动态代理

1. 前言

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两类：基于接口的动态代理，基于类的动态代理
  • 基于接口：JDK的动态代理
  • 基于类：cglib
  • java字节码实现：javasist

需要了解两个类：Proxy(代理)，invocationHandler(调用处理程序)

动态代理的实质是有一个代理处理器(实现InvocationHandler接口，实现接口的invoke方法) 此处理器持有 目标对象句柄。当客户端让代理对象执行方法时，代理处理器拦截方法后invoke（援引自己持有的目标对象处理）

2. 具体代码测试

三个类：接口UserService，接口实现UserServiceImpl，代理处理器ProxyInvocationHandler，主函数client

UserService

package com.snowdong.proxy;
public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

UserServiceImpl

package com.snowdong.proxy;

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("UserServiceImpl 调用了 add");
    }

    @Override
    public void delete() {
        System.out.println("UserServiceImpl 调用了 delete");
    }

    @Override
    public void update() {
        System.out.println("UserServiceImpl 调用了 update");
    }

    @Override
    public void query() {
        System.out.println("UserServiceImpl 调用了 query");
    }
}

ProxyInvocationHandler

package com.snowdong.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//使用这个类来，动态自动生成代理类！
//代理处理器
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;
    public void setTarget(Object target){
        this.target=target;
    }
    //生成得到代理类
    public Object getProxy(){
        /**newProxyInstance
         * - 参数1：表明你要用那个类加载器去加载生成的代理类。（一般为appClassLoader）。
         * - 参数2：说明你要生成的代理类的接口。
         * - 参数3：实现了InvocationHandle的类，这个类只有一个方法需要你要实现它。invoke()
         *     public static Object newProxyInstance(ClassLoader loader,
         *                                           Class<?>[] interfaces,
         *                                           InvocationHandler h)
         */
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    /**
     * @param proxy 对其调用方法的代理实例，是生成的代理类
     * @param method 是执行的方法(利用反射的原理，可以去看反射)
     * @param args 是执行某方法需要的参数
     * 代理类不是要代理某个对象么，然后增强里面的方法么，指得就是这个方法，代理类会为几乎所有方法都增强，除非你在这里做判断
     * @return  是执行这个方法所返回的值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        /**
         * method.invoke(target,args)
         * 第一个参数是你要增强的对象。第二个是参数。object是你返回的类型
         */
        Object result=method.invoke(target,args);
        return result;
    }
    public void log(String msg){
        System.out.println("[Debug]执行了"+msg+"方法");
    }
}

client

package com.snowdong.proxy;

public class Client {
    public static void main(String[] args) {
        //真实角色(即被代理的类/接口)
        UserService userService=new UserServiceImpl();
        //代理角色
        ProxyInvocationHandler pih=new ProxyInvocationHandler();
        //设置要代理的对象
        pih.setTarget(userService);
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
        proxy.delete();
        proxy.update();
        proxy.query();
    }
}

运行结果：

[Debug]执行了add方法
UserServiceImpl 调用了 add
[Debug]执行了delete方法
UserServiceImpl 调用了 delete
[Debug]执行了update方法
UserServiceImpl 调用了 update
[Debug]执行了query方法
UserServiceImpl 调用了 query

简单说明:
Proxy.newProxyInvocation(参数1.参数2，参数3)

• 参数1：表名你要用那个类加载器去加载生成的代理类。（这个是JVM类加载的知识，可以去了解一下，挺简单）。
• 参数2：说明你要生成的代理类的接口。
• 参数3：实现了InvocationHandle的类，这个类只有一个方法需要你要实现它。

invoke(Object proxy, Method method, Object【】 args) ｛

• 这个方法第一个参数，是生成的代理类，目前没发现用处，不管它。
• 第二个参数，是执行的方法(利用反射的原理，可以去看反射，也很简单。)
• 第三个参数，是执行某方法需要的参数。
• 第二个第三个参数解释执行的方法意思是：代理类不是要代理某个对象么，然后增强里面的方法么，指得就是这个方法，代理类会为几乎所有方法都增强，除非你在这里做判断。
• 返回值，是执行这个方法所返回的值。

然后你要去执行方法，就是用第二参数的invoke(obj,args);
Object object= method.invoke(obj,args);

• 第一个参数是你要增强的对象。
• 第二个是参数。
• object是你返回的类型