结构型--代理设计模式(Proxy)

代理模式（Proxy pattern）

核心作用：

• 通过代理，控制对对象的访问！
• 可以详细的控制访问某个(某类)对象的方法，在调用这个方法前做前置处理[从而实现将统一流程代码放到代理类中处理]，调用这个方法后做后置处理。(即：AOP的微观实现！)
• AOP（Aspect Oriented Programming，面向切面编程）的核心实现机制
  • 通过中间的代理，把除了明星唱歌以外的事情分离，让代理去做，明星只用完成自己的唱歌任务就可以

• AOP面向编程介绍

  • 常用术语
    | 切面（Aspect） | 其实就是共有功能的实现 |
    | — | — |
    | 通知（Advice） | 是切面的具体实现 |
    | 连接点（Joinpoint） | 就是程序在运行过程中能够插入切面的地点 |
    | 切入点（Pointcut） | 用于定义通知应该入到哪些连接点上 |
    | 目标对象（Target） | 就是那些即将切入切面的对象，也就是那些被通知的对象 |
    | 代理对象（Proxy） | 将通知应用到目标对象之后被动态创建的对象 |
    | 织入（Weaving） | 将切面应用到目标对象从而创建一个新的代理对象的过程 |

  • 开源的AOP框架

    • AspecU

核心角色

• 抽象角色

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

• 真实角色

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

• 代理角色

  • 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
  • 将统一的流程控制放到代理角色中处理！

应用场景

• 安全代理：屏蔽对真实角色的直接访问

• 远程代理：通过代理类处理远程方法调用（RMI）

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

  • 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一张图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开

开发框架中应用场景

• struts2中拦截器的实现

• 数据库连接池关闭处理

• Hibernate中延时加载的实现

• mybatis中实现拦截器插件

• AspectJ的实现

• Spring中AOP的实现

  • 日志拦截
  • 声明式事务处理

• web service

• RMI远程方法调用

实际上，随便选择一个技术框架都会用到代理模式

分类

• 静态代理（静态定义代理类）（要自己写）

• 动态代理（动态生成代理类）（自己不用管，由程序自动生成代理类）

  • JDK自带的动态代理
  • javaassist字节码操作库实现
  • CGLIB
  • ASM（底层使用指令，可维护性较差）

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

代码

1. 一个明星接口（Star），标明了该明星该做的事情
2. 一个真实的明星（RealStar）实现明星接口
3. 一个真实的代理（ProxyStar）实现明星接口，把明星专职以外的事情代理，只有明星才能做的事情交给明星自己处理
4. 客户端，与已知的接口中的事情向代理商打交道

• 明星接口(Star)

package proxy.staticProxy;

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

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

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

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

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

• 真实明星（RealStar）

package proxy.staticProxy;

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 bookTicket() {
        System.out.println("RealStar.bookTicket()");
    }

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

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

• 真实代理（ProxyStar）

将唱歌这件只能明星做的事情sing()，交给指定的明星去做，其他的代替明星完成

package proxy.staticProxy;

public class ProxyStar implements Star {

    private Star realStar;

    public ProxyStar(Star realStar) {
        this.realStar = realStar;
    }

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

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

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

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

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

• 客户

package proxy.staticProxy;

public class Client {

    public static void main(String[] args) {
        Star real = new RealStar();
        Star proxy = new ProxyStar(real);

        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectMoney();

    }
}

//结果——————————————————————————————————————
ProxyStar.confer()
ProxyStar.signContract()
ProxyStar.bookTicket()
RealStar(周杰伦本人).sing()//只有唱歌交给了周杰伦，其他的业务代理帮忙做了
ProxyStar.collectMoney()

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

应用范围更广

优点

• 相比较静态代理的优点

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

JDK自带的动态代理

• java.lang.reflect.Proxy

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

• java.lang.reflect.InvocationHandler(处理器接口)

  • 可以通过invoke方法实现对真实角色的代理访问
  • 每次通过Proxy生成代理类对象时都要指定对应的处理器对象

Star realStar = new RealStar();
StarHandler handler = new StarHandler(realStar);
Star proxy = (Star)Proxy.newProxyInstance
	(ClassLoader.getSystemClassLoader(),new Class[]{Star.class},handler);

proxy.sing();

代码

• 明星接口类（Star）和真实明星实现类（realStar）与上面的相同
• StarHandler类

继承InvocationHandler类，重写invoke方法

invoke方法内部就是代理逻辑的编写

package proxy.dynamicProxy;

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

public class StarHandler implements InvocationHandler {

    Star realStar;

    public StarHandler(Star realStar) {
        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;
    }
}

• 客户类（Client）

关键语句：

Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, handler);

• 第一个参数：类加载器
• 第二个参数：传递的Star类的class文件
• 第三个参数：实现了的代理，调用的方法都会在重写后的invoke中执行

package proxy.dynamicProxy;

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();

    }
}