动态代理那些事

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器  
static InvocationHandler getInvocationHandler(Object proxy)   

// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象  
static Class getProxyClass(ClassLoader loader, Class[] interfaces)   

// 方法 3：该方法用于判断指定类对象是否是一个动态代理类  
static boolean isProxyClass(Class cl)   

// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例  
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)  

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象  
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行  
Object invoke(Object proxy, Method method, Object[] args) 

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发  
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用  
InvocationHandler handler = new InvocationHandlerImpl(..);   

// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象  
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });   

// 通过反射从生成的类对象获得构造函数对象  
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });   

// 通过构造函数对象创建动态代理类实例  
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });   

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发  
InvocationHandler handler = new InvocationHandlerImpl(..);   

// 通过 Proxy 直接创建动态代理类实例  
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,   
     new Class[] { Interface.class },  handler );  

public interface Person {

    /**
     * 表演
     * @param payment 薪资待遇
     */
    void play(int payment);

    /**
     * 吃饭
     * @param food 食物名称
     */
    void eat(String food);

}

public class Actor implements Person {
    @Override
    public void play(int payment) {
        Log.e("jia", "eat: 开始表演  " + payment);
    }

    @Override
    public void eat(String food) {
        Log.e("jia", "eat: 开始吃饭  " + food);
    }
}

public class BusinessInvocationHandler implements InvocationHandler {

    private Actor actor;

    public BusinessInvocationHandler(Actor actor) {
        this.actor = actor;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object result = null;
        Log.e("jia", "invoke: 代理之前要做的事情");
        Log.e("jia", "invoke: 方法名： " + method.toString());
        if (args != null && args.length > 0){
            if(args[0] instanceof String || args[0] instanceof Integer){
                Log.e("jia", "invoke: 参数： " + args[0]);
            }
        }
        result = method.invoke(actor, args);
        Log.e("jia", "invoke: 代理之后要做的事情");

        return result;
    }
}

public class ProxyFactory {

    public static Person getProxy() {
        Actor actor = new Actor();
        BusinessInvocationHandler handler = new BusinessInvocationHandler(actor);
        Person personProxy = (Person) Proxy.newProxyInstance(actor.getClass().getClassLoader(), actor.getClass().getInterfaces(), handler);
        return personProxy;
    }

}

var proxy = ProxyFactory.getProxy()
proxy.eat("面包")
proxy.play(1200)