设计模式之代理模式（静态代理和动态代理）

代理模式

java中代理模式分为静态代理和动态代理，其中动态代理就是通过反射完成的。代理模式的主要思想就是有些类不好直接做某些操作，于是就通过代理类来完成。静态代理是每一个类如果想要使用代理模式，必须有一个代理类；动态代理则是有了明显的进步：所有的类使用一个代理类。

静态代理

实现代码如下：

/**
 * 公共实现的接口，（主题）
 */
interface ClothFactory{
    void produceCloth();
}

/**
 * 代理类
 */
class ProxyClothFactory implements ClothFactory{

    private ClothFactory clothFactory;

    public ProxyClothFactory(ClothFactory clothFactory){
        this.clothFactory = clothFactory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂开始准备工作。。。");
        clothFactory.produceCloth();
        System.out.println("代理工厂做后续工作。。。");
    }
}

/**
 * 被代理类
 */
class NikeClothFatory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("NikeClothFatory生产工作。。。");
    }
}
public class StaticProxyTest{
    public static void main(String[] args) {
        // 创建被代理对象
        NikeClothFatory nikeClothFatory = new NikeClothFatory();

        // 创建代理对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nikeClothFatory);
        proxyClothFactory.produceCloth();
    }
}

动态代理

动态代理思想：所有的被代理类使用一个代理类去完成工作。要想实现动态代理，必须要解决的问题：

1. 如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象
2. 当通过代理类的对象调用方法的时候，如何动态的去调用被代理类中的同名方法。
   
   实现代码如下：

interface Human{
    String getBelief();
    void eat(String food);
}
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "i believe i can!";
    }

    @Override
    public void eat(String food) {
        System.out.println("你吃"+food);
    }
}

/**
 * 动态代理思想：所有的被代理类使用一个代理类去完成工作。
 * 要想实现动态代理，必须要解决的问题：
 * 1. 如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象
 * 2. 当通过代理类的对象调用方法的时候，如何动态的去调用被代理类中的同名方法。
 */
class ProxyFactory{
    // 动态的创建一个代理类及其对象，解决第一个问题
    // obj 为代理的对象
    public static Object getProxyInstance(Object obj){
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        myInvocationHandler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), myInvocationHandler);
    }
}
class MyInvocationHandler implements InvocationHandler{

    // 需要使用被代理类的对象进行赋值
    private Object obj;

    public void bind(Object obj){
        this.obj = obj;
    }

    /**
     * 当通过代理类的对象调用方法a时，就会自动调用invoke()方法
     * 将被代理类要执行的方法a的功能声明在invoke()中
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // method 为代理类对象调用的方法， 此方法也就作为了被代理类对象要调用的方法
        // obj 被代理的对象
        Object invoke = method.invoke(obj, args);
        // method.invoke方法的返回值就作为当前类中的invoke()
        return invoke;
    }
}


public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        // proxyInstance代理类的对象
        Human proxyInstance = (Human)ProxyFactory.getProxyInstance(superMan);
        System.out.println(proxyInstance.getBelief());
        proxyInstance.eat("西瓜");
    }
}

关于动态代理原理可以参考https://www.jianshu.com/p/95970b089360