利用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() {
    }