设计模式（八）—— 代理模式

1. 定义

代理模式是一种使用代理对象来执行目标对象的方法并在代理对象中增强目标对象方法的一种设计模式。代理对象代为执行目标对象的方法，并在此基础上进行相应的扩展。

代理模式遵循开闭原则，代理对象和目标对象实现共同的接口，主要组成如下图所示。

2. 作用

隔离客户端和目标对象，而且可以扩展功能

3.分类

按照代理创建的时期来分类，可以分为两种：静态代理、动态代理（jdk动态代理、cglib动态代理、Spring和AspectJ实现的动态代理）；

4.具体实现

4.1 静态代理

（1）创建抽象接口Subject，声明目标对象需要让代理对象帮忙做的事；

public interface Subject{
    public void buyHouse();    
}

(2) 创建目标对象类（RealSubject）,实现Subject接口

public class RealSubject implements Subject {
    @Override
    public void buyHouse() {
        System.out.println("我要买房")；
    }    
}

（3）创建代理类，并通过代理类创建真实对象实例并访问其方法

public SubjectProxy implements Subject {
    private RealSubject realSubject;
    public  SubjectProxy(final RealSubject realSubject) {
        this.realSubject = realSubject;
    }   
    
    @Override
    public void buyHouse() {
        System.out.println("买房前的准备");
        realSubject.buyHouse();
        System.out.println("买房后装修");
    }
}

（4）客户端调用

public class ProxyPattern {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        SubjectProxy proxy = new SubjectProxy(realSubject);
        proxy.buyHouse();
    }   
}

静态代理可以做到在不修改目标对象的前提下，对目标进行扩展。

但是因为代理类需要实现与目标类相同的接口，需要为每个目标对象都创建一个代理类，工作量较大；同时，一旦接口增加方法，目标对象与代理对象都要维护。

如何解决静态代理中的缺点呢？答案是可以使用动态代理方式

4.2 动态代理

动态代理的代理对象不需要实现接口；

JDK中生成代理对象的API：

代理类所在包：java.lang.reflect.Proxy

JDK实现代理只需要使用newProxyInstance方法，但是该方法需要接受三个参数，完整的写法是：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

该方法是Proxy类的静态方法，接收三个参数：

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

代码示例

接口类Subject和目标对象类是一样的，保持不变，在这基础上增加一个代理工厂类，用来获取代理对象

（1）实现代理工厂

/**
 * 创建动态代理对象
 * 动态代理对象不需要实现接口，但需要指定接口类型
 */
public class ProxyFactory {
    //维护一个目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }    
    
    //给目标对象生成代理对象
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                 System.out.println("买房前准备");
                 //执行目标对象的方法
                 Object returnValue = method.invoke(target, args);
                 System.out.println("买房后装修");
                 return returnValue；
          }   
        });
    }
}

（2）客户端测试

public class ProxyPattern {
    public static void main(String[] args) {
        //目标对象
        RealSubject realSubject = new RealSubject();
        //创建代理对象
        Subject proxy = (Subject) new ProxyFactory(realSubject).getProxyInstance();
        //执行方法
        proxy.buyHouse();
    }   
}

动态代理总结：虽然相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。但是和静态代理一样，都要求目标对象是一个实现接口的目标对象，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候就可以使用以目标对象子类的方式类实现代理，这种方法就叫做：Cglib代理。

4.3 Cglib代理

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

• JDK的动态代理有一个限制，就是使用动态代理的对对象必须实现一个或多个接口，如果想代理没有实现接口的类，就可以使用Cglib实现。
• Cglib是一个强大的高性能的代码生成包，它可以在运行期扩展java类与实现java接口，它被许多AOP框架广泛使用，例如Spring AOP和synaop，为他们提供方法的interception（拦截）。
• Cglib包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类。不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

Cglib子类代理实现方法：

（1）需要引入Cglib的jarw文件，但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.

（2）引入功能包后，就可以在内存中动态构建子类

（3）代理类不能为final，否则报错

（4）目标对象的方法如果为final/static，那么就不会拦截，即不会执行目标对象额外的业务方法

代码示例：

（1）目标对象类

/**
 * 目标对象,没有实现任何接口
 */
public class RealSubject{

    public void buyHouse() {
        System.out.println("我要买房");
    }
}

（2）Cglib代理工厂

/**
 * Cglib子类代理工厂
 * 对RealSubject在内存中动态构建一个子类对象
 */
public class ProxyFactory implements MethodInterceptor{
    //维护目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();

    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("买房前准备");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);

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

        return returnValue;
    }
}

（3）客户端测试

public class ProxyPattern {
    public static void main(String[] args) {
        //目标对象
        RealSubject realSubject = new RealSubject();
        //创建代理对象
        Subject proxy = (Subject) new ProxyFactory(realSubject).getProxyInstance();
        //执行方法
        proxy.buyHouse();
    }   
}