3）屏蔽网络差异和复杂性，代理在本地，而实际对象在其他服务器上，调用本地代理时，本地大力请求其他服务器。

public class SampleStaticProxy {

    interface IService {
        void sayHello();
    }

    static class ConcreteService implements IService {

        @Override
        public void sayHello() {
            System.out.println("hello");
        }
    }

    static class ProxyService implements IService {

        private IService mService;

        public ProxyService(IService service) {
            mService = service;
        }

        @Override
        public void sayHello() {
            System.out.println("entering method");
            mService.sayHello();
            System.out.println("leaving method");
        }
    }

    public static void main(String[] args) {
        IService concreteService = new ConcreteService();
        ProxyService proxyService = new ProxyService(concreteService);
        proxyService.sayHello();
    }
}

分析一下，代理和实际对象一般有相同的接口，在这个demo中，共同的接口是IService，实际对象是 ConcreteService ，代理是 ProxyService 。 ProxyService 内部有一个 IService 的成员变量，指向实际对象，在构造方法中被初始化，对于方法 sayHello 的调用，它转发给了实际对象，在调用前后输出了一些跟踪调试信息，应该很好理解。上述例子是固定的所以称为静态代理。

输出跟踪调试信息可能是一个通用的需求，可以想象，如果每个类都需要，而又不希望修改类定义，我们需要为每个类创建代理，实现所有接口，那这个工作就太繁琐了，如果再有其他的切面需求，整个工作可能又要重新再来。这时，就需要动态代理了，接下来介绍两种实现方式：Java SDK 和 cglib。

public class SampleDynamicProxy {

    interface IService {
        void sayHello();
    }

    static class ConcreteService implements IService {

        @Override
        public void sayHello() {
            System.out.println("hello");
        }
    }

    static class SampleInvocationHandler implements InvocationHandler {

        private Object mRealObj;

        public SampleInvocationHandler(Object obj) {
            mRealObj = obj;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("entering method: " + method.getName());
            Object result = method.invoke(mRealObj, args);
            System.out.println("leaving method: " + method.getName());
            return result;
        }
    }

    public static void main(String[] args) {
        IService concreteService = new ConcreteService();
        IService proxyService = (IService) Proxy.newProxyInstance(IService.class.getClassLoader(),
                new Class<?>[]{IService.class}, new SampleInvocationHandler(concreteService));
        proxyService.sayHello();
    }
}

分析一下，IService 和 ConcreteService 依旧没变，程序输出也没变化，但是代理对象 proxyService 的创建方式改变了。其使用 java.lang.reflect包中的Proxy类的静态方法 newProxyInstance 来创建代理对象，这个方法的声明如下：

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

有三个参数，具体如下：

newProxyInstance 的返回值类型为 Object ，可以强制转换为 interfaces 数组中的某个接口类型。但是记住， 它不能强制转换为某个类类型 ，比如这里的 ConcreteService ，即使它实际代理的对象类型确实是 ConcreteService 。

SampleInvocationHandler 实现了 InvocationHandler ，它的构造方法接受一个参数 obj 表示被代理的对象，invoke方法处理所有的接口调用，它有三个参数：

在 SampleInvocationHandler 的 invoke 实现中，我们调用了 method 的 invoke 方法，传递了实际对象 mRealObj 作为参数，达到了调用实际对象对应方法的目的，在调用任何方法前后，输出跟踪调试语句。需要注意， 不能将proxy作为参数传递给method.invoke ，比如：

Object result = method.invoke(proxy, args);

上面的语句会出现死循环，因为proxy表示当前代理对象，这又会调用到 SampleInvocationHandler 的 invoke 方法。

接下来，我们看一下这里面的基本原理

Class<?> proxyClass = Proxy.getProxyClass(IService.class.getClassLoader(), new Class<?>[]{ISearchView.class});
try {
    Constructor<?> constructor = proxyClass.getConstructor(new Class<?>[]{InvocationHandler.class});
    SampleInvocationHandler handler = new SampleInvocationHandler(concreteService);
    IService proxyService = (IService) constructor.newInstance(handler);
    proxyService.sayHello();

    // 该方法用于获取JDK动态代理生成类$Proxy0的内容
    saveProxy0();
} catch (Exception e) {
    e.printStackTrace();
}

分为三步：

Proxy.getProxyClass 需要两个参数：一个是ClassLoader；另一个是接口数组。它会动态生成一个类，类名以 $Proxy 开头，后跟一个数字。对于上述示例，动态生成的类定义如下所示，为简化起见，忽略异常处理代码：

【注】这里需要手动去获取JDK动态代理生成类$Proxy0的内容

private static void saveProxy0() throws IOException {
    byte[] bytes = ProxyGenerator
            .generateProxyClass("$Proxy0", new Class<?>[]{IService.class});

    String pathDir = "C:\\Users\\SZSS\\Desktop\\out";
    String path = "\\$Proxy0.class";
    File f = new File(pathDir);
    if (!f.exists()) {
        f.mkdir();
    }
    path = f.getAbsolutePath() + path;
    f = new File(path);
    if (f.exists()) {
        f.delete();
    }
    f.createNewFile();

    try (FileOutputStream fos = new FileOutputStream(path)) {
        fos.write(bytes, 0, bytes.length);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public final class $Proxy0 extends Proxy implements IService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void sayHello() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.tufusi.lib.SampleDynamicProxy$IService").getMethod("sayHello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

$Proxy0 的父类是 Proxy ，它有一个构造方法，接受一个 InvocationHandler 类型的参数，保存为实例变量 h，h定义在父类Proxy中，它实现了 IService 接口，对于每个方法，如 sayHello，它调用 InvocationHandler 的 invoke 方法，对于 Object 中的方法，如 equals 、 toString 、 hashCode ， $Proxy0 同样转发给了 InvocationHandler 。

可以看出， 这个类定义本身与被代理的对象并没有关系，与 InvocationHandler 的具体实现也没有关系，而主要与接口数组有关，给定这个接口数组，它动态创建每个接口的实现代码，实现就是转发给 InvocationHandler ，与被代理对象的关系以及对它的调用由 InvocationHandler 的实现管理。

当然，可以通过jd-gui查看字节码文件，了解其实现原理，这个等后面字节码专栏写完，回来继续深挖这一块。立个flag吧！