代理模式（Proxy）（常用）

- 核心作用

通过代理，控制对对象的访问
可以详细控制访问某个（某类）对象的方法，再调用这个方法前做前置处理，调用这个方法后做后置处理。（即AOP的微观实现）--从而实现将统一流程代码放到代理类中处理。
AOP(Aspect Oriented Programming 面向切面编程)的核心实现机制。

- 核心角色

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

- 应用场景

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

- 结构图

proxy.gif

- 代码实现

public class ProxyTest
{
    public static void main(String[] args)
    {
        Proxy proxy=new Proxy();
        proxy.Request();
    }
}
//抽象主题
interface Subject
{
    void Request();
}
//真实主题
class RealSubject implements Subject
{
    public void Request()
    {
        System.out.println("访问真实主题方法...");
    }
}
//代理
class Proxy implements Subject
{
    private RealSubject realSubject;
    public void Request()
    {
        if (realSubject==null)
        {
            realSubject=new RealSubject();
        }
        preRequest();
        realSubject.Request();
        postRequest();
    }
    public void preRequest()
    {
        System.out.println("访问真实主题之前的预处理。");
    }
    public void postRequest()
    {
        System.out.println("访问真实主题之后的后续处理。");
    }
}

- 分类

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

/**
 * @author zhongjiahong
 *  静态代理（代理类和被代理类所需要实现的接口）
 */
public interface Star {
    void confer();
    void signContract();
    void bookTicket();
    void sing();
    void collectMoney();
}

/**
 *  被代理的类
 * @author zhongjiahong
 *
 */
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()");
    }
}

/**
 * @author zhongjiahong
 * 代理类
 */
public class ProxyStar implements Star{

    private Star star;

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

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

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

动态代理（动态生成代理类，程序自动生成）
- jdk自带的动态代理
- javaassist字节码操作库实现
- CGLIB
- ASM(底层使用指令，可维护性较差)
动态代理相比静态代理的优点
- 抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
JDK自带的动态代理
- java.lang.reflect.Proxy
作用：动态生成代理类和对象
- java.lang.reflect.InvocationHandler(处理器接口)
可以通过invoke方法实现对真实角色的代理访问。
可以通过Proxy生成代理类对象时都要指定对应的处理器对象。

Star与RealStar与上面一样

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

public class StarHandler implements InvocationHandler{

    Star star;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object object = null;
        System.out.println("签合同，付款，订机票");
        if(method.getName().equals("sing")){
            object = method.invoke(star, args);
        }
        return object;
    }

}

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

装饰者模式和代理模式
这两个设计模式看起来很像。对装饰器模式来说，装饰者（decorator）和被装饰者（decoratee）都实现同一个接口。对代理模式来说，代理类（proxy class）和真实处理的类（real class）都实现同一个接口。此外，不论我们使用哪一个模式，都可以很容易地在真实对象的方法前面或者后面加上自定义的方法。

  然而，实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话 说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模 式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。（注意看测试类创建的时候）

  我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。

代理模式（Proxy）（常用）