GOF23之代理模式Demo

代理模式可分为静态代理与动态代理。
代理模式一般涉及到的角色有：
抽象角色：声明真实对象和代理对象的共同接口。
真实角色：代理角色代表的真实对象，是我们最终要应用的对象。
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能替代真实对象相同的接口以便在任何时刻都能替代真实对象。同时，代理对象可以再执行真实对象操作时，附加其他的操作，相当于对象真实对象进行封装。
使用代理可以分离关注点与真正的业务。抽象角色中包含了各种方法，但是并不是所有的方法都需要真实角色来使用，真实角色真正的业务可能只是某一个而已。这样可以将真实角色的业务剥离出来，剩下的那些关注点交给代理类实现。
比如请歌星唱歌，需要进行面谈、签合同、订机票、唱歌、收钱。实际上经纪人就是歌星的代理，唱歌就是歌星的真正业务，其他的面谈、签合同、订机票、收钱这些事情是关注点，交给经纪人做即可。
一、静态代理的实现。
Star接口

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

RealStar实现类

public class RealStar implements Star {

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

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

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

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

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

ProxyStar类

public class ProxyStar implements Star {

    private Star star;//真实对象的引用

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

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

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

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

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

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

测试：

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

二、动态代理的实现
一个典型的动态代理创建对象过程可分为以下四个步骤：
1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(…);
2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类
Class clazz = Proxy.getProxyClass(classLoader,new Class[]{…});
3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4、通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入
Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。
生成的ProxySubject继承Proxy类实现Subject接口，实现的Subject的方法实际调用处理器的invoke方法，而invoke方法利用反射调用的是被代理对象的的方法（Object result=method.invoke(proxied,args)）
使用JDK自带的动态代理，最主要的两个类是InvocationHandler和Proxy。
将静态代理中的例子修改如下：
Star接口、RealStar实现类与静态代理中的一样，新增一个统一流程控制的类：StarHandler：

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 {
        //proxy 代理的对象  method 执行的方法  args 方法参数
        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()
真正的方法执行后!
收尾款