spring-aop

聊spring-aop之前，先来看一下Aspectj的使用

Aspectj

从http://www.eclipse.org/aspectj/downloads.php下载好aspectj-1.x.x.jar后，使用java -jar aspectj-1.x.x.jar命令就可以安装了。

简单编写了两个文件用来测试

切面类

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AspectjSample {
    @Before("execution(* *(..))")//匹配所有方法
    public void before() {
        System.out.println("before");
    }
}

测试类

public class AspectjTest {
    public static void main(String[] args) {
        System.out.println("main");
    }
    private void privateFun() {
        System.out.println("private fun");
    }
    private static void privateStaticFun() {
        System.out.println("private static fun");
    }
}

通过ajc -source 8 -d . -cp ../lib/aspectjrt.jar AspectjTest.java AspectjSample.java编译命令，将切面AspectjSample织入AspectTest中，将生成的class文件反编译后

切面类

import org.aspectj.lang.NoAspectBoundException;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AspectjSample {
    public AspectjSample() {
    }

    @Before("execution(* *(..))")
    public void before() {
        System.out.println("before");
    }

    public static AspectjSample aspectOf() {
        if (ajc$perSingletonInstance == null) {
            throw new NoAspectBoundException("AspectjSample", ajc$initFailureCause);
        } else {
            return ajc$perSingletonInstance;
        }
    }

    public static boolean hasAspect() {
        return ajc$perSingletonInstance != null;
    }

    static {
        try {
            ajc$postClinit();
        } catch (Throwable var1) {
            ajc$initFailureCause = var1;
        }

    }
}

测试类

public class AspectjTest {
    public AspectjTest() {
    }

    public static void main(String[] args) {
        AspectjSample.aspectOf().before();
        System.out.println("main");
    }

    private void privateFun() {
        AspectjSample.aspectOf().before();
        System.out.println("private fun");
    }

    private static void privateStaticFun() {
        AspectjSample.aspectOf().before();
        System.out.println("private static fun");
    }
}

可见aspectj在字节码层面（因为源文件不会被修改，只能通过编译或类加载过程修改字节码，从而生成最终的类）修改了我们的测试类，aspectj提供了编译期和类加载其的织入方式，spring-aop又是怎样的呢？

spring-aop

在spring中使用aspectj注解可以非常方便的编写aop，我们就以aspectj注解为例来说明spring-aop（spring只是使用了Aspectj的相关注解、语法，并没有使用Aspectj的代理机制）。

切面类

@Order(1)
@Aspect
public class SpringAOP {
    @Before("@annotation(age)")//使用Aspectj语法
    public void before(Age age) {
        System.out.println("before");
    }
}

Age注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(value = RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Age {
    int min() default 0;
    int max() default 150;
}

 

 Service类

@Service
public class UserServiceImpl implements UserService {
    @Resource
    private UserMapper userMapper;
    ......
    @Override
    @Age(min = 10, max = 20)
    public void insert(User user) {
        userMapper.insert(user);
    }
    ......    
}

spring-aop配置文件

<!--开启aspectj注解，proxy-target-class表示是否使用基于类的代理模式（cglib）-->
<aop:aspectj-autoproxy proxy-target-class="false"/>
<!--切面类-->
<bean id="springAOP" class="com.zyong.spring.aop.SpringAOP" />

 

在测试类中注入UserService，调用service类的insert方法，简单插入一个数据项，会发现实际调用的是代理类的insert方法（说明测试类中注入的就是UserService代理类）。

 

invoke就是InvocationHandler接口中的invoke，其核心逻辑就是调用的proceed方法

    public Object proceed() throws Throwable {
        //    We start with an index of -1 and increment early.
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();//调用真正的业务逻辑
        }

        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

 可以看出，spring的aop是在jdk的动态代理类中加入了责任链设计模式（拦截器），在代理方法被首次调用时，会先找到与该方法匹配的拦截器，首次调用后就可将其缓存。

 

最后再提一下cglib，与Aspectj、jdk动态代理都不同，cglib是在运行时动态生成被代理类的子类。

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.junit.Test;

import java.lang.reflect.Method;

public class CGLibTest {
    private void hello() {
        System.out.println("hello");
    }

    @Test
    public void test() {
        CGLibTest instance = CGLibTest.getInstance();
        instance.hello();
        //before
        //hello
        //after
    }

    private static CGLibTest getInstance() {
        Enhancer en = new Enhancer();
        // 设置要代理的目标类
        en.setSuperclass(CGLibTest.class);
        // 设置要代理的拦截器
        en.setCallback(new CGLibAspect());
        // 生成代理类的实例
        return (CGLibTest) en.create();
    }

    private static class CGLibAspect implements MethodInterceptor {

        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            System.out.println("before");
//            Object result = method.invoke(obj, args);//method是代理后的方法
            Object result = proxy.invokeSuper(obj, args);
            System.out.println("after");
            return result;
        }
    }
}

 

参考：https://www.ibm.com/developerworks/cn/java/j-lo-springaopcglib/

　　http://www.baeldung.com/aspectj