设计模式GOF23——代理模式

代理模式(proxy)是结构性模式的一种。结构型模式的核心作用是从程序的结构上实现低耦合，从而可以扩大整体的类结构，用来解决更大的问题。

模式的使用场景

代理模式的核心作用就是通过代理来控制对象的访问。可以通过详细控制访问某个对象的方法，在调用这个方法后做后置处理（即AOP的微观实现）
代理模式也是AOP（aspect oriented programming面向切面编程）的核心实现机制。

代理模式的角色

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

静态代理

//抽象代理类，大歌星唱歌需要的工作
public interface Star {
    void confer();//和客户会面
    void signconfer();//签合同
    void bookTicket();//订票
    void sing();//唱歌
    void collectMoney();//收尾款
}
//被代理类,真实歌星
public class RealStar implements Star{

    public void bookTicket() {
        //真实对象自己操作
    }

    public void collectMoney() {
        //真实对象自己操作
    }

    public void confer() {
        //真实对象自己操作
    }

    public void signconfer() {
        //真实对象自己操作
    }

    public void sing() {
        //真实对象自己操作
    }

}
//代理类，经纪人
public class Proxy implements Star{
    //被代理的对象的实体调用
    private Star star;

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

    public void bookTicket() {
        //代理类帮忙做无关紧要的方法和业务操作
    }

    public void collectMoney() {
        //代理类帮忙做无关紧要的方法和业务操作
    }

    public void confer() {
        //代理类帮忙做无关紧要的方法和业务操作
    }

    public void signconfer() {
        //代理类帮忙做无关紧要的方法和业务操作
    }

    public void sing() {
        //真正的业务逻辑交给被代理的对象自己做
        star.sing();
    }

}
//调用的操作
public class Client {

    public static void main(String[] args) {
        //被代理对象实例的创建
        Star realStar = new RealStar();
        //代理对象实例的创建
        Star proxy = new Proxy(realStar);
        //代理对象来执行方法
        proxy.confer();
        proxy.signconfer();
        proxy.bookTicket();
        proxy.sing();
        proxy.signconfer();
    }

}

动态代理

动态代理类是动态生成代理类。
优点
抽象角色中声明的所有方法都被转移到调用处理器一个集中的方法处理，这样，我们可以更加灵活和统一的处理众多方法。（而且动态生成可以让程序直接生成相应的二进制编码，更加节省操作时间）

使用场景

JDK自带的动态代理。
java.lang.reflect.Proxy作用：动态生成代理器和对象
java.lang.reflect.InvocationHandler(接口处理器)可以通过invoke方法实现对真实角色的代理访问，每次通过proxy生成代理对象时都要制定对应的处理器对象。

动态代理代码实现

//抽象代理类，大歌星唱歌需要的工作
public interface Star {
    void confer();//和客户会面
    void signconfer();//签合同
    void bookTicket();//订票
    void sing();//唱歌
    void collectMoney();//收尾款
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class StarHandler implements InvocationHandler{
    private Star realstar;

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

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        method.invoke(realstar, args);
        return null;
    }

}
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.confer();
        proxy.signconfer();
        proxy.bookTicket();
        proxy.sing();
        proxy.signconfer();
    }

}