Spring AOP面向切面编程AspectJ详解

AspectJ是基于Java语言的AOP框架。

<aop:aspect>>：子元素
<aop:pointcut>：配置全局切入点
<aop:before>:配置前置通知
<aop:after-retruning>:配置后置通知
<aop:around>:配置环绕通知
<aop:after-throwing>:配置异常通知
<aop:after>:配置最终通知
<aop:declare-parents>：配置引介通知

<aop:aspect>属性
id:用于定义该切面的唯一标识
ref：用于引用普通的Spring Bean

配置切入点<aop:pointcut>
id 用于指定切入点的唯一标识名称
expression:用于指定切入点关联的切入点表达式

execution(* com.itheima.jdk..(…))
第1个*：表示返回类型
com.itheima.jdk表示要拦截的包名
第2个表示类名
第3个表示方法名
（…） 表示方法的参数，其中（…） 表示任意参数

第1个*和包名之间没有空格

配置通知
pointcut: 该属性用于指定一个切入点表达式
pointcut-ref：该属性指定一个已经存在的切入点名称
method:该属性指定一个方法名，指定将切面Bean中的该方法转换为增强处理
throwing：该属性只对元素有效，它用于指定一个形参名
returning:该属性只对元素有效，后置通知方法可以通过该形参访问目标方法的返回值

相关jar包：Spring-apsects-4.3.6.RELEASE.jar、aspectjweaver-1.8.10.jar

实例：

/**
 *切面类，在此类中编写通知
 */
public class MyAspect {
	// 前置通知
	public void myBefore(JoinPoint joinPoint) {
		System.out.print("前置通知：模拟执行权限检查...,");
		System.out.print("目标类是："+joinPoint.getTarget() );
		System.out.println(",被植入增强处理的目标方法为："
                            +joinPoint.getSignature().getName());
	}
	// 后置通知
	public void myAfterReturning(JoinPoint joinPoint) {
		System.out.print("后置通知：模拟记录日志...," );
		System.out.println("被植入增强处理的目标方法为："
                          + joinPoint.getSignature().getName());
	}
	/**
	 * 环绕通知
	 * ProceedingJoinPoint 是JointPoint子接口，表示可以执行目标方法
	 * 1.必须是Object类型返回值
	 * 2.必须接受一个参数，类型ProceedingJoinPoint
	 * 3.必须throws Throwable
	 */
	public Object myAround(ProceedingJoinPoint proceedingJoinPoint) 
             throws Throwable {
		// 开始
		System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
		
		// 执行当前目标方法
		Object obj = proceedingJoinPoint.proceed();
		
		// 结束
		System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
		return obj;
	}
	
	// 异常通知
	public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
		System.out.println("异常通知 " + "出错了" + e.getMessage());
	}
	
	// 最终通知
	public void myAfter() {
		System.out.println("最终通知：模拟方法结束后的释放资源...");
	}
	}

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"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

	<!-- 1 目标类 -->
	<bean id="userDao" class="com.itheima.jdk.UserDaoImpl" />

	<!-- 2 切面 -->
	<bean id="myAspect" class="com.itheima.aspectj.xml.MyAspect" />
	<!-- 3 aop编程 -->

	<aop:config>

        <!-- 配置切面 -->
		<aop:aspect ref="myAspect">

		  <!-- 3.1 配置切入点，通知最后增强哪些方法 -->
		  <aop:pointcut expression="execution(* com.itheima.jdk.*.*(..))"
				                                      id="myPointCut" />

			<!-- 3.2 关联通知Advice和切入点pointCut -->
			<!-- 3.2.1 前置通知 -->
			<aop:before method="myBefore" pointcut-ref="myPointCut" />

			<!-- 3.2.2 后置通知,在方法返回之后执行，就可以获得返回值
			 returning属性：用于设置后置通知的第二个参数的名称,类型是Object -->
			<aop:after-returning method="myAfterReturning"
				pointcut-ref="myPointCut" returning="returnVal" />

			<!-- 3.2.3 环绕通知 -->
			<aop:around method="myAround" pointcut-ref="myPointCut" />

			<!-- 3.2.4 抛出通知：用于处理程序发生异常-->
			<!-- * 注意：如果程序没有异常，将不会执行增强 -->
			<!-- * throwing属性：用于设置通知第二个参数的名称，类型Throwable -->
			<aop:after-throwing method="myAfterThrowing"
				pointcut-ref="myPointCut" throwing="e" />

			<!-- 3.2.5 最终通知：无论程序发生任何事情，都将执行 -->
			<aop:after method="myAfter" pointcut-ref="myPointCut" />
		</aop:aspect>
	</aop:config>
</beans>

// 目标类
@Repository("userDao")
public class UserDaoImpl implements UserDao {
	public void addUser() {
//		int i = 10/0;
		System.out.println("添加用户");
	}
	public void deleteUser() {
		System.out.println("删除用户");
	}
}

//测试类
public class TestXmlAspectj {
	public static void main(String args[]) {
		String xmlPath = 
                         "com/itheima/aspectj/xml/applicationContext.xml";
		ApplicationContext applicationContext = 
                          new ClassPathXmlApplicationContext(xmlPath);
		// 1 从Spring容器获得内容
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		// 2 执行方法
		userDao.addUser();
	}
}

这种方法配置xml文件太过繁琐，理解就可以了，下面基于AspectJ的注解会很方便。
2.基于注解的声明式AspectJ

AspectJ的注解及其描述
@Aspect：定义一个切面
@Pointcut：用于定义切入点表达式。
@Before：用于定义前置通知
@AfterReturning：用于定义后置通知
@Around：用于定义环绕通知
@AfterThrowing：用于定义异常通知来处理未处理的异常
@After：用于定义最终final通知

同上，是实例：

/**
 * 切面类
 */

@Aspect
@Component
public class MyAspect {

	// 定义切入点表达式
	@Pointcut("execution(* com.itheima.jdk.*.*(..))")
	// 使用一个void返回值、方法体为空的方法来命名切入点
	private void myPointCut(){}
	
	// 前置通知
	@Before("myPointCut()")
	public void myBefore(JoinPoint joinPoint) {
		System.out.print("前置通知：模拟执行权限检查...,");
		System.out.print("目标类是："+joinPoint.getTarget() );
		System.out.println(",被植入增强处理的目标方法为："
		               +joinPoint.getSignature().getName());
	}
	
	
	// 后置通知
	@AfterReturning(value="myPointCut()")
	public void myAfterReturning(JoinPoint joinPoint) {
		System.out.print("后置通知：模拟记录日志...," );
		System.out.println("被植入增强处理的目标方法为："
		              + joinPoint.getSignature().getName());
	}
	// 环绕通知
	@Around("myPointCut()")
	public Object myAround(ProceedingJoinPoint proceedingJoinPoint) 
            throws Throwable {
		// 开始
		System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
		// 执行当前目标方法
		Object obj = proceedingJoinPoint.proceed();
		// 结束
		System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
		return obj;
	}
	
	// 异常通知
	@AfterThrowing(value="myPointCut()",throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
		System.out.println("异常通知" + "出错啦" + e.getMessage());
	}
	
	// 最终通知
	@After("myPointCut()")
	public void myAfter() {
		System.out.println("最终通知：模拟方法结束后的释放资源...");
	}
}

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-4.3.xsd
  http://www.springframework.org/schema/aop 
  http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
  http://www.springframework.org/schema/context 
  http://www.springframework.org/schema/context/spring-context-4.3.xsd">
      <!-- 指定需要扫描的包，使注解生效 -->
      <context:component-scan base-package="com.itheima" />
      <!-- 启动基于注解的声明式AspectJ支持 -->
      <aop:aspectj-autoproxy />
</beans>

// 测试类
public class TestAnnotationAspectj {
	public static void main(String args[]) {
		String xmlPath = 
                  "com/itheima/aspectj/annotation/applicationContext.xml";
		ApplicationContext applicationContext = 
                 new ClassPathXmlApplicationContext(xmlPath);
		// 1 从Spring容器获得内容
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		// 2 执行方法
		userDao.addUser();
	}
}