利用Cglib实现AOP

前文讲了, 可以利用Spring, Guice等框架提供的容器实现AOP, 如果想绕过容器, 直接注入Class,

可以利用Cglib为对象加上动态代理,实现代码切入, 但是每次调用比较繁琐,

因此我们还需要给他加了一层语法糖, 使之更易用.

Advice

Spring带了一堆Advice, 我们只模拟实现环绕Advice, 以及增加了一个Clear切入的注解, 下面看具体实现.

 /**
  * 环绕Advie
  *
  * 可以加在类上, 或者方法上.
  * 加在类上的话, 类中所有无@Clear注解的方法都会被切入
  *
  *     @Before({CustomInterceptor.class, B.class})
  *     @Before(CustomInterceptor.class)
  */
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.TYPE, ElementType.METHOD})
 public @interface Before {
     Class<? extends Interceptor>[] value();
 }

 /**
  * 清除Advice
  *
  * 可以清除方法上的指定Interceptor, 若不指定, 则清除所有切入.
  *
  *     @Clear 清除所有
  *     @Clear(CustomInterceptor.class) 清除CustomInterceptor
  */
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.TYPE, ElementType.METHOD})
 public @interface Clear {
     Class<? extends Interceptor>[] value() default {};
 }

语法糖

直接调用Cglib做切入, 需要setSuperClass, setCallback等等.

 　　Enhancer enhancer = new Enhancer();
 　　enhancer.setSuperclass(AopDemo.class);
 　　enhancer.setCallback(new MethodInterceptorImpl());

 　　AopDemo demo = (AopDemo) enhancer.create();

我们需要对Enhancer以及Callback进行封装, 减少复杂度

 import java.util.concurrent.ConcurrentHashMap;

 /**
  * cglib中Enhancer的语法糖, 让注入更简单点
  */
 public class Enhancer {

     private static final ConcurrentHashMap<String, Object> singleton = new ConcurrentHashMap<String, Object>();

     private Enhancer(){}

     public static <T> T enhance(Class<T> targetClass) {
         return (T)net.sf.cglib.proxy.Enhancer.create(targetClass, new Callback());
     }

     public static <T> T enhance(Class<T> targetClass, Interceptor... injectInters) {
         return (T)net.sf.cglib.proxy.Enhancer.create(targetClass, new Callback(injectInters));
     }

     public static <T> T getTarget(String singletonKey) {
         return (T)singleton.get(singletonKey);
     }

     public static <T> T enhance(String singletonKey, Class<T> targetClass) {
         Object target = singleton.get(singletonKey);
         if (target == null) {
             target = enhance(targetClass);
             singleton.put(singletonKey, target);
         }
         return (T)target;
     }

     public static <T> T enhance(String singletonKey, Class<T> targetClass, Interceptor... injectInters) {
         Object target = singleton.get(singletonKey);
         if (target == null) {
             target = enhance(targetClass, injectInters);
             singleton.put(singletonKey, target);
         }
         return (T)target;
     }
     public static <T> T enhance(Object target) {
         return (T)net.sf.cglib.proxy.Enhancer.create(target.getClass(), new Callback(target));
     }

     public static <T> T enhance(Object target, Interceptor... injectInters) {
         return (T)net.sf.cglib.proxy.Enhancer.create(target.getClass(), new Callback(target, injectInters));
     }
     public static <T> T enhance(String singletonKey, Object target) {
         Object result = singleton.get(singletonKey);
         if (result == null) {
             result = enhance(target);
             singleton.put(singletonKey, result);
         }
         return (T)result;
     }

     public static <T> T enhance(String singletonKey, Object target, Interceptor... injectInters) {
         Object result = singleton.get(singletonKey);
         if (result == null) {
             result = enhance(target, injectInters);
             singleton.put(singletonKey, result);
         }
         return (T)result;
     }

 }

 import net.sf.cglib.proxy.MethodInterceptor;
 import net.sf.cglib.proxy.MethodProxy;

 import java.lang.reflect.Method;
 import java.util.HashSet;
 import java.util.Set;

 /**
  * Callback.
  */
 class Callback implements MethodInterceptor {

     private Object injectTarget = null;
     private final Interceptor[] injectInters;

     private static final Set<String> excludedMethodName = buildExcludedMethodName();
     private static final InterceptorManager interMan = InterceptorManager.me();

     public Callback() {
         this.injectInters = InterceptorManager.NULL_INTERS;
     }

     public Callback(Interceptor... injectInters) {
         checkInjectInterceptors(injectInters);
         this.injectInters = injectInters;
     }

     public Callback(Object injectTarget, Interceptor... injectInters) {
         if (injectTarget == null) {
             throw new IllegalArgumentException("injectTarget can not be null.");
         }
         checkInjectInterceptors(injectInters);
         this.injectTarget = injectTarget;
         this.injectInters = injectInters;
     }

     private void checkInjectInterceptors(Interceptor... injectInters) {
         if (injectInters == null) {
             throw new IllegalArgumentException("injectInters can not be null.");
         }
         for (Interceptor inter : injectInters) {
             if (inter == null) {
                 throw new IllegalArgumentException("interceptor in injectInters can not be null.");
             }
         }
     }

     public Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
         if (excludedMethodName.contains(method.getName())) {
             // if (method.getName().equals("finalize"))
             //     return methodProxy.invokeSuper(target, args);
             // return this.injectTarget != null ? methodProxy.invoke(this.injectTarget, args) : methodProxy.invokeSuper(target, args);

             // 保留上面注释部分，此处为优化
             if (this.injectTarget == null || method.getName().equals("finalize")) {
                 return methodProxy.invokeSuper(target, args);
             } else {
                 return methodProxy.invoke(this.injectTarget, args);
             }
         }

         if (this.injectTarget != null) {
             target = this.injectTarget;
             Interceptor[] finalInters = interMan.buildServiceMethodInterceptor(injectInters, target.getClass(), method);
             Invocation invocation = new Invocation(target, method, args, methodProxy, finalInters);
             invocation.useInjectTarget = true;
             invocation.invoke();
             return invocation.getReturnValue();
         }
         else {
             Class<?> targetClass = target.getClass();
             if (targetClass.getName().indexOf("$$EnhancerByCGLIB") != -1) {
                 targetClass = targetClass.getSuperclass();
             }
             Interceptor[] finalInters = interMan.buildServiceMethodInterceptor(injectInters, targetClass, method);
             Invocation invocation = new Invocation(target, method, args, methodProxy, finalInters);
             invocation.useInjectTarget = false;
             invocation.invoke();
             return invocation.getReturnValue();
         }
     }

     private static final Set<String> buildExcludedMethodName() {
         Set<String> excludedMethodName = new HashSet<String>();
         Method[] methods = Object.class.getDeclaredMethods();
         for (Method m : methods) {
             excludedMethodName.add(m.getName());
         }
         // getClass() registerNatives() can not be enhanced
         // excludedMethodName.remove("getClass");
         // excludedMethodName.remove("registerNatives");
         return excludedMethodName;
     }
 }

封装后可以直接使用一句话, 还可用来增强已有对象

         AopDemo demo = Enhancer.enhance(AopDemo.class);

示例

 @Before({PrivilegeInterceptor.class, LogInterceptor.class})
 public class AopDemo {

     public static void main(String[] args){
         AopDemo demo = Enhancer.enhance(AopDemo.class);
         demo.doSomething();
         demo.doOtherthing();

     }

     public void doOtherthing() {
         // 默认沿用Class的interceptor
         System.out.println("do 111111111111111");
     }

     @Clear(PrivilegeInterceptor.class)
     public void doSomething() {
         // 手动清除了权限Interceptor
         System.out.println("do 222222222222222");
     }
 }

 public class LogInterceptor implements Interceptor{
     @Override
     public void intercept(Invocation inv) {
         inv.invoke();
         System.out.println("Log记录入库");
     }
 }

 public class PrivilegeInterceptor implements Interceptor{
     @Override
     public void intercept(Invocation inv) {
         System.out.println("鉴权成功");
         inv.invoke();
     }
 }

doOtherthing执行结果

鉴权成功
do 111111111111111
Log记录入库

doSomething执行结果

do 222222222222222
Log记录入库

其他使用

直接用来增强对象

         AopDemo demoSinle1 = Enhancer.enhance(AopDemo.getInstance());

在enhance里new Interceptor

         AopDemo demo3 = Enhancer.enhance(AopDemo.class, new Interceptor() {
             @Override
             public void intercept(Invocation inv) {
                 System.out.println("new before");
                 inv.invoke();
                 System.out.println("new after");
             }
         });
         demo3.doSomething();

在需要增强的方法上写@Before

     @Before(LogInterceptor.class)
     public void doOtherthing() {
     }