Java动态代理之通俗理解

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java动态代理之通俗理解相关的知识,希望对你有一定的参考价值。

代理模式介绍

代理模式是一种常用的设计模式,其作用就是为目标对象提供额外的访问方式,在不修改目标对象的前提下,扩展目标对象的额外功能,比如统计执行时间,打印日志等。

代理模式分为两种:静态代理和动态代理。

需求:假如不想改动原有代码情况下,并记录用户保存方法的执行时间。示例代码如下:

接口

public interface UserService {
    public void saveUser(User user);
}

实现类

public class UserServiceImpl implements UserService {

    private UserDao userDaoImpl;

    @Override
    public void saveUser(User user) {
        userDaoImpl.save(user); 
    }
    ...
}

静态代理实现

静态代理是在程序运行前产生的,一般来说,代理类和目标类实现同一接口或者有相同的父类

代理类

public class UserServiceProxyImpl implements UserService {

    private UserService UserServiceImpl;//代理类持有一个委托类的对象引用

    public UserServiceProxyImpl(UserService UserServiceImpl) {
        this.UserServiceImpl = UserServiceImpl;
    }

    @Override
    public void saveUser(User user) {
        long startTime = System.currentTimeMillis();
        System.out.println("开始记录时间");
        delegate.dealTask(taskName);    // 将请求分派给委托类处理
        long endTime = System.currentTimeMillis();
        System.out.println("保存用户信息方法耗时" + (endTime-startTime) + "毫秒");
    }
}

产生代理对象的静态工厂类

public class UserServiceProxyFactory {
    public static UserService getInstance() {
        return new UserServiceProxyImpl(new UserServiceImpl());
    }
}

客户端

public class ClientTest {
    public static void main(String[] args) {
        UserService UserServiceProxy = UserServiceProxyFactory.getInstance();
        UserServiceProxy.saveUser(new User("1","张三"));
    }
}

运行结果

开始记录时间
保存用户信息方法耗时0.01毫秒

静态代理优缺点:

优点:

1、业务类UserServiceImpl只需要关注业务逻辑本身,保证了业务类的重用性。

2、客户端Client和业务类UserServiceImpl之间没有直接依赖关系,对客户的而言屏蔽了具体实现。

缺点:

1、代理对象的一个接口只服务于一种接口类型的对象,静态代理在程序规模稍大时就无法使用。

2、如果接口增加一个方法,除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度

动态代理实现

动态代理是程序在运行过程中在JVM内部动态产生的代理对象,代理类可以实现对多种类的代理。

动态代理又分为两种:JDK动态代理和CGLIB动态代理。

JDK动态代理

JDK动态代理需先声明一个代理类和目标类之间的中间类,此中间类需要实现jdk中的一个接口InvocationHandler。源码如下:

package java.lang.reflect;
public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

产生代理对象的中间类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKProxy implements InvocationHandler {

    private Object target; //持有目标对象的引用
    public JDKProxy(Object target){
        this.target = target;
    }

    //创建代理对象
    public Object createProxy(){
         //1.得到目标对象的classloader
        ClassLoader classLoader = target.getClass().getClassLoader();
         //2.得到目标对象的实现接口的class[]
        Class<?>[] interfaces = target.getClass().getInterfaces();

        //3.第三个参数需要一个实现InvocationHandler接口的对象
        //3-1.第一种写法,让当前类实现InvocationHandler,第三个参数写this
        return Proxy.newProxyInstance(classLoader, interfaces, this);

        //3-2.第二种写法,第三个参数用匿名内部类的形式,先注释掉
        /*return Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                long startTime = System.currentTimeMillis();
                System.out.println("开始记录时间");
                Object ret = method.invoke(target, args);   //执行目标对象方法,此处写target如果写proxy会死循环直到内存溢出
                long endTime = System.currentTimeMillis();
                System.out.println("保存用户信息方法耗时" + (endTime-startTime) + "毫秒");
                return ret;
            }
        });*/
    }
    /* 
    在代理实例上执行目标对象的方法 
    参数1 就是代理对象,一般不使用
    参数2 它调用的方法的Method对象
    参数3 调用的方法的参数
    */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.currentTimeMillis();
        System.out.println("开始记录时间");
        Object ret = method.invoke(target, args);//执行目标对象方法,此处写target如果写proxy会死循环直到内存溢出
        long endTime = System.currentTimeMillis();
        System.out.println("保存用户信息方法耗时" + (endTime-startTime) + "毫秒");
        return ret;
    }

}

客户端

public class ProxyTest {
    @Test
    public void test1() {
        UserService userService = new UserServiceImpl();    //1.创建目标对象
        JDKProxy factory = new JDKProxy(userService);   // 2.通过JKDProxy完成代理对象创建
        UserService userServiceProxy = (UserService)factory.createProxy();
        userServiceProxy.saveUser(new User("1","张三"));
    }
}

JDK动态代理中,需要关注的两点:

1、Proxy.newProxyInstance(classLoader, interfaces, this); 底层是怎么创建的代理对象

2、invoke方法是什么时候执行的,谁来调用的此方法

<font color=red>解析1>></font>怎么产生代理对象:

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
    throws IllegalArgumentException
    {
    if (h == null) {
        throw new NullPointerException();
    }
    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }
    /*
    * Look up or generate the designated proxy class.
    */
    Class<?> cl = getProxyClass0(loader, intfs);
    /*
    * Invoke its constructor with the designated invocation handler.
    */
    try {
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
            // create proxy instance with doPrivilege as the proxy class may
            // implement non-public interfaces that requires a special permission
            return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                public Object run() {
                    return newInstance(cons, ih);
                }
            });
        } else {
            return newInstance(cons, ih);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString());
    }
}

//继续看newInstance方法
private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
    try {
        return cons.newInstance(new Object[] {h} );
    } catch (IllegalAccessException | InstantiationException e) {
        throw new InternalError(e.toString());
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString());
        }
    }
}

由此可以看出创建代理对象,是利用反射,先获取目标对象的构造器,然后在通过构造反射生成代理对象

<font color=red>解析2>></font>invoke方法什么时候被调用:

我们通过一个工具类把生成的代理对象的字节码输出到磁盘,然后通过反编译来查看代理对象有哪些内容

工具类如下:

public class ProxyGeneratorUtils {
    /**
        * 把代理类的字节码写到硬盘上
        * @param fileName 文件名
        * @param path 路径信息
        * @param clazz 目标类的接口数组
        */
    public static void writeProxyClassToHardDisk(String fileName, String path, Class<?>[] clazz) {
        byte[] classFile = ProxyGenerator.generateProxyClass(fileName, clazz);
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(path);
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //主方法
    public static void main(String[] args) {
        ProxyGeneratorUtils.writeProxyClassToHardDisk("$JDKProxy1","F:/$JDKProxy1.class",UserServiceImpl.class.getInterfaces());
    }
}

运行main方法生成代理对象字节码文件,用JD.exe反编译打开如下

public final class $JDKProxy1 extends Proxy implements UserService {
    private static Method m1;
    private static Method m3;
    private static Method m0;
    private static Method m2;

    public $JDKProxy1(InvocationHandler arg0) throws  {
        super(arg0);
    }
    public final void saveUser(User arg0) throws  {
            try {
                super.h.invoke(this, m3, new Object[]{arg0});
            } catch (RuntimeException | Error arg2) {
                throw arg2;
            } catch (Throwable arg3) {
                throw new UndeclaredThrowableException(arg3);
            }
        }
    ...

用一张图来说明调用userServiceProxy代理对象的saveUser()方法内部发生了什么

技术分享图片

CGLIB动态代理

cglib动态代理也需要一个产生代理对象的中间类,此类需实现MethodInterceptor接口,此接口在cglib包中,目前已经被spring整合,在spring-core核心包中<br>

产生代理对象的中间类

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class CglibProxy implements MethodInterceptor {

    private Object target; //持有目标对象的引用
    public CglibProxy(Object target){
        this.target = target;
    }
    //创建代理对象
    public Object createProxy(){
        Enhancer enhancer = new Enhancer(); //1.创建Enhancer
        enhancer.setSuperclass(target.getClass());  //2.传递目标对象的class
        enhancer.setCallback(this); //3.设置回调操作(相当于InvocationHanlder)
        return enhancer.create();
    }
    //相当于InvocationHanlder中的invoke
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        long startTime = System.currentTimeMillis();
        System.out.println("开始记录时间");
        Object ret = method.invoke(target, args);//执行目标对象方法,此处写target如果写proxy会死循环直到内存溢出
        long endTime = System.currentTimeMillis();
        System.out.println("保存用户信息方法耗时" + (endTime-startTime) + "毫秒");
        return ret;
    }
}

客户端

public class ProxyTest {
    @Test
    public void test1() {
        UserService userService = new UserServiceImpl();    //1.创建目标对象
        CglibProxy factory = new CglibProxy(customerService);   // 2.通过CglibProxy完成代理对象创建
        UserService userServiceProxy = (UserService)factory.createProxy();
        userServiceProxy.saveUser(new User("1","张三"));
    }
}

产生代理对象字节码,用JD.exe反编译如下

import java.lang.reflect.Method;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class UserServiceImpl$$EnhancerByCGLIB$$1772a9ea extends UserServiceImpl implements Factory {
    ...
    public final void saveUser(User paramUser)
    {
        MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
        if (tmp4_1 == null){
            tmp4_1;
            CGLIB$BIND_CALLBACKS(this);
        }
        if (this.CGLIB$CALLBACK_0 != null) return;
        super.saveUser(paramUser);
    }
    ...
}

JDK动态代理和CGLIB动态代理区别:

1、JDK动态代理是针对于接口代理,目标类必须实现了接口,产生的代理对象也会实现该接口。

2、CGLIB代理是采用继承,产生的代理对象继承于目标类,所以目标类和目标方法不能用final修饰。

以上是关于Java动态代理之通俗理解的主要内容,如果未能解决你的问题,请参考以下文章

java反射与动态代理的理解

java反射和动态代理有啥关系

Java设计模式之动态代理

@protocol(协议)和@delegate(代理)的个人理解 通俗易懂

深入理解设计模式-代理模式(静态代理动态代理jdk和cglib)

Java重要技术(27)动态代理之查看代理对象的类型信息