AspectJ学习总结

AspectJ 是spring 切面编程的一种实现方式。以前的切面是用spring AOP。但是由于种种原因，现在更多的是使用AspectJ来实现spring的切面编程

AspectJ是采用静态代理的方式。即在程序运行前代理类就已经改变了(源码已经改变了,因为在编译的时候AspectJ机制会动态的织入代理类。这个时候用特定的工具查看源码即可发现源码已经发生改变)；动态代理：程序运行的时候在内存中生成代理类的对象。在调用代理类的时候均使用内存中的代理对象(源码不会改变)。采用静态代理有如下好处:

1. 静态代理的运行效率高于动态代理。

（但是缺点也很明显。创建静态代理的时候比创建动态代理花的时间长，所以如果是不需要频繁的创建代理类的时候，可以考虑使用静态代理。并且静态代理在扩展方面不如动态代理）

package hello.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

/**
 * Created by Administrator on 2017/8/24.
 * 切面练习类
 * 各种advice的顺序. Around > before > 执行方法 > Around > afterReturning > after
 * @After 可以用于清理现场。比如释放资源等等
 */
@Aspect
public class AspectDeclare {

    @Pointcut("execution(* hello.aspect.AspectTest.*(..))") //从前到后的正则意义: 方法的返回类型--包名--类名--所有方法
    public void printMessage() {
    }

    @Before(value = "printMessage()")
    public void before(JoinPoint joinPoint) throws Exception{
        System.out.println("先于这个之前执行" + joinPoint.getSignature().getName());
    }

    /** afterReturning:后置通知(应用：常规数据处理)
     　　　　方法正常返回后执行，如果方法中抛出异常，通知无法执行，必须在方法执行后才执行，所以可以获得方法的返回值。*/
    @AfterReturning(value = "execution(* hello.aspect.AspectTest.*(..))", returning = "ret")
    public void afterReturning(JoinPoint joinPoint, Object ret) {
        System.out.println("后置通知:" + joinPoint.getSignature().getName() + " ---returning value:" + ret);
    }

    /**
     *  around:环绕通知(应用：十分强大，可以做任何事情)
     *　　　方法执行前后分别执行，可以阻止方法的执行，必须手动执行目标方法
     */
    @Around("printMessage()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕执行前");
        Object obj = proceedingJoinPoint.proceed();
        System.out.println("环绕执行后");
        return obj;
    }


}

粗略看了下AspectJ的相关内容。简单使用不难。记住里面几个关键点。然后记下里面正则的语法即可