Java动态代理

既然叫动态代理，那肯定会有静态代理，这里不再详细介绍什么是动态代理

下面，主要讲解动态代理的原理

在接触Spring时，经常能碰到AOP和IOC两个概念，IOC就是依赖注入，AOP的原理的就是动态代理。

首先我们申明一个Target的接口，为其声明一个方法：

public interface Interceptor {

    public void intercept();
}

接着，定义一个Log类和Transaction类来实现这个接口：

public class LogInterceptor implements Interceptor{

    @Override
    public void intercept(){
        System.out.println("日志记录开始");
    }
}

public class TransactionInterceptor implements Interceptor {

    @Override
    public void intercept() {
        System.out.println("事务开启");
    }
}

下面，定义一个动态代理类，必须实现InvocationHandler 这个接口：

public class TargetProxy implements InvocationHandler{

    private Target target;
    private Stack<Interceptor> interceptorStack;
     
    public TargetProxy(Target target, Stack<Interceptor> interceptorStack) {
        this.target = target;
        this.interceptorStack = interceptorStack;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("invoke");
        for(Interceptor interceptor:interceptorStack){
            interceptor.intercept();
        }
        return method.invoke(target, args);
    }
}

最后是我们的测试类：

public class Test {

    public static void main(String[] args) {
        Stack<Interceptor> interceptorStack =new Stack<>();
        interceptorStack.add(new LogInterceptor());
        interceptorStack.add(new TransactionInterceptor());
         
        Target target = new TargetImpl();
        target = (Target) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                        target.getClass().getInterfaces(),new TargetProxy(target, interceptorStack));
        System.out.println("Start Target");
        target.execute();
    }
    
}