Java动态代理之通俗理解

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方法是什么时候执行的，谁来调用的此方法

解析1>>怎么产生代理对象：

@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