Spring AOP开发案例

在确保可运行项目能够正确无误地运行之后，再严格照着教程的步骤，对代码模仿一遍。模仿过程难免代码有出入，导致无法得到期望的运行结果，此时此刻通过比较正确答案 ( 可运行项目 ) 和自己的代码，来定位问题所在。采用这种方式，学习有效果，排错有效率，可以较为明显地提升学习速度，跨过学习路上的各个槛。

链接：https://pan.baidu.com/s/1IY-IRpBZFn57L3RdPb8lVw?pwd=b84c
提取码：b84c

 基于XML的声明式 AspectJ

1.创建一个名为chapter03的动态Web项目，在src目录下创建一个一个aspectj包，在包中创建接口UserDao。

package aspectj;

public interface UserDao {
public void addUser() ;
public void deleteUser() ;	

}

2.在aspectj包下创建一个类UserDaoImpl实现UserDao接口。

public class UserDaoImpl implements UserDao{

	@Override
	public void addUser() {
		// TODO Auto-generated method stub

		System.out.println("添加用户");
	}

	@Override
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("删除用户");
	}

}

3.在aspectj包下创建MyAspect切面，用来定义不同类型通知

package aspectj;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
/**
 * 切面类，在此类中编写通知
 */
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是JoinPoint的子接口，表示可执行目标方法
	 * 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("最终通知：模拟方法结束后释放资源..");
	}
}

4.在src目录下创建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"
	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">
	<!-- 1 目标类 -->
	<bean id="userDao" class="aspectj.UserDaoImpl" />
	<!-- 2 切面 -->
	<bean id="myAspect" class="aspectj.MyAspect" />
	<!-- 3 aop编程 -->
	<aop:config>
		<!-- 1.配置切面 -->
		<aop:aspect id="aspect" ref="myAspect">
			<!-- 2.配置切入点 -->
			<aop:pointcut expression="execution(* aspectj.*.*(..))"	id="myPointCut" />
			<!-- 3.配置通知 -->
				<!-- 前置通知 -->
				<aop:before method="myBefore" pointcut-ref="myPointCut" />
				<!--后置通知--> 
				<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="joinPoint"/>
				<!--环绕通知 -->
				<aop:around method="myAround" pointcut-ref="myPointCut" />
				<!--异常通知 -->
				<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e" />
				<!--最终通知 -->
				<aop:after method="myAfter" pointcut-ref="myPointCut" />
		</aop:aspect>
	</aop:config>
</beans>

5.在aspectj包下创建TestXmlAspectJ类，用来测试

package aspectj;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import aspectj.UserDao;
public class TestXmlAspectJ {
	public static void main(String[] args) {
		String xmlPath="applicationContext.xml";
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
		//从容器中获得内容
		UserDao userDao=(UserDao)applicationContext.getBean("userDao");
		//执行方法
		userDao.addUser();
		userDao.deleteUser();
	}
}

运行结果：

 如果将UserDaoImpl类设置一个错误：

package aspectj;

public class UserDaoImpl implements UserDao{

	@Override
	public void addUser() {
		// TODO Auto-generated method stub
		int i=10/0;
		System.out.println("添加用户");
	}

	@Override
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("删除用户");
	}

}

运行效果：

 基于注解的声明式AspectJ

1.在src目录下创建annotation包，创建切面myAspect

package 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
@Component
public class MyAspect {
	//定义切入点表达式
	@Pointcut("execution(* annotation.*.*(..))")
	//使用一个返回值为void、方法体为空的方法来命名切入点
	public 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());
	}
	/**
	 * 环绕通知
	 * ProceedingJoinPoint是JoinPoint的子接口，表示可执行目标方法
	 * 1.必须是Object类型的返回值
	 * 2.必须接收一个参数，类型为ProceedingJoinPoint
	 * 3.必须throws Throwable
	 */
	@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("最终通知：模拟方法结束后释放资源..");
	}
}

2.将UserDao和UserDaoImpl复制到annotation包下，并对UserDaoImpl做一下调整

package annotation;

import org.springframework.stereotype.Repository;
@Repository("userDao")
public class UserDaoImpl implements UserDao{

	@Override
	public void addUser() {
		// TODO Auto-generated method stub
		System.out.println("添加用户");
	}

	@Override
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("删除用户");
	}

}

3.在src目录下创建applicationContext2.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="annotation" />
	<!-- 启动基于注解的声明式AspectJ支持 -->
	<aop:aspectj-autoproxy />
</beans>

4.在annotation包下创建TestAnnotation类进行测试

package annotation;
import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestAnotation {
	public static void main(String[] args) {
		String xmlPath="applicationContext2.xml";
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
		//从容器中获得内容
		UserDao userDao=(UserDao)applicationContext.getBean("userDao");
		//执行方法
		userDao.addUser();
		userDao.deleteUser();
	}
}

运行结果：