GOF23设计模式之代理模式（proxy）

一、代理模式概述

　　1、代理模式的核心作用

　　　　（1）通过代理，控制对象的访问；

　　　　（2）可以详细的控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（AOP的微实现）

　　　　　　  代理模式是 AOP（Aspect Oriented Programming 面向切面编程）的核心实现机制。

　　2、代理模式的核心角色

　　　　（1）抽象角色

　　　　　　定义代理角色和真实角色的公共对外方法。

　　　　（2）真实角色

　　　　　　实现抽象角色，定义真实角色所需要实现的业务逻辑，供代理角色调用。

　　　　　　关注真正的业务逻辑。

　　　　（3）代理角色

　　　　　　实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑辅方法来实现抽象方法，并附加自己的操作。

　　　　  将统一的流程控制放在代理角色中处理！

　　3、代理模式的使用场景

　　　　（1）安全代理： 屏蔽对真实角色的访问；

　　　　（2）通过代理类处理远程方法调用（RMI Remote Method Invocation 远程方法调用）；

　　　　（3）延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。

　　4、代理模式的分类

　　　　（1）静态代理（静态定义代理类）

　　　　（2）动态代理（动态生成代理类）

　　　　　　① JDK自带的动态代理

　　　　　　② javassist字节码操作库实现

　　　　　　③ CGLIB

　　　　　　　 CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。

　　　　　　　 通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。

　　　　　　④ ASM底层使用指令，可维护性较差

　　　　　　　 ASM是一个java字节码操纵框架，它能被用来动态生成类或者增强既有类的功能。

二、代理模式之静态代理

　　示例代码场景：周杰伦开演唱会时，面谈、签合同、订票等操作都是由周杰伦的经纪人来完成，唱歌部分由他本人完成，最后收款也是由经纪人来完成。

　　（1）创建抽象角色

/**
 * 抽象角色
 * @author CL
 *
 */
public interface Star {
    /**
     * 面谈 
     */
    void confer();
    /**
     * 签合同
     */
    void signConstract();
    /**
     * 订票
     */
    void bookTicket();
    /**
     * 唱歌
     */
    void sing();
    /**
     * 收款
     */
    void collectMoney();
}

　　（2）定义真实角色

/**
 * 真实身份（相当于例子中的周杰伦本人）
 * @author CL
 *
 */
public class RealStar implements Star {

    @Override
    public void confer() {
        System.out.println("周杰伦去面谈");
    }

    @Override
    public void signConstract() {
        System.out.println("周杰伦去签合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("周杰伦去订票");
    }

    @Override
    public void sing() {
        System.out.println("周杰伦去唱歌");
    }

    @Override
    public void collectMoney() {
        System.out.println("周杰伦去收款");        
    }

}

　　（3）定义代理角色

/**
 * 代理身份（相当于例子中的周杰伦的经纪人）
 * @author CL
 *
 */
public class ProxyStar implements Star {
    private Star star;
    
    public ProxyStar(Star star) {
        this.star = star;
    }

    @Override
    public void confer() {
        System.out.println("经纪人去面谈");
    }

    @Override
    public void signConstract() {
        System.out.println("经纪人去签合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("经纪人去订票");
    }

    @Override
    public void sing() {
        star.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("经纪人去收款");
    }

}

　　（4）测试

/**
 * 客户端
 *     只和经纪人联系
 * @author CL
 *
 */
public class Client {

    public static void main(String[] args) {
        Star real = new RealStar();
        Star proxy = new ProxyStar(real);
        
        //面谈
        proxy.confer();
        //签合同
        proxy.signConstract();
        //订票
        proxy.bookTicket();
        //唱歌
        proxy.sing();
        //收款
        proxy.collectMoney();
    }
}

　　控制台输出：

经纪人去面谈
经纪人去签合同
经纪人去订票
周杰伦去唱歌
经纪人收款

三、代理模式之动态代理

　　JDK自带的动态代理：

　　　　① 在客户端，java.lang.reflect.Proxy

　　　　　作用：动态生成代理类和对象

　　　　② 实现java.lang.reflect.InvocationHandler(处理器接口)

　　　　　可以通过invoke方法实现对真实角色的代理访问

　　　　　每次通过Proxy生成代理类对象时都要指定对应的处理器对象

　　（1）创建抽象角色

public interface Star {
    /**
     * 面谈 
     */
    void confer();
    /**
     * 签合同
     */
    void signConstract();
    /**
     * 订票
     */
    void bookTicket();
    /**
     * 唱歌
     */
    void sing();
    /**
     * 收款
     */
    void collectMoney();
}

　　（2）创建真实角色

/**
 * 真实身份（相当于例子中的周杰伦本人）
 * @author CL
 *
 */
public class RealStar implements Star {

    @Override
    public void confer() {
        System.out.println("周杰伦去面谈");
    }

    @Override
    public void signConstract() {
        System.out.println("周杰伦去签合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("周杰伦去订票");
    }

    @Override
    public void sing() {
        System.out.println("周杰伦去唱歌");
    }

    @Override
    public void collectMoney() {
        System.out.println("周杰伦去收款");        
    }

}

　　（3）创建代理角色的处理器

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 代理角色的处理类
 * jdk自带的动态代理
 * @author CL
 *
 */
public class StarHandler implements InvocationHandler {
    private Star realStar;
    
    public StarHandler(Star realStar) {
        this.realStar = realStar;
    }

    //通过invoke方法实现对真实角色的代理访问
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object obj = null;
        
        System.out.print("在执行真实角色的方法之前的处理，比如-->");
        System.out.println("面谈，签合同，订票");
        
        if (method.getName().equals("sing")) {
            obj = method.invoke(realStar, args);
        }
        
        System.out.print("在执行真实角色的方法之后的处理，比如-->");
        System.out.println("收款");
        
        return obj;
    }

}

　　（4）测试

import java.lang.reflect.Proxy;

/**
 * 测试JDK自带的动态代理
 * @author CL
 *
 */
public class Client {

    public static void main(String[] args) {
        Star realStar = new RealStar();
        
        StarHandler handler = new StarHandler(realStar);
        
        Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Star.class}, handler);
        
        proxy.sing();
    }
}

　　控制台输出：

在执行真实角色的方法之前的处理，比如-->面谈，签合同，订票
周杰伦去唱歌
在执行真实角色的方法之后的处理，比如-->收款