设计模式（六）代理模式

——核心作用：通过代理，控制对对象的访问，可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，从而实现将统一流程代码放到代理类中处理，调用这个方法后做后置处理。

——AOP（Aspect Oriented Programming面向切面编程）的核心实现机制

——核心角色：

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

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

　　　　　　　关注真正的业务逻辑。

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

　　　　　　　将统一的流程控制放到代理角色中处理。

——应用场景：

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

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

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

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

——分类：

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

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

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

---

静态代理：

1. 定义一个Star接口

package com.ztq.proxy.staticProxy;

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

2. 定义一个RealStar类

package com.ztq.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()");
    }
    
}

3. 定义一个ProxyStar类

package com.ztq.proxy.staticProxy;

public class ProxyStar implements Star{

    private Star star;
    
    public ProxyStar(Star star){
        super();
        this.star = star;
    }
    
    @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() {
        star.sing();
    }

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

4. 定义一个客户端调用

package com.ztq.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()

UML图：

---

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

JDK自带的动态代理：

　　java.lang.reflect.Proxy 作用：动态生成代理类和对象

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

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

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

Star接口、RealStar类与静态代理一样，此处省略。

定义一个StarHandler类

package com.ztq.proxy.dynamicProxy;

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;
    }

}

定义一个客户端调用类

package com.ztq.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.bookTicket();
        proxy.sing();
    }
}

运行结果

真正的方法执行前
面谈，签合同，预付款，订机票
真正的方法执行后
收尾款
真正的方法执行前
面谈，签合同，预付款，订机票
RealStar.sing()
真正的方法执行后
收尾款