Spring框架学习

文章40 |   阅读 21319 |   点赞0

来源：https://blog.csdn.net/yerenyuan_pku/category_6457009.html

Spring入门第七讲——Spring AOP的注解开发

转x33g5p2x  于2021-12-18 转载在 其他  
字(12.9k)|赞(0)|评价(0)|浏览(557)

在前一讲中，我已讲过Spring使用基于AspectJ的XML配置文件的方式进行AOP开发，现在我就来讲讲怎样使用基于AspectJ的注解的方式进行AOP开发。

使用基于AspectJ的注解的方式进行AOP开发

创建web项目，引入jar包

首先创建一个动态web项目，例如spring_demo03_aop，然后导入Spring框架相关依赖jar包，要导入哪些jar包呢？这里不废话，直接给出要导入的jar包。

引入相关的配置文件

首先，引入Spring的配置文件，在该文件中应引入aop约束，这样一开始applicationContext.xml文件的内容就应该是下面的样子。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <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">
  4. </beans>

然后，还要记得在src目录下引入Log4j的配置文件（log4j.properties），也就是日志记录文件，该文件内容如下：

  1. ### direct log messages to stdout ###
  2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  3. log4j.appender.stdout.Target=System.err
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
  7. ### direct messages to file mylog.log ###
  8. log4j.appender.file=org.apache.log4j.FileAppender
  9. log4j.appender.file.File=c\:mylog.log
  10. log4j.appender.file.layout=org.apache.log4j.PatternLayout
  11. log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
  13. ### set log levels - for more verbose logging change 'info' to 'debug' ###
  14. # error warn info debug trace
  15. log4j.rootLogger= info, stdout

编写目标类并配置

首先，在src目录下创建一个com.meimeixia.spring.demo03包，并在该包下创建一个名为OrderDao的类。

  1. package com.meimeixia.spring.demo01;
  3. public class OrderDao {
  4. 	
  5. 	public void save() {
  6. 		System.out.println("保存订单...");
  7. 	}
  8. 	
  9. 	public void update() {
  10. 		System.out.println("修改订单...");
  11. 	}
  12. 	
  13. 	public void delete() {
  14. 		System.out.println("删除订单...");
  15. 	}
  16. 	
  17. 	public void find() {
  18. 		System.out.println("查询订单...");
  19. 	}
  20. 	
  21. }

然后，在Spring配置文件中对以上目标类进行配置。

编写切面类并配置

现在有这样一个需求：我们想在OrderDao类的save方法执行之前，就简简单单地执行一个操作，那该咋怎呢？这时我们可以编写一个切面类，并在切面类中随便编写一个方法，例如下面的before方法。待会，我们就使用注解对该切面类进行增强，让切面类中的before方法在目标类的save方法执行之前执行。

  1. package com.meimeixia.spring.demo01;
  3. public class MyAspectAnno {
  5. 	public void before() {
  6. 		System.out.println("前置增强--------------------");
  7. 	}
  8. 	
  9. }

接着，在Spring配置文件中对以上切面类进行配置。

使用注解对目标类进行增强

首先，我们需要在Spring的配置文件中开启注解的AOP开发。

然后，我们就可以在切面类上使用注解了。

  1. package com.meimeixia.spring.demo01;
  3. import org.aspectj.lang.annotation.Aspect;
  4. import org.aspectj.lang.annotation.Before;
  6. /** * 切面类（注解的切面类） * @author liayun * */
  7. @Aspect //Spring会把这个类识别成一个切面
  8. public class MyAspectAnno {
  10. 	//@Before注解代表前置增强，还要告诉Spring在哪个类上的哪个方法上应用前置增强
  11. 	@Before(value="execution(* com.meimeixia.spring.demo01.OrderDao.save(..))")
  12. 	public void before() {
  13. 		System.out.println("前置增强--------------------");
  14. 	}
  15. 	
  16. }

温馨提示：@Aspect注解用于定义切面类，@Before注解代表的是前置通知。

编写测试类并进行测试

首先，在com.meimeixia.spring.demo01包下创建一个SpringDemo01的单元测试类，其内容如下，可以看出我们是通过Spring来整合JUnit进行单元测试的。

  1. package com.meimeixia.spring.demo01;
  3. import javax.annotation.Resource;
  5. import org.junit.Test;
  6. import org.junit.runner.RunWith;
  7. import org.springframework.test.context.ContextConfiguration;
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  10. /** * Spring的AOP的注解开发 * @author liayun * */
  11. @RunWith(SpringJUnit4ClassRunner.class)
  12. @ContextConfiguration("classpath:applicationContext.xml")
  13. public class SpringDemo01 {
  14. 	
  15. 	@Resource(name="orderDao")
  16. 	private OrderDao orderDao;
  18. 	@Test
  19. 	public void demo01() {
  20. 		orderDao.save();//作断点调试，可以看到使用到的是Cglib的动态代理：CglibAopProxy
  21. 		orderDao.update();
  22. 		orderDao.delete();
  23. 		orderDao.find();
  24. 	}
  25. 	
  26. }

然后，运行以上demo01单元测试方法，Eclipse控制台就会打印出如下内容。

Spring AOP注解开发中的通知类型

Spring AOP注解开发入门之后，咱就来看一下AOP注解开发中的通知类型。

前置通知

前置通知是指在目标方法执行之前进行操作。上面我演示的就是前置通知，这里不再赘述。

后置通知

后置通知是指在目标方法执行之后进行操作。它除了可以获得切入点的信息以外，还可以获得方法的返回值。为了验证这一点，首先，将OrderDao类修改成下面这个样子（主要是修改了一下delete方法，让其返回一个字符串）。

  1. package com.meimeixia.spring.demo01;
  3. public class OrderDao {
  4. 	
  5. 	public void save() {
  6. 		System.out.println("保存订单...");
  7. 	}
  8. 	
  9. 	public void update() {
  10. 		System.out.println("修改订单...");
  11. 	}
  12. 	
  13. 	public String delete() {
  14. 		System.out.println("删除订单...");
  15. 		return "删除订单成功";
  16. 	}
  17. 	
  18. 	public void find() {
  19. 		System.out.println("查询订单...");
  20. 	}
  21. 	
  22. }

然后，在MyAspectAnno切面类中添加一个afterReturning方法，并在该方法上使用@AfterReturning注解，告诉Spring要在OrderDao类中的delete方法上应用后置通知。

  1. package com.meimeixia.spring.demo01;
  3. import org.aspectj.lang.annotation.AfterReturning;
  4. import org.aspectj.lang.annotation.Aspect;
  5. import org.aspectj.lang.annotation.Before;
  7. /** * 切面类（注解的切面类） * @author liayun * */
  8. @Aspect //Spring会把这个类识别成一个切面
  9. public class MyAspectAnno {
  11. 	//@Before注解代表前置增强，还要告诉Spring在哪个类上的哪个方法上应用前置增强
  12. 	@Before(value="execution(* com.meimeixia.spring.demo01.OrderDao.save(..))")
  13. // @Before(value="MyAspectAnno.pointcut2()")
  14. 	public void before() {
  15. 		System.out.println("前置增强--------------------");
  16. 	}
  17. 	
  18. 	//后置通知
  19. 	@AfterReturning(value="execution(* com.meimeixia.spring.demo01.OrderDao.delete(..))", returning="result")
  20. 	public void afterReturning(Object result) {//这儿的result一定得跟returning="result"中的result对应上
  21. 		System.out.println("后置增强--------------------" + result);
  22. 	}
  23. 	
  24. }

最后，运行SpringDemo01单元测试类中的demo01方法，你就会看到Eclipse控制台打印出了如下内容。

环绕通知

环绕通知是功能最强的一个通知，它是指在目标方法执行之前和之后进行操作。很重要的一点就是它可以阻止目标方法的执行。为了验证这一点，我们可以在MyAspectAnno切面类中添加一个如下的around方法，并在该方法上使用@Around注解，告诉Spring要在OrderDao类中的update方法上应用环绕通知。

  1. package com.meimeixia.spring.demo01;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.AfterReturning;
  5. import org.aspectj.lang.annotation.Around;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.aspectj.lang.annotation.Before;
  9. /** * 切面类（注解的切面类） * @author liayun * */
  10. @Aspect //Spring会把这个类识别成一个切面
  11. public class MyAspectAnno {
  13. 	//@Before注解代表前置增强，还要告诉Spring在哪个类上的哪个方法上应用前置增强
  14. 	@Before(value="execution(* com.meimeixia.spring.demo01.OrderDao.save(..))")
  15. 	public void before() {
  16. 		System.out.println("前置增强--------------------");
  17. 	}
  18. 	
  19. 	//后置通知
  20. 	@AfterReturning(value="execution(* com.meimeixia.spring.demo01.OrderDao.delete(..))", returning="result")
  21. 	public void afterReturning(Object result) {//这儿的result一定得跟returning="result"中的result对应上
  22. 		System.out.println("后置增强--------------------" + result);
  23. 	}
  24. 	
  25. 	//环绕通知
  26. 	@Around(value="execution(* com.meimeixia.spring.demo01.OrderDao.update(..))")
  27. 	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
  28. 		System.out.println("环绕前增强--------------------");
  29. 		Object obj = joinPoint.proceed();//执行我们的目标方法，它会返回一个Object
  30. 		System.out.println("环绕后增强--------------------");
  31. 		return obj;
  32. 	}
  33. 	
  34. }

接着，运行SpringDemo01单元测试类中的demo01方法，你就会看到Eclipse控制台打印出了如下内容。

异常抛出通知

异常抛出通知是指在程序出现异常的时候而进行的操作，而且它还可以获得异常的信息。异常抛出通知能想到的一个应用场景就是在事务管理的时候会用到。为了验证这一点，首先，修改一下OrderDao类中的find方法，使其抛出一个除零异常。

  1. package com.meimeixia.spring.demo01;
  3. public class OrderDao {
  4. 	
  5. 	public void save() {
  6. 		System.out.println("保存订单...");
  7. 	}
  8. 	
  9. 	public void update() {
  10. 		System.out.println("修改订单...");
  11. 	}
  12. 	
  13. 	public String delete() {
  14. 		System.out.println("删除订单...");
  15. 		return "删除订单成功";
  16. 	}
  17. 	
  18. 	public void find() {
  19. 		System.out.println("查询订单...");
  20. 		int i = 1 / 0;
  21. 	}
  22. 	
  23. }

然后，在MyAspectAnno切面类中添加如下一个afterThrowing方法，并在该方法上使用@AfterThrowing注解，告诉Spring要在OrderDao类中的find方法上应用异常抛出通知。

  1. package com.meimeixia.spring.demo01;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.AfterReturning;
  5. import org.aspectj.lang.annotation.AfterThrowing;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.aspectj.lang.annotation.Before;
  10. /** * 切面类（注解的切面类） * @author liayun * */
  11. @Aspect //Spring会把这个类识别成一个切面
  12. public class MyAspectAnno {
  14. 	//@Before注解代表前置增强，还要告诉Spring在哪个类上的哪个方法上应用前置增强
  15. 	@Before(value="execution(* com.meimeixia.spring.demo01.OrderDao.save(..))")
  16. 	public void before() {
  17. 		System.out.println("前置增强--------------------");
  18. 	}
  19. 	
  20. 	//后置通知
  21. 	@AfterReturning(value="execution(* com.meimeixia.spring.demo01.OrderDao.delete(..))", returning="result")
  22. 	public void afterReturning(Object result) {//这儿的result一定得跟returning="result"中的result对应上
  23. 		System.out.println("后置增强--------------------" + result);
  24. 	}
  25. 	
  26. 	//环绕通知
  27. 	@Around(value="execution(* com.meimeixia.spring.demo01.OrderDao.update(..))")
  28. 	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
  29. 		System.out.println("环绕前增强--------------------");
  30. 		Object obj = joinPoint.proceed();//执行我们的目标方法，它会返回一个Object
  31. 		System.out.println("环绕后增强--------------------");
  32. 		return obj;
  33. 	}
  34. 	
  35. 	//异常抛出通知
  36. 	@AfterThrowing(value="execution(* com.meimeixia.spring.demo01.OrderDao.find(..))", throwing="e")
  37. 	public void afterThrowing(Throwable e) {//这儿的e一定得跟throwing="e"中的e对应上
  38. 		System.out.println("异常抛出增强--------------------" + e.getMessage());
  39. 	}
  40. 	
  41. }

最后，运行SpringDemo01单元测试类中的demo01方法，你就会看到Eclipse控制台打印出了如下内容。

最终通知

无论目标方法是否出现异常，最终通知都会执行。此时，我们已经知道了OrderDao类中的find方法（也即目标方法）抛出了一个除零异常。现在，咱就是要看看find方法（也即目标方法）出现了异常，最终通知会不会执行。为了验证这一点，我们在MyAspectAnno切面类中添加如下的一个after方法，并在该方法上使用@After注解，告诉Spring要在OrderDao类中的find方法上应用最终通知。

  1. package com.meimeixia.spring.demo01;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.AfterReturning;
  6. import org.aspectj.lang.annotation.AfterThrowing;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.annotation.Before;
  11. /** * 切面类（注解的切面类） * @author liayun * */
  12. @Aspect //Spring会把这个类识别成一个切面
  13. public class MyAspectAnno {
  15. 	//@Before注解代表前置增强，还要告诉Spring在哪个类上的哪个方法上应用前置增强
  16. 	@Before(value="execution(* com.meimeixia.spring.demo01.OrderDao.save(..))")
  17. 	public void before() {
  18. 		System.out.println("前置增强--------------------");
  19. 	}
  20. 	
  21. 	//后置通知
  22. 	@AfterReturning(value="execution(* com.meimeixia.spring.demo01.OrderDao.delete(..))", returning="result")
  23. 	public void afterReturning(Object result) {//这儿的result一定得跟returning="result"中的result对应上
  24. 		System.out.println("后置增强--------------------" + result);
  25. 	}
  26. 	
  27. 	//环绕通知
  28. 	@Around(value="execution(* com.meimeixia.spring.demo01.OrderDao.update(..))")
  29. 	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
  30. 		System.out.println("环绕前增强--------------------");
  31. 		Object obj = joinPoint.proceed();//执行我们的目标方法，它会返回一个Object
  32. 		System.out.println("环绕后增强--------------------");
  33. 		return obj;
  34. 	}
  35. 	
  36. 	//异常抛出通知
  37. 	@AfterThrowing(value="execution(* com.meimeixia.spring.demo01.OrderDao.find(..))", throwing="e")
  38. 	public void afterThrowing(Throwable e) {//这儿的e一定得跟throwing="e"中的e对应上
  39. 		System.out.println("异常抛出增强--------------------" + e.getMessage());
  40. 	}
  41. 	
  42. 	//最终通知
  43. 	@After(value="execution(* com.meimeixia.spring.demo01.OrderDao.find(..))")
  44. 	public void after() {
  45. 		System.out.println("最终增强--------------------");
  46. 	}
  47. 	
  48. }

接着，运行SpringDemo01单元测试类中的demo01方法，你就会看到Eclipse控制台打印出了如下内容。

从上面输出的结果中，我们就证明了即使目标方法出现了异常，最终通知也会执行。

Spring AOP注解开发中的切入点的配置

假设切面类里面有很多种通知，但它们都需要作用于目标类的同一个方法上，比如说find方法，假如说我有一天不想作用在find方法上了，而想作用在save方法或者update方法上，那该咋办呢？这时，我们得到切面类里面一个一个改，如果切面类这里面的通知很多，那么我们是不是得改好几个啊！这势必会很麻烦！为了解决这种问题，咱可以使用@Pointcut注解来定义切入点。例如，咱可以在MyAspectAnno切面类里面定义如下一些切入点。

那么，我们怎么把之前写好的各种类型的通知应用在这些切入点上呢？也就是说MyAspectAnno切面类定义了以上一系列切入点之后，可以修改成下面这个样子。

  1. package com.meimeixia.spring.demo01;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.AfterReturning;
  6. import org.aspectj.lang.annotation.AfterThrowing;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.annotation.Before;
  10. import org.aspectj.lang.annotation.Pointcut;
  12. /** * 切面类（注解的切面类） * @author liayun * */
  13. @Aspect //Spring会把这个类识别成一个切面
  14. public class MyAspectAnno {
  16. 	//@Before注解代表前置增强，还要告诉Spring在哪个类上的哪个方法上应用前置增强
  17. 	@Before(value="MyAspectAnno.pointcut2()")
  18. 	public void before() {
  19. 		System.out.println("前置增强--------------------");
  20. 	}
  21. 	
  22. 	//后置通知
  23. 	@AfterReturning(value="MyAspectAnno.pointcut4()", returning="result")
  24. 	public void afterReturning(Object result) {//这儿的result一定得跟returning="result"中的result对应上
  25. 		System.out.println("后置增强--------------------" + result);
  26. 	}
  27. 	
  28. 	//环绕通知
  29. 	@Around(value="MyAspectAnno.pointcut3()")
  30. 	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
  31. 		System.out.println("环绕前增强--------------------");
  32. 		Object obj = joinPoint.proceed();//执行我们的目标方法，它会返回一个Object
  33. 		System.out.println("环绕后增强--------------------");
  34. 		return obj;
  35. 	}
  36. 	
  37. 	//异常抛出通知
  38. 	@AfterThrowing(value="MyAspectAnno.pointcut1()", throwing="e")
  39. 	public void afterThrowing(Throwable e) {//这儿的e一定得跟throwing="e"中的e对应上
  40. 		System.out.println("异常抛出增强--------------------" + e.getMessage());
  41. 	}
  42. 	
  43. 	//最终通知
  44. 	@After(value="MyAspectAnno.pointcut1()")
  45. 	public void after() {
  46. 		System.out.println("最终增强--------------------");
  47. 	}
  48. 	
  49. 	/* * 这里面有一个问题：假设我这里面有很多种通知，但都需要作用于同一个方法上，比如说find()方法，假如说我有一天不想作用在find()方法上了， * 我想作用在save()方法或者update()方法上，咋办呢？你是不是得到这边一个一个改啊！那如果我这里面的通知很多，但都 * 作用于同一个方法上，你是不是得改好几个啊？很麻烦！ * */
  50. 	//切入点的注解
  51. 	@Pointcut(value="execution(* com.meimeixia.spring.demo01.OrderDao.find(..))")
  52. 	private void pointcut1() {}//该方法没有特殊的意义，私有就行
  53. 	@Pointcut(value="execution(* com.meimeixia.spring.demo01.OrderDao.save(..))")
  54. 	private void pointcut2() {}
  55. 	@Pointcut(value="execution(* com.meimeixia.spring.demo01.OrderDao.update(..))")
  56. 	private void pointcut3() {}
  57. 	@Pointcut(value="execution(* com.meimeixia.spring.demo01.OrderDao.delete(..))")
  58. 	private void pointcut4() {}
  59. 	
  60. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://liayun.blog.csdn.net/article/details/100527764

内容来源于网络，如有侵权，请联系作者删除！

spring框架学习

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com