上一篇文章说到用AspectJ的切点表达式实现非侵入式AOP，可以不在原来代码的基础上增加代码或注解接可以增加切面逻辑。但是有一个关键点，就是AspectJ是静态代理，会在编译期生成 AOP代理类。而且AspectJ的切点表达式是通过注解参数的方式添加的，必须是编译期常量，也就是只能硬编码写死。如果想进一步将这些切点描述集中到一个配置文件，而且用一种可读性比较强的描述，必须用动态代理，在运行期读取配置文件并解析出切点。

一、JDKProxy

JDKProxy是通过实现同一个接口的同名方法，生成和调用代理类来实现动态代理的：

JDKProxy.png

例如，我需要在TestController的hhh方法加日志逻辑：
（1）原来的目标类TestController：

@RestController
public class TestController implements BaseController{

    @RequestMapping("/h")
    public String hhh(String i,Integer e) throws Exception{
        System.err.println("h");
        return "h";
    }
}

（2）由于JDKProxy是通过实现同一个接口的同名方法，所以接口一定要有代理目标方法的声明。被实现的接口BaseController：

public interface BaseController {
    String hhh(String i,Integer e) throws Exception;
}

（3）实现InvocationHandler，重写invoke方法，增加切面逻辑：

 class MyInvocationHandler implements InvocationHandler{
        private Object object;
        MyInvocationHandler(Object obj){
            object = obj;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //日志记录逻辑
            LogAciton.before(method,args);
             //反射调用原来的目标方法
            Object result = method.invoke(object,args);
            return result;
        }
    }

（4）通过反射调用代理方法：

public class JDKDynamicProxyDemo {

    public static void main(String[] args) throws Exception {
        JDKDynamicProxyDemo demo = new JDKDynamicProxyDemo();
        demo.run();
    }

    public void run() throws Exception{
        //假设已经通过解析配置拿到原来目标的类名（className）和方法名（methodName）
        Object testController = Class.forName(className).newInstance();
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class[] interfaces = testController.getClass().getInterfaces();
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler(testController);
        Object self = Proxy.newProxyInstance(classLoader,interfaces,myInvocationHandler);
        //入参先暂定为"i"和1
        Method method = self.getClass().getDeclaredMethod(methodName,"i".getClass(),int.class);
        //调用代理方法
        method.invoke(self,"i",1);
    }

由上可知，这种代理方式最多的缺点就是需要增加一个接口，如果目标类比较多，那就会多出很多不必要的接口。

二、Cglib

和JDKProxy不同，Cglib是通过继承目标类生成代理类的，并不需要增加接口
（1）实现MethodInterceptor，增加切面逻辑：

public class MyMethodInterceptor implements MethodInterceptor{
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
             //日志记录逻辑
            LogAciton.before(method,args);
            //注意这里的方法调用，不是用反射
            Object object = proxy.invokeSuper(obj, args);
            return object;
        }
    }

（2）获取动态代理类，并通过反射调用：

public class CglibDynamicProxyDemo {
   //已经通过解析配置拿到原来目标的类名和方法名，用自定义的Signature对象存储
    public List<Signature> beforeList = JsonResolver.getBefore();

    public static void main(String[] args) throws Exception {
        CglibDynamicProxyDemo demo = new CglibDynamicProxyDemo();
        demo.run();
    }

    public void run()throws Exception{
        Signature before =beforeList.get(0);
        //创建Enhancer对象，类似于JDK动态代理的Proxy类
        Enhancer enhancer = new Enhancer();
        //设置要继承的类
        enhancer.setSuperclass(Class.forName(before.getClazz()));
        enhancer.setCallback(new MyMethodInterceptor());
        Object proxy = enhancer.create();
        //处理方法签名
        String methodName = before.getMethod();
        List<Class> classList = new ArrayList<>();
        for(String arg:before.getArgs()){
            classList.add(Class.forName(arg));
        }
        Class[] classes = classList.toArray(new Class[classList.size()]);
        //设置方法入参
        Object[] objs = new Object[]{"istr",22};
        //反射调用
        Method method = proxy.getClass().getDeclaredMethod(methodName,classes);
        method.invoke(proxy,objs);
    }

可以看到，不考虑性能等问题，通过Cglib实现的是最完美的，既可以通过解析配置拿到目标方法，又可以不用额外增加接口等代码，是真正的非侵入，将这部分代码移除完全对原来的逻辑代码没影响，还不留脏代码。可是最大的问题（坑）是，怎么能像AspectJ一样，在执行到具体方法时，指定调用代理方法呢？
才疏学浅，坑还没填完.....更详细的代码见：https://github.com/RoxyJNg/non-intrusive-log