package Reflect;

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

public class DynamicProxyDemo {
    public static void main(String[] args) {
        Hello hello = (Hello) Proxy.newProxyInstance(
                // 指定 新生成代理类 使用的类加载器
                Hello.class.getClassLoader(),
                // 新生成代理类实现的接口类型
                new Class<?>[] {Hello.class},
                // 自定义调用处理器
                // 当新生成的代理对象的方法被调用时，会触发自定义处理器的 invoke 方法，
                // 方法调用的相关信息（如方法对象、参数等）会作为参数传入自定义调用处理器的 invoke 方法
                // 自定义调用处理器的 invoke 方法中，调用 HelloImpl 的实现方法，并且可以在调用前后执行一些自定义操作
                new MyInvocationHandler(new HelloImpl())
        );
        hello.sayHello();
    }
}

/**
 * 接口
 */
interface Hello{
    void sayHello();
}

/**
 * 接口实现类，被代理对象
 */
class HelloImpl implements Hello {
    @Override
    public void sayHello() {
        System.out.println("Hello World");
    }
}

class MyInvocationHandler implements InvocationHandler {

    /**
     * 被代理对象
     */
    private Object target;

    /**
     * 构造函数 传入被代理对象
     * @param target
     */
    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    /**
     * 对 被代理对象 的调用方法增强
     *
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法调用前，执行xxx
        System.out.println(method.getName() + "方法调用前");
        // 被代理对象 方法调用
        Object result = method.invoke(target, args);
        // 方法调用结束后，执行xxx
        System.out.println(method.getName() + "方法执行完成");
        return result;
    }
}