代理模式（Proxy Pattern）

什么是代理模式（Proxy Pattern）

代理模式的定义：

为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。这种类型的设计模式属于结构型模式。

核心作用

• 通过代理，控制对象访问。可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现）。
• AOP(Aspect Oritend Programming)面向切面编程的核心实现机制。

核心角色

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

举例

以明星唱歌演出为例，某公司请周杰伦(真实角色)演出，如果周杰伦没有经纪人，面谈–>合同起草–>签字，收预付款–>安排机票和车辆–>唱歌–>收尾款，这一系列的事情都需要周杰伦一个人去完成，而周杰伦正真要做的主要的事情其实是唱歌。周杰伦请了经纪人(代理角色)之后，面谈，合同起草，签字，收预付款，安排机票和车，收尾款，这些工作统统都交给经人，自己只管唱歌即可。同时某公司(客户端)只要和经纪人联系即可。

应用场景

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

分类

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

类图

代码

抽象角色：

package com.match.proxy.staticproxy;

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

真实角色：

package com.match.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("周杰伦演出--唱歌");
    }

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

}

代理角色：

package com.match.proxy.staticproxy;

public class Proxy implements Star
{
    private Star star;

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

    @Override
    public void confer()
    {
        System.out.println("经纪人和某公司面谈");
    }

    @Override
    public void signContract() 
    {
        System.out.println("经纪人和某公司签合同");
    }

    @Override
    public void bookTicket()
    {
        System.out.println("经纪人订机票");
    }

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

    @Override
    public void collectMoney() 
    {
        System.out.println("经纪人收取演出费用");
    }
}

客户端：

package com.match.proxy.staticproxy;

public class Client
{
    public static void main(String[] args)
    {
        Star star = new RealStar();
        Star proxy = new Proxy(star);
        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectMoney();
    }
}

测试输出：

经纪人和某公司面谈
经纪人和某公司签合同
经纪人订机票
周杰伦演出--唱歌
经纪人收取演出费用

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

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

JDK自带的动态代理

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

详细内容查看JDK API文档

代码

抽象角色：

package com.match.proxy.dynamicproxy;

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

}

真实角色：

package com.match.proxy.dynamicproxy;

public class RealStar implements Star
{

    private String singer;

    public RealStar()
    {
        this.singer="Singer";
    }
    @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(singer+".sing()");
    }

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

}

处理器：

package com.match.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("经纪人和某公司签合同");
        System.out.println("经纪人订机票");
        if(method.getName().equals("sing")){
            object = method.invoke(realStar, args);
        }
        System.out.println("经纪人收取演出费用");
        return object;
    }
}

客户端：

package com.match.proxy.dynamicproxy;

import java.lang.reflect.Proxy;

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

测试输出:

经纪人和某公司面谈
经纪人和某公司签合同
经纪人订机票
Singer.sing()
经纪人收取演出费用

动态代理相比静态代理的优点

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