Head First 设计模式 --11 代理模式

代理模式：为另一个对象提供一个替身或占位符以控制对这个对象的访问。

 代码：

interface Boss {
  public void meeting();
}

class BossImp implements Boss {
  @Override
  public void meeting() {
    System.out.println("meeting ....");
  }
}

class SecretaryProxy implements Boss {
  private Boss boss;

  public SecretaryProxy(Boss boss) {
    this.boss = boss;
  }

  @Override
  public void meeting() {
    System.out.println("before meeting ....");
    boss.meeting();
  }
}

public class ProxyTest {
  public static void main(String[] args) {
    Boss boss = new BossImp();
    SecretaryProxy proxy = new SecretaryProxy(boss);
    proxy.meeting();
  }
}

类图：

这里SecretaryProxy就是一个代理，在Boss开会前会通知Boss开会，还可以控制一些小的会议不用参加。

代理模式和装饰者模式很像，都是用一个对象把被封装对象封装起来，然后调用封装的对象。但是代理模式的目的是控制对象的访问，而装饰者模式是增加对象的行为。这里还有一个小技巧如何控制客户端用的是代理而不是实际的对象，通过提供一个工厂实例化并返回代理。这个实例化的过程可以用工厂模式来实例化。代理模式和适配器模式也很像，都是挡在其他对象前面并负责将请求转发给他们。适配器会改变对象适配的接口，而代理则实现相同的接口。

java本身也提供了一个代理类：

public class ProxyTest {
  public static void main(String[] args) {
    User user = new UserImpl();

    MyInvocationHandler myInvocationHandler = new MyInvocationHandler(user);

    User proxy = (User) myInvocationHandler.getProxy();

    proxy.add();

    User user2 = new UserImpl2();

    MyInvocationHandler myInvocationHandler2 = new MyInvocationHandler(user2);

    User proxy2 = (User) myInvocationHandler2.getProxy();

    proxy2.add();
  }
}

interface User {
  public abstract void add();

  public abstract void delete();
}


class UserImpl implements User {

  @Override
  public void add() {
    System.out.println("i am in add()");
  }

  @Override
  public void delete() {
    System.out.println("i am in delete");
  }

  public void update() {
    System.out.println("i am in update");
  }
}

class UserImpl2 implements User {

  @Override
  public void add() {
    System.out.println("i am in impl2 add()");
  }

  @Override
  public void delete() {
    System.out.println("i am in impl2 delete");
  }

  public void update() {
    System.out.println("i am in impl2 update");
  }
}


class MyInvocationHandler implements InvocationHandler {
  private Object target;

  public MyInvocationHandler(Object target) {
    this.target = target;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("=================before====================");
    Object object = method.invoke(target, args);
    System.out.println("=================after=====================");

    return object;
  }

  public Object getProxy() {
    return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
        target.getClass().getInterfaces(), this);
  }
}