什么是代理模式

举个栗子，比如兰蔻想找安妮海瑟薇代言香水广告，假设兰蔻方代表为Jack，那么是不是Jack直接闯到Anne豪宅扯一嗓子“Anne 妹纸，我这有个私活你接不接”;实际情况肯定不是这样，且不说这个操作太鲁莽（搞不好还会被一枪崩掉），合作本身涉及的事项就很多，比如有木有档期，出场费怎么定价，要买哪些保险，税费怎么处理，违约责任等等，显然这里面财务、保险、法律相关的问题Anne一个人肯定搞不定，需要专业人士处理；而这所有的一切都可以交给Anne的经纪人（或者团队）Team来协办，作为一个艺人Anne只管拍广告就可以了。

在这个场景中，Jack是客户（代表兰蔻集团），Anne是艺人提供代言服务直接参与广告拍摄，Team是代理（帮Anne处理商务事宜），所有合作细节都是Jack找Team商谈完成，找Team谈合作一样能达成目标（拍代言广告），而且比直接找Anne本人效率更高，更稳妥。

静态代理

若代理类在程序运行前就已经存在，这种方式称为静态代理，这种情况下的代理类通常都是我们在Java代码中定义的（hard coding）。通常情况下，静态代理中的代理类和目标类（委托l类）会实现同一接口或是派生自相同的父类。
在这里插入图片描述
此例中，Atm是被代理的目标对象（委托对象），Crs持有Atm的引用，是代理对象，调用Crs的withdraw方法实际被转到Atm的withdraw

public interface Account { /*目标类与代理类都实现该接口*/
    String withdraw(double amount);
}
public class Atm implements Account{ /*自动取款机,目标类(被代理)*/
    @Override
    public String withdraw(double amount) { 
        return "取出"+ amount +"元";
    }
}
public class Crs implements Account { /*自动存取款机，此处为Atm的代理类*/
    private Account account = new Atm();/*持有被代理对象的引用,静态代理*/
    @Override
    public String withdraw(double amount) { 
        return account.withdraw(amount);/*取款调用的是目标对象的方法*/
    }
    public String deposit() { /*代理类可以有自己的业务操作*/
        return "存款120元";
    }
}
public class Test { 
    public static void main(String[] args) { 
        Crs crs = new Crs();/*创建代理对象*/
        System.out.println(crs.withdraw(100));
    }
}

静态代理的不足

静态代理实现简单容易理解，但是静态代理不能使一个代理类反复作用于多个不同的目标对象，代理对象直接持有目标对象的引用，导致代理对象和目标对象的耦合。如果Account接口还有另一个实现类也需要进行事务控制，那么就要定义一个新的代理类，这样就会产生许多重复的模版代码，代码复用率不高。而动态代理就可以很好的解决这类问题。

JDK动态代理

静态代理的代理关系在编译时确定，而动态代理的代理关系在运行时确定，动态代理更灵活。

JDK动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的

目标与代理的共同接口

public interface Account { /*目标类与代理类都实现该接口，接口定义业务操作*/
    String withdraw(double amount);
}

目标对象

public class Atm implements Account{ /*自动取款机,目标类*/
    @Override
    public String withdraw(double amount) { 
        return "取出"+ amount +"元";
    }
}

handler

//InvocationHandler，对代理类方法的调用会被转到该类的invoke()方法。
public class AtmInvocationHandler implements InvocationHandler { 
    private Object target;
    public AtmInvocationHandler(Object target) { /*绑定对象*/
        this.target = target;
    }
    public Object getProxy() { 
        /* 获取代理对象 参数说明： loader，指定代理对象的类加载器； interfaces，代理对象需要实现的接口数组； handler，方法调用的实际处理者 newProxyInstance()会返回一个实现了指定接口的代理对象，对该对象的所有方法调用都会转发给InvocationHandler.invoke()方法。 */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this); // 需要绑定接口
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        Object result = null;
        System.out.println("取款操作");
        result = method.invoke(target, args);
        System.out.println(result);
        System.out.println("取款完成");
        return result;
    }
}
public class Test { 
    public static void main(String[] args){ 
        AtmInvocationHandler handler = new AtmInvocationHandler(new Atm());
        Object atmProxy = handler.getProxy();
        Account accout = (Account)atmProxy;
        Object result = accout.withdraw(100.0);
    }
}
取款操作
取出100.0元
取款完成

JDK动态代理小结

代理类AtmInvocationHandler实现了InvocationHandler接口，与静态代理不同它持有的目标对象类型是Object，因此代理类AtmInvocationHandler能够代理任意的目标对象，给目标对象添加事务控制的逻辑。因此动态代理真正实现了将代码中横向切面逻辑的剥离，实现了代码复用。

JDK动态代理的缺点：
（一）通过反射类Proxy和InvocationHandler回调接口实现JDK动态代理，要求目标类必须实现一个接口，对于没有实现接口的类，无法通过这种方式实现动态代理。
（二）动态代理会为接口中的声明的所有方法添加上相同的代理逻辑，不够灵活

CGLIB动态代理

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB支持接口、继承方式实现代理。

原理 \color{blue}{原理} 原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势将横切逻辑织入（weave）目标对象

CGLIB代理实现步骤：

1、定义目标对象

public class Atm{ /*自动取款机,目标类，不需要实现指定接口*/
    public String withdraw(double amount) { 
        return "取出"+ amount +"元";
    }
    public String checkBalance() { 
        return "当前余额:" + 1200 + "元";
    }
}

2、定义拦截器。在调用目标对象的方法时，CGLib会回调MethodInterceptor接口的intercept方法实施拦截，来切入代理逻辑，类似于JDK中的InvocationHandler接口

public class AtmInterceptor implements MethodInterceptor { 
    /** * obj：cglib生成的代理对象 * method：被代理对象方法 * args：方法入参 * methodProxy: 代理方法 */    
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
        System.out.println("事务开始");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println(result);
        System.out.println("事务结束");
        return result;
    }
}

3、在需要使用目标对象的时候，通过CGLIB动态代理获取代理对象。

public class Test { 
    public static void main(String[] args) { 
        //class 文件缓存目录，如果不研究动态类的源码可以不设置
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\cglib_classes");    
        //用于创建代理对象的增强器，可以对目标对象进行扩展
        Enhancer enhancer = new Enhancer();
        //将目标对象设置为父类
        enhancer.setSuperclass(Atm.class);
        //设置目标拦截器
        enhancer.setCallback(new AtmInterceptor());
        // 创建代理对象
        Atm atm = (Atm)enhancer.create();
        // 通过代理对象调用目标方法
        Object result = atm.withdraw(100);
        atm.checkBalance();
    }
}

目标对象的每个方法调用都会被拦截

CGLIB debugging enabled, writing to 'D:\cglib_classes'
事务开始
取出100.0元
事务结束
事务开始
当前余额:1200元
事务结束

以上代码通过CGLIB的Enhancer指定要代理的目标对象（即包含实际业务逻辑的对象），再通过调用create()方法得到代理对象，所有对代理对象的非final方法的调用都会指派给AtmInterceptor.intercept()方法，在intercept()方法中可以加入目标对象之外的业务逻辑，比如参数校验、日志审计、安全检查等功能；通过调用MethodProxy.invokeSuper()方法，将调用转发给原始对象，也就是本例的Atm 。CGLIG中MethodInterceptor的作用与JDK代理中的InvocationHandler类似，都是方法调用的中转派发。