Aop切面编程（2）--代理模式

1、代理模式的理解：不修改A对象的代码的基础上，对A代码块进行拓展。通过创建ProxyA代理对象，拓展A对象并调用A对象的核心功能；

即：不修改对象的源码基础上，创建代理对象，进行功能的附加和增强；

2、代理的分类：1）静态代理；2）动态代理（jdk,cglib）；

3、静态代理：在编译的过程中就已经将代理对象、被代理对象、接口确定下来了，class文件已经生成了；

实现步骤：
1、定义一个接口及其实现类；
2、创建一个代理类同样实现这个接口
3、将目标对象注注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。

3.1）定义一个接口及方法ParentPrint：

package com.example.demo.proxy;  public interface ParentPrint {     void print(String content); } 

3.2）定义一个被代理的类，并实现接口ParentPrint,其中print方法就是我们需要代理的核心方法；

package com.example.demo.proxy;   public class Printer implements  ParentPrint {      @Override     public void print(String content) {         System.out.println(content);     } } 

3.3）定义代理类，构造一个有参数的构造器，并重写print方法（其中通过传入的参数调用被代理对象的print方法）。

package com.example.demo.proxy;  /* 1、首先需要代理类ProxyStaticPrinter和被代理类Printer同时实现一个共同的接口 ； 2、代理类ProxyStaticPrinter需要在构造方法中注入接口定义对象，并重写代理的方法print（前置后置处理）,在其中加入注入对象的print方法； 3、实例化代理对象ProxyStaticPrinter，实例化被代理对象Printer； 4、将被代理对象通过参数注入到代理对象（ProxyStaticPrinter）有参构造器中； 5、代理对象调用处理过的方法； */ public class ProxyStaticPrinter implements ParentPrint {      private ParentPrint parentPrint;       public ProxyStaticPrinter(ParentPrint parentPrint) {         this.parentPrint = parentPrint;     }      @Override     public void print(String content) {         System.out.println("前置操作");         parentPrint.print(content);         System.out.println("后置操作");     }  }   

3.4）测试，定义一个代理对象，将代理对象通过参数传入被代理的对象中；

    //测试     public static void main(String[] args) {         ParentPrint parentPrint = new Printer();         ParentPrint ProxyParentPrint = new ProxyStaticPrinter(parentPrint);         ProxyParentPrint.print("测试");     }

运行

3.5）总结：

将目标对象注注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问；

优点：被代理类无需实现接口
缺点：只能代理这个类，要想代理其他类，要想代理其他类需要写新的代理方法。

4、动态代理：动态代理包含了jdk动态代理和cglib动态代理；

4.1）jkd动态代理：

实现步骤：
1、定义一个接口及其实现类；
2、自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
3、通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

4.1.1）定义一个接口

package com.example.demo.proxy;  public interface ParentPrint {     void print(String content); } 

4.1.2）定义一个接口及方法ParentPrint：

package com.example.demo.proxy;  public interface ParentPrint {     void print(String content); } 

4.1.3）定义一个被代理的类，并实现接口ParentPrint,其中print方法就是我们需要代理的核心方法；

package com.example.demo.proxy;   public class Printer implements  ParentPrint {      @Override     public void print(String content) {         System.out.println(content);     } } 

4.1.4）定义一个代理类ProxyJdkPrinter并实现InvocationHandler，实现invoke方法，最终调用method.invoke(parentPrint,args)；

注意该Proxy类中是静态方法，且接收的三个参数依次为：

ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的。
Class<?>[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型。
InvocationHandler：事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法作为参数传入。

package com.example.demo.proxy;  import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;   /*jdk动态代理：前提目标类必须有父接口（接口：ParentPrint,目标类：Printer） 1、创建ProxyJdkPrinter类，继承接口InvocationHandler创建代理类的调用处理程序； 2、同样引入代理类的参数对象private ParentPrint parentPrint; 3、实现invoke方法，最终调用method.invoke(parentPrint,args)； 4、测试： 实例化代理类p1； 将p1放入代理类ProxyJdkPrinter； 通过Proxy类的WuDaInvocationHandler方法创建代理对象； 代理对象调用被代理的方法； * */ public class ProxyJdkPrinter implements InvocationHandler {      private ParentPrint parentPrint;       public ProxyJdkPrinter(ParentPrint parentPrint) {         this.parentPrint = parentPrint;     }       @Override     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {         String name = method.getName();         if(name.equals("print")){             System.out.println("jdk增加操作");         }         return method.invoke(parentPrint,args);     }  }   

4.1.5）测试，invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。

    public static void main(String[] args) {         ParentPrint p1 = new Printer();         ProxyJdkPrinter proxyJdkPrinter = new ProxyJdkPrinter(p1);         //newProxyInstance:创建代理实例对象         //三个参数：         //1、 目标类的类加载器 2、目标类的父接口  3、handler         ParentPrint proxyPrint = (ParentPrint)Proxy.newProxyInstance(p1.getClass().getClassLoader(), p1.getClass().getInterfaces(), proxyJdkPrinter);         proxyPrint.print("测试");     }

运行

4.1.6）总结：

通过java提供的Proxy类帮我们创建代理对象，基于接口的动态代理需要利用JDK中的API，在JVM内存中动态的构建Proxy对象；
优点：可以生成所有实现接口的代理对象
缺点：JDK反射生成代理必须面向接口, 这是由Proxy的内部实现决定的。生成代理的方法中你必须指定实现类的接口，它根据这个接口来实现代理类生成的所实现的接口。

4.2）cglib动态代理：当目标没有实现类的时候，可以使用；

实现步骤：

1、定义一个类；
2、自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
3、通过 Enhancer 类的 create()创建代理类；

4.2.1)定义一个被代理类Printer

package com.example.demo.proxy;   public class Printer1 {      public void print(String content) {         System.out.println(content);     } } 

4.2.2)定义一个代理类ProxyCglibPrinter，并实现MethodInterceptor

package com.example.demo.proxy;  import org.springframework.cglib.proxy.Enhancer; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy;  import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;   /*cglib动态代理：（目标对象不需要实现接口） 实现MethodInterceptor 接口，在调用目标对象的方法时，就可以实现在调用方法之前、调用方法过程中、调用方法之后对其进行控制。 1.创建目标对象target； 2.创建interceptor对象 3.创建Enhancer对象，它以目标类和interceptor作为原料，生产出代理对象 4、enhancer设置参数setSuperclass，setCallback 5、创建代理类proxy,调用需要代理的方法； * */ public class ProxyCglibPrinter implements MethodInterceptor {       @Override     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {         String name = method.getName();         if(name.equals("print")){             System.out.println("cglib增加操作");         }         methodProxy.invokeSuper(o,objects);         return null;     }  }   

4.2.3）测试

    public static void main(String[] args) {         Printer1 target = new Printer1();         ProxyCglibPrinter interceptor = new ProxyCglibPrinter();         Enhancer enhancer = new Enhancer();         enhancer.setSuperclass(target.getClass());         enhancer.setCallback(interceptor);         Printer1 proxy = (Printer1)enhancer.create();         proxy.print("测试");     }

运行

4.2.4)总结：

无需代理类实现接口，使用Cblib中的Enhancer来生成代理对象子类，并实现MethodInterceptor中的intercept方法，在此方法中可以实现增强功能。

如果目标对象需要实现接口，则使用JDK代理。
如果目标对象不需要实现接口，则使用Cglib代理。

5、综上所述，再次总结：

静态代理：

jdk动态代理：

cglib动态代理：