GOF23 设计模式之 代理模式

代理模式：

• 通过代理，控制对对象的访问！
  
  • 可以详细控制访问某人（某类）的方法，在调用这个方法前做前置处理，调用这个方法之后做后置处理。（即：APO的围观实现）
• AOP（Aspect Oriented Programming 面向切面编程）的核心实现机制！
• 可以只关注核心流程。通过代理实现将统一的流程代码放到代理类中处理

核心角色

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

应用场景

• 安全代理：屏蔽对真实角色的直接访问
• 远程代理：通过代理类处理远程方法调用（RMI）
• 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
  
  • 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

分类

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

静态代理一种简单的实现

• Star接口

package com.coderbean.proxy.staticProxy;

/**
 * Created by Chang on 15/9/27.
 */
public interface Star {
    /**
     * 面谈
     */
    void confer();

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

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

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

    /**
     * 收尾款
     */
    void collectMoney();
}

• RealStar类

package com.coderbean.proxy.staticProxy;

/**
 * Created by Chang on 15/9/27.
 */
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类

package com.coderbean.proxy.staticProxy;

/**
 * Created by Chang on 15/9/27.
 */
public class ProxyStar implements Star {

    private Star star;

    public ProxyStar(Star star) {
        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");
    }
}

• Client类

package com.coderbean.proxy.staticProxy;

/**
 * 测试代理模式
 * Created by Chang on 15/9/27.
 */
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();
    }
}

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

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

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

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类

package com.coderbean.proxy.dynamicProxy;

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

/**
 * Created by Chang on 15/9/27.
 */
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 {
        System.out.println("#####");
        //可以在这里方便的放置一些处理的代码
        method.invoke(realStar,args);


        return null;
    }
}

• Client类

package com.coderbean.proxy.dynamicProxy;

import java.lang.reflect.Proxy;

/**
 * Created by Chang on 15/9/27.
 */
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();
    }

}