设计模式之代理模式

代理模式的基本介绍：

1. 代理模式：为一个对象提供一个替身，以控制这个对象的访问。即通过代理对象访问目标对象，这样做的好处是可以在目标对象实现的基础上，增强额外功能的操作，即扩展目标对象的功能。
2. 被代理的对象可以是远程对象，创建开销大的对象或需要安全控制的对象。
3. 代理模式由不同的形式，主要有三种静态代理、动态代理（JDK代理，接口代理）、Cglib代理（可以在内存动态的创建对象，而不需要实现接口，属于动态代理的一种）。
4. 代理模式示意图：

静态代理：

静态代理在使用时，需要定义接口或者父类，被代理对象（即目标对象）与代理对象一起实现相同的接口或者继承相同的父类。

应用案例：

1. 定义一个接口，ITeacher。
2. 目标对象Teacher实现接口ITeacher。
3. 使用静态代理方式，需要在代理对象StaticProxy中也实现ITeacher接口。
4. 调用的时候通过调用代理对象的方法来调用目标对象。
5. 注意：代理对象和目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法。

代码实现：

/**  * 定义接口  * @author Administrator  *  */ public interface ITeacher {     //教师教学     void teach();          //接收参数信息     String sayHello(String str); }     /**  * 实现类  */ public class Teacher implements ITeacher {     @Override     public void teach() {         System.out.println("老师讲课......");     }     @Override     public String sayHello(String str) {         System.out.println("接收的参数:" + str);         return str;     } }         /**  * 测试类  * @author Administrator  *  */ public class Client {     public static void main(String[] args) {         Teacher teacher = new Teacher();         StaticProxy staticProxy = new StaticProxy(teacher);         staticProxy.teach();         staticProxy.sayHello("我是王老师");     } }

静态代理优缺点分析：

1. 优点：在不修改目标对象的功能前提下，能通过代理对象对目标功能扩展。
2. 缺点：因为代理对象需要与目标对象实现一样的接口，所有会有很多代理类。
3. 一旦增加方法，目标对象与代理对象都要维护。

动态代理：

1. 代理对象，不需要实现接口，但是目标对象要实现接口，否则不能动态代理。
2. 代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象。
3. 动态代理也叫作：JDK代理，接口代理。

JDK中生成代理对象的API：代理类所在包：java.lang.reflect.Proxy，JDK实现代理只需要使用newProxyInstance方法，但是该方法需要接受三个参数，完整的写法： static Object newProxyInstance(ClassLoader loader,Class<?> [] interfaces,InvocationHandler handler)

JDK动态代理应用实列：

/**  * 定义接口  * @author Administrator  *  */ public interface ITeacher {     //教师教学     void teach();          //接收参数信息     String sayHello(String str); }       /**  * 实现类  */ public class Teacher implements ITeacher {     @Override     public void teach() {         System.out.println("老师讲课......");     }     @Override     public String sayHello(String str) {         System.out.println("接收的参数:" + str);         return str;     } }       import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class JdkProxy {          //维护一个目标对象     private Object obj;          public JdkProxy(Object obj) {         this.obj = obj;     }     /**      * 写代理的方法      * @return      */     public Object getProxyInstance() {                  /**          * ClassLoader loader:指定当前目标对象使用的类加载器，获取加载器的方法固定          * Class<?> interfaces:目标对象实现的接口类型，使用泛型方法确认类型          * InvocationHandler handler:事情处理，执行目标对象的方法时，会触发事情处理器方法，会把当前执行的目标对象方法作为参数传递          */         return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),                  new InvocationHandler() {                                          @Override                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                         System.out.println("动态代理开始");                         Object invoke = method.invoke(obj, args);                         System.out.println("动态代理结束");                         return invoke;                     }                                      });      } }         /**  * jdk的动态代理  * @author Administrator  *  */ public class Client {     public static void main(String[] args) {         ITeacher teacher = new Teacher();         ITeacher proxy = (ITeacher)new JdkProxy(teacher).getProxyInstance();         proxy.teach();         System.out.println("----------");         proxy.sayHello("我是王老师");     } }

Cglib代理：

Cglib代理介绍：

静态代理和JDK的动态代理模式都要求目标对象实现一个接口，但是有时候目标对象只是一个单独的对象，并没有任何的接口，这个时候可用使用目标对象子类来实现->Cglib代理。

Cglib代理也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能扩展，Cglib也是动态代理的一种。

Cglib是一个强大高性能的代码生成包，它可以在运行期间扩展java类与实现java接口，被许多AOP框架广泛使用，SpringAOP用它实现方法的拦截。

在AOP编程中选择代理模式的方法：

1. 目标对象需要实现接口，用JDK代理
2. 目标对象不需要实现接口，用Cglib代理

Cglib使用需要导入额外的jar包，有asm.jar,asm-commons.jar,asm-tree.jar,cglib.jar。在内存中动态的构建子类，代理类不能使用final，否则不会报错，对目标对象方法如果为final/static，那么不会被拦截，即不会执行目标对象额外的业务方法。

Cglib应用实列;

package com.yu.demo.proxy.cglib; public class Teacher  {          public void teach() {         System.out.println("老师讲课......");     }          public String sayHello(String str) {         System.out.println("接收的参数:" + str);         return str;     } }       import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; /**  * cglib的代理  * @author Administrator  */ public class CglibProxy implements MethodInterceptor{          private Object target;          public CglibProxy(Object target) {         this.target = target;     }          //返回一个代理对象，是target对象的代理模式     public Object getProxyInstance() {         //创建代理的工具类         Enhancer enhancer = new Enhancer();         //设置父类信息         enhancer.setSuperclass(target.getClass());         //设置回调函数         enhancer.setCallback(this);         //创建子类对象，即代理对象         return enhancer.create();     }     //重写intercept方法，会调用目标对象的方法     @Override     public Object intercept(Object obj, Method method, Object[] args, MethodProxy arg3) throws Throwable {         System.out.println("cglib的代理模式开始....");         Object invoke = method.invoke(target, args);         System.out.println("cglib的代理模式结束....");         return invoke;     }           }         /**  * cglib代理  * @author Administrator  *  */ public class Client {     public static void main(String[] args) {         Teacher teacher = new Teacher();         Teacher proxy = (Teacher)new CglibProxy(teacher).getProxyInstance();         proxy.teach();         System.out.println("-----------");         proxy.sayHello("王老师");     } }