设计模式之代理模式

1、核心：

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

2、代理模式角色：

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

3、应用场景：

-安全代理：屏蔽对真实角色的直接访问。
-远程代理：通过代理类处理远程方法调用。
-延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。

4、分类:

静态代理：静态定义代理类
动态代理：动态生成代理类

5、静态代理：

问题：比如每个歌星都有个经纪人，那么经纪人相当于一个代理角色，实现面谈、签合同、订车票、收钱的工作，歌星相当于一个真实角色，只负责唱歌就好了。

代码：

/**
 * 歌星抽象接口（代理角色与真实角色共同接口）
 * @author ly1
 *
 */
public interface Star {
    /**
     * 面谈
     */
    void confer();  
    /**
     * 签合同
     */
    void signContract();
    /**
     * 定车票
     */
    void bookTicket();
    /**
     * 唱歌
     */
    void sing();
    /**
     * 收钱
     */
    void collectMoney();
}

/**
 * 真实歌星
 * @author ly1
 *
 */
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()");
    }

}

/**
 * 代理角色
 * @author ly1
 *
 */
public class ProxyStar implements Star{
    private RealStar real;

    public ProxyStar(RealStar real) {
        this.real = real;
    }

    @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() {
        real.sing();
    }

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

}

/**
 * 客户端调用
 * @author ly1
 *
 */
public class Client {
    public static void main(String[] args) {
        RealStar real = new RealStar();
        ProxyStar proxy = new ProxyStar(real);

        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectMoney();
    }
}

结果：
ProxyStar.confer()
ProxyStar.signContract()
ProxyStar.bookTicket()
RealStar.sing()
ProxyStar.collectMoney()

6、动态代理：

实现方法：

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

这里只实现JDK自带的动态代理：

-java.lang.reflect.Proxy

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

代码：

/**
 * 歌星抽象接口（代理角色与真实角色共同接口）
 * @author ly1
 *
 */
public interface Star {
    /**
     * 面谈
     */
    void confer();  
    /**
     * 签合同
     */
    void signContract();
    /**
     * 定车票
     */
    void bookTicket();
    /**
     * 唱歌
     */
    void sing();
    /**
     * 收钱
     */
    void collectMoney();
}

/**
 * 真实歌星
 * @author ly1
 *
 */
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()");
    }

}

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

/**
 * 动态代理处理器
 * @author ly1
 *
 */
public class StarHandler implements InvocationHandler{
    private RealStar real;

    public StarHandler(RealStar real) {
        super();
        this.real = real;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object obj = null;
        //可以在通过方法名，实现不同的业务逻辑，这里只是实现了调用sing方法时的业务逻辑
        System.out.println("面谈、签合同、订票");
        if(method.getName().equals("sing")){
            obj = method.invoke(real, args);
        }
        System.out.println("收钱");
        return obj;
    }

}

import java.lang.reflect.Proxy;

/**
 * 测试动态代理
 * @author ly1
 *
 */
public class Client {
    public static void main(String[] args) {
        RealStar real = new RealStar();
        StarHandler handler = new StarHandler(real);
        Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class},handler);
        proxy.sing();
    }
}

结果：
面谈、签合同、订票
RealStar.sing()
收钱

7、分析

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

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