静态代理和动态代理

代理模式是一种常用的设计模式，是为其他对象提供一种代理以控制对该对象的访问。开发过程中，一个对象不想或者不能直接引用另一个对象（比如使用第三方开源框架），而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式有两个非常直观的优点：
优点一：可以隐藏委托类的实现;
这个应该比较好理解，代理类中会调用实现类的方法，二实现类方法可以以库的形式隐藏起来，起到一定的具体实现保护作用

优点二：可以实现客户与委托类间的解耦，在不修改委托类代码的情况下能够做一些额外的处理
这个既是代理的优点，也是面向对象的优点。因为工程编译好后，如果需要调整实现类，可以将实现类修改后，再编译成class文件，而不用修改委托类代码，实现客户与委托类的解耦。

静态代理
静态代理在团队开发时可能会使用到，特别是当团队不同组别约定调用接口的时候，为了不受另一组接口实现的影响，可以选择代理设计模式，静态代理在编译时期就已经确定接口的调用，如下所示：
设定一个约定接口Contract：

package com;

public interface Contract {
    void func0();
    void func1();
}

接口实现类Source：

package com;

public class Source implements Contract {
    @Override
    public void func0(){
        System.out.println("func0");
    }
    @Override
    public void func1(){
        System.out.println("func1");
    }
}

最后是一个代理类，通过构造函数注入的方式，实现接口的调用：

package com;

public class ProxyC implements Contract{

    private Contract contract;

    public ProxyC(Contract contract){
        this.contract = contract;
    }
    @Override
    public void func0(){
        contract.func0();
    }
    @Override
    public void func1(){
        contract.func1();
    }
}

测试类Test:

package com;

public class Test {
    public static void main(String[] args){
        Contract contract = new Source();
        ProxyC proxyC = new ProxyC(contract);
        proxyC.func0();
    }
}

输出：

func0

动态代理
动态代理相对于静态代理而言，最大的不同在于，静态代理在编译期就已经确定了接口的调用关系；而动态代理是在运行期完成接口的调用。
动态代理在一些框架中使用特别频繁，比如Spring AOP，MyBatis拦截机制（插件实现）等，还有一些监测SDK，比如友盟的一些接口，它们实现的原理都是动态代理。

先定一个约束接口Contract：

package com;

public interface Contract {
    void func0();
    void func1();
}

再定义委托类Source：

package com;

public class Source implements Contract {
    @Override
    public void func0(){
        System.out.println("func0");
    }

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

定义一个MyHandler类，用于实现InvocationHandler中的invoke接口，这一步很重要：

package com;

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

public class MyHandler implements InvocationHandler {
    Object object;
    public MyHandler(Object obj){
        this.object = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        System.out.println("before");
        Object result = method.invoke(object, args);
        System.out.println("after");
        return result;
    }
}

上述invoke函数表明，动态代理可以实现批量修改函数调用，是一个很典型的AOP设计。

测试代码：

package com;

import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args){
        Contract contract = new Source();
        MyHandler myHandler = new MyHandler(contract);
        Contract con = (Contract) Proxy.newProxyInstance(Contract.class.getClassLoader(),
                new Class[]{Contract.class}, myHandler);
        con.func0();
    }
}

输出：

before
func0
after