前言

        在说代理模式之前，我先说一下日常我们说的代理和被代理人，这东西就是我们常听到的律师帮人打官司，当发生纠纷的时候，自己也不懂法律啊，这咋办，总不能硬着头皮上吧，这时候就需要一个律师做你的代理，帮你打一波官司，而你就成为了被代理人。
        在了解了代理和被代理人之后再来了解代理模式那就很方便了，只要记住代理就是做事的，被代理人只需要知道结果(其实就是过着懒人的生活，什么都不用操心)。
        Java中的代理模式分为两种：

静态代理
这种代理模式从名字上来看就知道，静态静态，就是一开始规定好了，在这里就是代表是我们程序员自己根据需要被代理的类来创建的代理类，可能看着比较绕，上代码就很清楚了：

首先先来个IClassMethod接口，里面主要是抽象了代理类和被代理类共同的方法（你要让别人代理你做，别人总要会这个东西吧）

public interface IClassMethod {
    void playing(String something);

    void goHome(String goHome);
}

再来个Person类，这个类就是我们的被代理类啦，实现了IClassMethod这个接口

public class Person implements IClassMethod {
  public Person() {
      System.out.println("init person");
  }

  @Override
  public void playing(String something) {
      System.out.println(something);
  }

  @Override
  public void goHome(String goHome) {
      System.out.println(goHome);
  }
}

这时候有了被代理类，那么就来一个代理类PersonProxy，它需要有被代理类的实例对象，不然怎么知道要代理谁呢，当然也要实现了IClassMethod这个接口啦，不然怎么代替被代理的类做事呢：

public class PersonProxy implements IClassMethod {
    private Person mPerson;

    public PersonProxy(Person person) {
        mPerson = person;
    }

    @Override
    public void playing(String something) {
        mPerson.playing(something);
    }

    @Override
    public void goHome(String goHome) {
        mPerson.goHome(goHome);
    }
}

运行一下：

public class Test {
    public static void main(String[] args) {
        PersonProxy proxy=new PersonProxy(new Person());
        proxy.goHome("我回家了");
        proxy.playing("我在玩");
    }
}

静态代理

这样一整个静态代理就完成了，重新理一下静态代理：需要一个代理类（PersonProxy），一个被代理类（Person），还有一个两个都要实现的接口(IClassMethod)，看PersonProxy代码就知道，其实就是在代理类（PersonProxy）里面使用Person来做操作，但是真正用的却是PersonProxy的方法。
使用静态代理的话，也能实现普通的需求，但是如果有很多个被代理类呢，那不也要很多个代理类了么，那多麻烦，这时候就需要动态代理出场了。

动态代理
Java中有两种实现动态代理方式：一种是使用jdk的反射机制，一种是使用cglib。我们这就介绍下使用反射这种。
动态代理只能对接口代理，其中有两个很重要的东西，一个就是Proxy类和InvocationHandler接口，我们逐一介绍，Proxy就是Java提供生成代理类的类，里面有个newProxyInstance方法生成代理类，这方法有三个参数：

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

第一个参数：ClassLoader类加载器
第二个参数：接口类
第三个参数：重要的InvocationHandler
前两个没啥好说的，最后一个才是重点，这个InvocationHandler里面就是一个方法

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

这方法主要是用来调用代理类的方法的，第一个参数就是被代理类，第二个参数就是被代理类调用的方法，第三个就是方法的参数。
创建一个MyInvocationHandler里面做一些自己的操作：

public class MyInvocationHandler implements InvocationHandler {
    private Person mPerson;

    public MyInvocationHandler(Person person) {
        mPerson = person;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        for (int i = 0; i < args.length; i++) {
            if (method.getName().equals("playing"))
                args[i] = "我没在玩游戏";
        }
        return method.invoke(mPerson, args);
    }
}

然后再使用Proxy

public class Test {
    public static void main(String[] args) {
        IClassMethod personProxy = (IClassMethod) Proxy.newProxyInstance(Person.class.getClassLoader(),
                Person.class.getInterfaces(),
                new MyInvocationHandler(new Person()));
        personProxy.goHome("我回家了");
        personProxy.playing("我在玩游戏");
    }
}

可以看到，其实跟静态代理长的差不多，只不过这个代理类是jdk通过反射来生成的，这样只要是实现相同接口的类，都能使用动态代理，返回一个代理类。
看一下这个动态代理运行结果：