AOP in Spring

动态代理：利用Java的反射技术(Java Reflection)，在运行时创建一个实现某些给定接口的新类（也称“动态代理类”）及其实例（对象）。代理的是接口(Interfaces)，不是类(Class)，更不是抽象类。

动态代理有什么用
解决特定问题：一个接口的实现在编译时无法知道，需要在运行时才能实现
实现某些设计模式：适配器(Adapter)或修饰器(Decorator)
面向切面编程：如AOP in Spring

上代码实例：

public class ProxyListTest {
public static void main(String[] args) {

    // 代理目标( proxy target ) : 谁将被被别人所代理
    final Object target = new ArrayList<>();

    Class<?> targetClass = target.getClass() ;

    // 获得 代理目标 对应的类 的 "类加载器" ( 那个 "类加载器" 加载了 代理目标对应的类 )
    ClassLoader loader = targetClass.getClassLoader();
    // 获得 代理目标 对应的类 所实现的接口
    Class<?>[] interfaces = targetClass.getInterfaces() ;

    // 创建用来 派遣方法调用的 指派器 ( 请求派遣器 )
    InvocationHandler handler = new InvocationHandler(){
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object result = null ;
            try {
            	 // 调用 target 的 method 方法并传入参数
                result = method.invoke(target, args);
            } catch( Exception cause ) {
                throw new RuntimeException( "调用失败" , cause );
            }
            return result ;
        }
    };
    /**
        * static newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
        * 第一个参数是：类加载器(Class Loader)
        * 第二个参数是：需要实现的接口数组
        * 第三个参数是：InvocationHandler接口。所有动态代理类的方法调用，都会交由InvocationHandler接口实现类里的invoke()方法去处理。这是动态代理的关键所在。
    */

    // 代理对象( proxy object ) : 谁将去代理别人
    Object proxy = Proxy.newProxyInstance( loader , interfaces , handler ) ;
    System.out.println( proxy ); // proxy.toString()
    System.out.println( System.identityHashCode( proxy ) );

    if( proxy instanceof List ) {
        List list = (List) proxy ;
        list.add( "张三" );
        list.add( "李四" );
        list.add( "王五" );
        // list.toString()
        System.out.println( list ); 
    }
  }
}