Spring AOP概念以及基于注解开发AspectJ

一，Spring AOP的基本概念。

AOP即面向切面编程。AOP采取横向抽取机制，将分散在各个方法中的重复代码抽取出来，然后在程序编译或运行阶段，再将这些抽取出来的代码应用到各个需要执行的地方。
在AOP中，横向抽取机制的类与切面的关系如下图所示：

二，基于注解开发AspectJ

AspectJ注解如下表所示：

注解名称	描述
@Aspect	用于定义一个切面，注解在切面类上。
@Pointcut	用于定义切入点表达式。在使用时需要定义一个切入点方法，该方法是一个返回值为void，且方法体位空的普通方法。
@Before	用于定义前置通知。在使用时，通常为其指定Value值，该值可以是已有的切入点，也可以是切入点表达式。
@AfterReturning	用于定义后置返回通知。在使用时，通常为其指定Value值，该值可以是已有的切入点，也可以是切入点表达式。
@Around	用于定义环绕通知。在使用时，通常为其指定Value值，该值可以是已有的切入点，也可以是切入点表达式。
@AfterThrowing	用于定义异常通知。在使用时，通常为其指定Value值，该值可以是已有的切入点，也可以是切入点表达式。另外哈游一个throwing属性用于访问目标方法抛出的异常，该属性值与异常通知方法中同名的形参一致。
@After	用于定义后置（最终）通知。在使用时，通常为其指定Value值，该值可以是已有的切入点，也可以是切入点表达式。

三，基于注解开发AspectJ的简单实例。

1.需要添加的依赖文件。

spring四个核心模块jar包以及spring框架需要依赖的jar包。spring-beans-xxx.jar，spring-core-xxx.jar，spring-context-xxx.jar，spring-expression-xxx.jar,commons-logging-xxx.jar。为AspectJ框架提供的支持spring-aspects-xxx.jar以及aspectjweaver-xxx.jar（xxx为版本号）。

2.具体实现代码。

（1）编写dao层的接口以及实现类：

package aspectj.dao;
public interface TestDao {
	public void save();
	public void modify();
	public void delete();
}

package aspectj.dao;
import org.springframework.stereotype.Repository;
@Repository("testDao")
public class TestDaoImpl implements TestDao{
	@Override
	public void save() {
		System.out.println("保存");
	}
	@Override
	public void modify() {
		System.out.println("修改");
	}
	@Override
	public void delete() {
		System.out.println("删除");
	}
}

（2）编写一个切面类：

package aspectj.annotation;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
/**
 * 切面类，在此类中编写各种类型通知
 */
@Aspect//@Aspect声明一个切面
@Component//@Component让此切面成为Spring容器管理的Bean
public class MyAspect {
	/**
	 * 定义切入点，通知增强哪些方法。
"execution(* aspectj.dao.*.*(..))" 是定义切入点表达式，
该切入点表达式的意思是匹配aspectj.dao包中任意类的任意方法的执行。
其中execution()是表达式的主体，第一个*表示的是返回类型，使用*代表所有类型；
aspectj.dao表示的是需要匹配的包名，后面第二个*表示的是类名，使用*代表匹配包中所有的类；
第三个*表示的是方法名，使用*表示所有方法； 后面(..)表示方法的参数，其中“..”表示任意参数。
另外，注意第一个*与包名之间有一个空格。
	 */
	@Pointcut("execution(* aspectj.dao.*.*(..))")
	private void myPointCut() {
	}
	/**
	 * 前置通知，使用Joinpoint接口作为参数获得目标对象信息
	 */
	@Before("myPointCut()")//myPointCut()是切入点的定义方法
	public void before(JoinPoint jp) {
		System.out.print("前置通知：模拟权限控制");
		System.out.println("，目标类对象：" + jp.getTarget() 
		+ "，被增强处理的方法：" + jp.getSignature().getName());
	} 
	/**
	 * 后置返回通知
	 */
	@AfterReturning("myPointCut()")
	public void afterReturning(JoinPoint jp) {
		System.out.print("后置返回通知：" + "模拟删除临时文件");
		System.out.println("，被增强处理的方法：" + jp.getSignature().getName());
	}
	/**
	 * 环绕通知
	 * ProceedingJoinPoint是JoinPoint子接口，代表可以执行的目标方法
	 * 返回值类型必须是Object
	 * 必须一个参数是ProceedingJoinPoint类型
	 * 必须throws Throwable
	 */
	@Around("myPointCut()")
	public Object around(ProceedingJoinPoint pjp) throws Throwable{
		//开始
		System.out.println("环绕开始：执行目标方法前，模拟开启事务");
		//执行当前目标方法
		Object obj = pjp.proceed();
		//结束
		System.out.println("环绕结束：执行目标方法后，模拟关闭事务");
		return obj;
	}
	/**
	 * 异常通知
	 */
	@AfterThrowing(value="myPointCut()",throwing="e")
	public void except(Throwable e) {
		System.out.println("异常通知：" + "程序执行异常" + e.getMessage());
	}

	/**
	 * 后置（最终）通知
	 */
	@After("myPointCut()")
	public void after() {
		System.out.println("最终通知：模拟释放资源");
	}
}

（3）编写配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
   <!-- 指定需要扫描的包，使注解生效 -->
   <context:component-scan base-package="aspectj"/>
   <!-- 启动基于注解的AspectJ支持 -->
   <aop:aspectj-autoproxy/>
</beans>

（4）编写测试类Test

package aspectj.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import aspectj.dao.TestDao;
public class AspectjAOPTest {
	public static void main(String[] args) {
		@SuppressWarnings("resource")
		ApplicationContext appCon =
         new ClassPathXmlApplicationContext("aspectj/config/applicationContext.xml");
		//从容器中，获取增强后的目标对象
		TestDao testDaoAdvice = (TestDao)appCon.getBean("testDao");
		//执行方法
		testDaoAdvice.save();
		System.out.println("==============");
		testDaoAdvice.modify();
		System.out.println("==============");
		testDaoAdvice.delete();
	}
}

（5）运行结果以及分析。

运行结果如下图所示：

根据运行结果，我们可以得知，环绕通知（@Around）是最先开始，然后是前置通知（@Before），然后是执行原有方法，再是执行后置返回通知（@AfterReturning），而后执行最终通知（@After），最后执行环绕通知（@Around）。