设计模式之代理模式

本文讲述设计模式中的代理模式。

7、代理模式

AOP的原理，可以在调用方法前做前置处理，调用方法后做后置处理

7.1、代理模式的三个角色

• 抽象角色
  定义代理角色和真实角色的公共对外方法
• 真实角色
  实现抽象角色，定义真实角色所要实现的业务逻辑供代理角色调用；关注真正的业务逻辑
• 代理角色
• 实现抽象角色，是真实角色的代理，通过真实角色的业务方法来实现抽象方法，并可以附加自己的操作。
  
  我们将统一的流程放在代理角色中处理
  例如一个歌星开演唱会，前期的签约、找场地、宣传和后期的收尾款经纪人（代理角色）做就可以了，只有唱歌才是自己（真实角色）做的。

7.2、 代理模式的分类

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

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

• JDK自带的动态代理
• CGLIB

7.3、静态代理的实现

直接上代码了，模拟歌手开演唱会

• 抽象角色

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

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

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

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

    /**
     * 收尾款
     */

    void collectMoney();
}

• 真实角色

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

• 代理角色

public class ProxyStar implements Star{
    private RealStar realStar;

    public ProxyStar(RealStar 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");
    }
}

• 客户端调用

public class Client {
    public static void main(String[] args) {
        RealStar realStar = new RealStar();
        ProxyStar proxyStar = new ProxyStar(realStar);
        proxyStar.confer();
        proxyStar.signContract();
        proxyStar.bookTicket();
        proxyStar.sing();
        proxyStar.collectMoney();
    }
}

7.4、动态代理的实现

使用动态代理，我们可以更加灵活和统一的处理众多的方法，因为抽象角色（接口）中声明的所有方法都被调用处理器一个集中的方法中处理。

JDK自带的动态代理

• java.lang.refect.Proxy
  动态生成代理类对象
• java.lang.reflect.InvocationHandler(处理器接口)
  可以通过invoke方法实现对真实角色的代理访问
  每次通过Proxy生成代理类对象时都要指定对应的处理器对象

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

7.4.1、 动态代理的代码实现

代理角色与真实角色和静态代理一样

• 调用处理器

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 invoke =null;
        System.out.println("真正的方法执行前");
        System.out.println("面谈，签合同，预付款，订机票");
        if (method.getName().equals("sing")){
             invoke = method.invoke(realStar, args);
        }
        System.out.println("真正的方法执行后");
        System.out.println("收尾款");
        return invoke;
    }
}

• 客户端调用

public class Client {
    public static void main(String[] args) {
        RealStar realStar = new RealStar();
        StarHandler handler = new StarHandler(realStar);
       Star proxy =  (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, handler);
       proxy.sing();
    }
}