√ JavaSE - 27.怎么使用代理（卷1 P273）

1. 利用代理可以在运行时创建实现了一组给定接口的新类，只有在编译时期无法确定需要实现哪个接口时才有必要使用代理。
2. 代理模式：使用一个代理对象将原对象包装起来，任何对原对象的调用都要通过代理对象，代理对象决定是否以及何时将方法调用转到原对象上。
3. 静态代理：代理类和被代理类在编译期间就确定下来了，不利于程序的扩展，每一个代理类只能为一个接口服务。
4. 动态代理：客户通过代理类来调用其他对象的方法，并且是在程序运行时根据需要动态创建被代理类的代理对象。

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

public class ProxyTest {
    public static void main(String[] args) {
        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory proxyInstance = (ClothFactory) DynamicProxyClothFactory.getProxyInstance(nikeClothFactory);
        proxyInstance.produceCloth();
    }
}

interface ClothFactory {
    void produceCloth();
}

class NikeClothFactory implements ClothFactory {
    @Override
    public void produceCloth() {
        System.out.println("Produce a cloth.");
    }
}

class StaticProxyClothFactory implements ClothFactory {
    private ClothFactory factory;

    public StaticProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }

    @Override
    public void produceCloth() {

    }
}

class DynamicProxyClothFactory {
    public static Object getProxyInstance(Object object) {
        InvocationHandlerTest invocationHandlerTest = new InvocationHandlerTest();
        invocationHandlerTest.bind(object);
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), invocationHandlerTest);
    }
}

class InvocationHandlerTest implements InvocationHandler {
    private Object object;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before");
        Object invoke = method.invoke(object, args);
        System.out.println("After");
        return invoke;
    }
}