代理模式分类

一、代理概念

　　代理的两种模式静态代理和动态代理，这个是怎么区别的我们谈一下，Java中都是通过编译器生成.class文件，在通过JVM读取，
然后加载到内存中，生成对应的需要对象，根据代理类创建的时间分成静态和动态代理，静态的代理就是在程序运行前.class文件就存在，
我们经常使用的代理模式就是静态代理，动态代理就是程序运行时动态创建，比如JDK的动态代理和CGLB代理；

二、静态代理----代理模式

   这里我们使用取款机这个例子来说一下，现在假如说你是招商的银行卡，你需要在工商取款机取款，这里有个规定那就是每笔需要收费2元，这个工商取款机就是代理对象，你的目标对象就是取款，我们抽象一个取款的接口WithdrawService,招商取款机上面的实现取款机接口ATM，然后工商取款机ATMProxy实现代理角色；当然这里我简化很多步骤；

/**
 * 抽象的取款接口
 */
public interface WithdrawService {
    int GetByMoneyWithdraw(int money);
}

/**
 * ATM机实现的接口
 */
public class ATM implements WithdrawService{
    @Override
    public int GetByMoneyWithdraw(int money) {
        System.out.print("取款"+money);
        return money;
    }
}

/**
 * 代理对象
 */
public class ATMProxy implements WithdrawService {
    private ATM atm;
    public ATMProxy(ATM atm){
        this.atm=atm;
    }
    @Override
    public int GetByMoneyWithdraw(int money) {

        int proxyMoney=2;
        System.out.print("取款"+money+":"+"手续费"+proxyMoney);
        atm.GetByMoneyWithdraw(money+proxyMoney);
        return money+proxyMoney;
    }
}
/**
 * 测试类
 */
public class ProxyTest {
    public static void main(String[] args){
        WithdrawService withdrawService=new ATMProxy(new ATM());
        withdrawService.GetByMoneyWithdraw(1000);
    }
}

以上就是静态代理，在运行前就生成，代理模式的优点就在于不直接依赖于目标对象，而是通过代理对象作为中间对象也就是我们经常说的解耦；另外代理对象还可以对实现的方法进行增强，增加自己的规则，这里我们思考一个问题:当我们每增加一个代理类的时候，我就需要编写一个类，这样我们代码通用很差，另外这样子会照成系统更加复杂，执行速度更加慢；这就背离了我们设计的原则，那么怎么避免这种问题？

三、动态代理----JDK动态代理

   针对于上面提出的问题，通过反射机制，JDK给我们提供Proxy类，这个只是针对于接口的增强，在JVM运行时动态创建生成。这里简单说一下JDK通过接口动态生成代理对象的过程：

    1.获取WithdrawService接口下所有方法；

    2.生成代理类，默认为命名空间+$+Proxy+类名；

    3.根据接口，在代码中动态创建代理的字节码文件；

    4.将字节码文件转化为class文件；

    5.创建InvocationHandler实例handler,来处理代理的方法调用

    6.Proxy的class对象以创建的handler对象为参数，实例一个proxy对象；

   下面我们展示一下JDK实现代理:

/**
 * 抽象的取款接口
 */
public interface WithdrawService {
    int GetByMoneyWithdraw(int money);
}

/**
 * ATM机实现的接口
 */
public class ATM implements WithdrawService{
    @Override
    public int GetByMoneyWithdraw(int money) {
        System.out.print("取款"+money);
        return money;
    }
}

/**
 * JDK动态代理的实现
 */
public class ATMJDKProxy implements InvocationHandler {
    //目标对象
    private Object target;
    //构建目标对象
    public ATMJDKProxy(Object target){
        super();
        this.target=target;
    }
    //获取目标的代理对象
    public Object getProxy(){
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),this.target.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.print("执行前处理什么事情");
        Object result = method.invoke(target, args);
        System.out.print("执行后处理什么事情");
        return result;
    }
}

/**
 * 测试类
 */
public class ProxyTest {

    public static void main(String[] args) {
        WithdrawService withdrawService=new ATM();
        ATMJDKProxy atmjdkProxy=new ATMJDKProxy(withdrawService);
        WithdrawService proy= (WithdrawService) atmjdkProxy.getProxy();
        proy.GetByMoneyWithdraw(1000);
    }
}

四、动态代理----CGLIB动态代理 

   JDK动态代理只能实现对接口方法的增强，不能实现对接口类的的动态代理。那么我们想动态生成类的时候怎么办，不用想了那就是使用CGLIB类库；这个当然也是在JVM运行时动态创建，这里也简单描述下生成ATM动态代理类的过程：

   1.查找ATM类中的非final的public类型方法；

   2.将这些方法定义转化为字节码；

   3.将组成字节码转化为代理的Clss类；

   4.实现MethodInterceptor 接口，用来处理代理方法上的请求；

   下面我们展示一下CGLIB实现代理:

/**
 * ATM不实现接口
 */
public class ATM {
    public int GetByMoneyWithdraw(int money) {
        System.out.print("取款"+money);
        return money;
    }
}

/**
 * 实现MethodInterceptor
 */
public class ATMCGLIBProxy implements MethodInterceptor {
    private Object target;
    public Object getInstance(Object target){
        this.target=target;
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("开始前");
        methodProxy.invokeSuper(o,objects);
        System.out.println("开始后");
        return null;
    }
}
/**
 * 测试类
 */
public class ProxyTest {

      public static void main(String[] args) {
          ATMCGLIBProxy cglib=new ATMCGLIBProxy();
          ATM atm = (ATM) cglib.getInstance(new ATM());
          atm.GetByMoneyWithdraw(1000);
      }
}

以上是基本实现，这里我们简单说一下CGLIB底层是通过使用字节码处理框架ASM，来转换字节码并生成新的类；什么是ASM？ASM是一个Java字节码操纵框架，它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件，也可以在类被加载入 Java 虚拟机之前动态改变类行为。Java class 被存储在严格格式定义的 .class文件里，这些类文件拥有足够的元数据来解析类中的所有元素：类名称、方法、属性以及 Java 字节码（指令）。ASM从类文件中读入信息后，能够改变类行为，分析类信息，甚至能够根据用户要求生成新类。

   这里需要注意使用这个的时候需要引入：cglib-nodep-2.2.jar；cglib-2.2.jar；asm-3.2jar;

 五、动态代理----应用场景

  大家执行过上面的代码以后会有一种是曾相识的感觉，在方法执行前做一些事，在方法执行后做一些事，使我们很容易想到Spring Aop中的通知，这里确实有用到动态代理，至于别的我暂时还没有想到，等等那天解读Spring源码的时候我们再来探讨一下，到此结束；