AOP动态代理

       代理模式，核心是为其他对象提供一种代理以控制对这个对象的访问。AOP是一种面向切面的横切技术，主要采用动态代理来实现，实现InvocationHandler接口创建代理类调用invoke方法。

      动态代理类：
       Interface InvocationHandler：仅定义了一个方法Object：invoke(Object obj,Method method,Object[] args）。obj一般是指代理类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现。
Proxy：动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：
       Protected Proxy(InvocationHandler h）：构造函数。Static Class getProxyClass (ClassLoader loader,Class[] interfaces）：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
       Static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h）：返回代理类的一个实例，返回后的代理类可以当作被代理类使用。

public class LogHandler implements InvocationHandler {
    
    private Object targetObject;
    
    public Object newProxyInstance(Object targetObject) {
        this.targetObject = targetObject;
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                               targetObject.getClass().getInterfaces(), this);
    }
    
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("start-->>" + method.getName());
        for (int i=0; i<args.length; i++) {
            System.out.println(args[i]);
        }
        Object ret = null;
        try {
            //调用目标方法
            ret = method.invoke(targetObject, args);
            System.out.println("success-->>" + method.getName()); 
        }catch(Exception e) {
            e.printStackTrace();
            System.out.println("error-->>" + method.getName());
            throw e;
        }
        return ret;
    }

动态代理类    

public class DynamicProxy<T>{
   public static<T> T newProxyInstance(ClassLoader loader,Class<>[] interfaces,invocationHandler h){
    if (trrue){
      (new BeforeAdvice()).exec();
    }
 }
   return (T)Proxy.newProxyInstance(loader,interface,h)
}