代理模式（proxy pattern）

核心作用

通过代理，控制对对象的访问
可以详细控制访问某个（某类）对象的方法，在调用这个方法浅做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现）
AOP（Aspect Oriented Programming 面向切面编程）的核心实现机制

核心角色

抽象角色
- 定义代理角色和真实角色的公共对外方法
真实角色
- 实现抽象角色，定义真实角色所需要实现的业务逻辑，供代理角色调用
- 关注真正的业务逻辑
代理角色
- 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
- 将统一的流程控制放到代理角色中处理！

安全场景

安全代理：屏蔽对真实角色的直接访问
远程代理：通过代理类处理远程方法调用（RMI）
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。

代码解析

我们用现实生活中的明星和经纪人举个例子：
建一个明星接口，代表明星日常所需要做的事情。

public interface Star {
    /**
     * 面谈
     */
    void confer();

    /**
     * 签合同
     */
    void signContract();

    /**
     * 订票
     */
    void bookTickect();

    /**
     * 唱歌
     */
    void sing();

    /**
     * 收钱
     */
    void collectMoney();
}

然后我们实现一下接口，构建一个“真实”的明星

/**
 *真实角色
 */
public class RealStar implements Star{
    @Override
    public void confer() {
        System.out.println("RealStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("RealStar.signContract()");
    }

    @Override
    public void bookTickect() {
        System.out.println("RealStar.bookTickect()");
    }

    @Override
    public void sing() {
        System.out.println("RealStar（周杰伦本人）.sing()");
    }

    @Override
    public void collectMoney() {
        System.out.println("RealStar.collectMoney()");
    }
}

静态代理

在静态代理中，我们需要一个专门的代理类，去实现明星接口，代替明星完成一些事情，那么我们看一下明星日常需要完成的类，只有唱歌，是需要本人完成，其他的事情都可以由经纪人代理。那么，我们就只需要在sing()方法里调用真实唱歌类就可以了。

/**
 * 代理人
 */
public class ProxyStar implements Star{

    private Star star;
    @Override
    public void confer() {
        System.out.println("ProxyStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("ProxyStar.signContract()");
    }

    @Override
    public void bookTickect() {
        System.out.println("ProxyStar.bookTickect()");
    }

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

    @Override
    public void collectMoney() {
        System.out.println("ProxyStar.collectMoney()");
    }

    public ProxyStar(Star star) {
        super();
        this.star = star;
    }
}

我们调用一下代理方法，来看下效果：


/**
 * 静态代理（我们自己定义代理）
 */
public class Client {
    public static void main(String[] args) {
        Star real = new RealStar();
        Star proxy = new ProxyStar(real);

        proxy.confer();
        proxy.signContract();
        proxy.bookTickect();
        proxy.sing();
        proxy.collectMoney();
    }
}

结果：
ProxyStar.confer()
ProxyStar.signContract()
ProxyStar.bookTickect()
RealStar（周杰伦本人）.sing()
ProxyStar.collectMoney()

动态代理

我们在来看下动态代理,和静态代理不同，我们只需要实现InvocationHandler接口，重写invoke()方法就可实现代理。

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

/**
 * 核心
 */
public class StarHandler implements InvocationHandler {
    Star realStar;

    public StarHandler(Star realStar) {
        super();
        this.realStar = realStar;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object object = null;
        System.out.println("真正的方法执行前！");
        //调用方法 此处简化
        System.out.println("面谈，签合同，订票");
        if(method.getName().equals("sing")){
            object = method.invoke(realStar,args);
        }
        System.out.println("真正的方法执行后！");
        System.out.println("收尾款");
        return object;
    }
}

同样，我们调用一下方法，看下结果：

import java.lang.reflect.Proxy;

/**
 * 动态代理
 */
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();
    }
}

结果：
真正的方法执行前！
面谈，签合同，订票
RealStar（周杰伦本人）.sing()
真正的方法执行后！
收尾款

同样的，我们实现了代理。

动态代理相比于静态代理的优点

抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法处理，这样，我们可以更加灵活和统一的处理众多的方法。

JDK自带的动态代理

java.lang.reflect.Proxy
- 作用：动态生成代理类和对象
java.lang.reflect.InvocationHandler(处理器接口)
- 可以通过invoke方法实现对真实角色的代理访问
- 每次通过Proxy身材代理类对象时都要指定对应的处理器对象

开发框架中应用场景

struts2中拦截器的实现
数据库连接池关闭处理
Hibernate中延时加载的实现
mybatis中实现拦截器插件
AspectJ的实现
spring中AOP的实现
- 日志拦截
- 声明式事务处理
web service
RMI远程方法调用

注：该博文为学习总结，视频来源为高淇java300集

设计模式GOF23--代理模式