设计模式--代理模式

代理模式
　　定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

　　举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。用图表示如下：

 

　　1.1 为什么要用代理模式？
　　　　中介隔离作用：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。

　　　　开闭原则，增加功能：代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

　　代理模式分为三类：1. 静态代理 2. 动态代理 3. CGLIB代理

　　1.2 静态代理

　　举例(买房），类图如下：

 

 

　　第一步：创建服务类接口

　　　　public interface BuyHouse {
　　　　　　void buyHosue();
　　　　}
　　第二步：实现服务接口

　　　　public class BuyHouseImpl implements BuyHouse {
　　　　　　@Override
　　　　　　public void buyHosue() {
　　　　　　　　System.out.println("我要买房");
　　　　　　}
　　　　}
　　第三步：创建代理类

　　　　public class BuyHouseProxy implements BuyHouse {
　　　　　　private BuyHouse buyHouse;
　　　　　　public BuyHouseProxy(final BuyHouse buyHouse) {
　　　　　　　　this.buyHouse = buyHouse;
　　　　　　}
　　　　　　@Override
　　　　　　public void buyHosue() {
　　　　　　　　System.out.println("买房前准备");
　　　　　　　　buyHouse.buyHosue();
　　　　　　　　System.out.println("买房后装修");
　　　　　　}
　　　　}
　　总结：

　　优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。

　　缺点： 代理对象与目标对象要实现相同的接口，我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。

　　1.3 动态代理
　　动态代理有以下特点:

　　　　1.代理对象,不需要实现接口

　　　　2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)

　　　　代理类不用再实现接口了。但是，要求被代理对象必须有接口。

　　动态代理实现：

　　Java.lang.reflect.Proxy类可以直接生成一个代理对象

　　　　Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)生成一个代理对象

　　　　　　参数1:ClassLoader loader 代理对象的类加载器 一般使用被代理对象的类加载器

　　　　　　参数2:Class<?>[] interfaces 代理对象的要实现的接口 一般使用的被代理对象实现的接口

　　　　　　参数3:InvocationHandler h (接口)执行处理类

　　　　InvocationHandler中的invoke(Object proxy, Method method, Object[] args)方法：调用代理类的任何方法，此方法都会执行

　　　　　　参数3.1:代理对象(慎用)

　　　　　　参数3.2:当前执行的方法

　　　　　　参数3.3:当前执行的方法运行时传递过来的参数

　　第一步：编写动态处理器

　　public class DynamicProxyHandler implements InvocationHandler {
　　　　private Object object;
　　　　public DynamicProxyHandler(final Object object) {
　　　　　　this.object = object;
　　　　}
　　　　@Override
　　　　public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
　　　　　　System.out.println("买房前准备");
　　　　　　Object result = method.invoke(object, args);
　　　　　　System.out.println("买房后装修");
　　　　　　return result;
　　　　}
　　　}
　　第二步：编写测试类

　　public class DynamicProxyTest {
　　　　public static void main(String[] args) {
　　　　　　BuyHouse buyHouse = new BuyHouseImpl();
　　　　　　BuyHouse proxyBuyHouse = (BuyHouse) Proxy.newProxyInstance(BuyHouse.class.getClassLoader(), new
　　　　　　Class[]{BuyHouse.class}, new DynamicProxyHandler(buyHouse));
　　　　　　proxyBuyHouse.buyHosue();
　　　　}
　　}
　　动态代理总结：虽然相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持interface代理的桎梏（我们要使用被代理的对象的接口），因为它的设计注定了这个遗憾。

　　1.4 CGLIB代理

　　CGLIB 原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。

　　CGLIB 底层：使用字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

　　CGLIB缺点：对于final方法，无法进行代理。

　　CGLIB的实现步骤：

　　第一步：建立拦截器

　　public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

　　　　System.out.println("买房前准备");

　　　　Object result = methodProxy.invoke(object, args);

　　　　System.out.println("买房后装修");

　　　　return result;

　　}
　　参数：Object为由CGLib动态生成的代理类实例，Method为上文中实体类所调用的被代理的方法引用，Object[]为参数值列表，MethodProxy为生成的代理类对方法的代理引用。

　　返回：从代理实例的方法调用返回的值。

　　其中，proxy.invokeSuper(obj,arg) 调用代理类实例上的proxy方法的父类方法（即实体类TargetObject中对应的方法）

　　第二步： 生成动态代理类

　　public class CglibProxy implements MethodInterceptor {
　　　　private Object target;
　　　　public Object getInstance(final Object target) {
　　　　　　this.target = target;
　　　　　　Enhancer enhancer = new Enhancer();
　　　　　　enhancer.setSuperclass(this.target.getClass());
　　　　　　enhancer.setCallback(this);
　　　　　　return enhancer.create();
　　　　}
　　　　public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
　　　　　　System.out.println("买房前准备");
　　　　　　Object result = methodProxy.invoke(object, args);
　　　　　　System.out.println("买房后装修");
　　　　　　return result;
　　　　　　}
　　　　}
　　这里Enhancer类是CGLib中的一个字节码增强器，它可以方便的对你想要处理的类进行扩展，以后会经常看到它。

　　首先将被代理类TargetObject设置成父类，然后设置拦截器TargetInterceptor，最后执行enhancer.create()动态生成一个代理类，并从Object强制转型成父类型TargetObject。

　　第三步：测试

　　　　public class CglibProxyTest {
　　　　　　public static void main(String[] args){
　　　　　　BuyHouse buyHouse = new BuyHouseImpl();
　　　　　　CglibProxy cglibProxy = new CglibProxy();
　　　　　　BuyHouseImpl buyHouseCglibProxy = (BuyHouseImpl) cglibProxy.getInstance(buyHouse);
　　　　　　buyHouseCglibProxy.buyHosue();
　　　　　　}
　　　　}
　　CGLIB代理总结： CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。