Spring面向切面编程AOP连接点和通用切点-----Spring框架

- 日理万妓 2024-03-24 18:23 113阅读 0赞
  1. package com.powernode.spring6.service;
  2. import org.aspectj.lang.JoinPoint;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.Signature;
  5. import org.aspectj.lang.annotation.*;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.springframework.core.annotation.Order;
  9. import org.springframework.stereotype.Component;
  10. @Component
  11. //切面类是需要使用@Aspect注解标注的,标注了就是一个切面
  12. @Aspect
  13. @Order(2)
  14. public class LogAspect //切面
  15. {
  16. private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);
  17. //切面等于通知加上切点
  18. //通知等于增强,就是说要编写的增强代码
  19. //这里的Advice以方法的形式出现(因为方法里面写代码)
  20. //Before注解只要标注,就是一个前置通知,内部写切点表达式
  21. @Pointcut("execution(* com.powernode.spring6.service..*(..))")
  22. //定义通用的切点表达式
  23. public void commonAspect()
  24. {
  25. //这个方法只是一个标记,方法名随意,方法体也不需要写东西
  26. }
  27. @Before("commonAspect()")
  28. public void Before(JoinPoint joinPoint)
  29. {
  30. //这个joinPoint会在Spring容器中调用这个方法的时候自动传过来
  31. //我们可以直接使用
  32. Signature signature = joinPoint.getSignature();
  33. //获取目标方法的签名,内部有方法的具体信息
  34. logger.info(signature.getName());
  35. logger.info("我是一段前置通知");
  36. }
  37. //后置通知
  38. @AfterReturning("commonAspect()")
  39. public void AfterReturning()
  40. {
  41. logger.info("我是一段后置通知");
  42. }
  43. //环绕通知
  44. @Around("commonAspect()")
  45. public void Around(ProceedingJoinPoint joinPoint) throws Throwable {
  46. //前面的代码
  47. logger.info("前环绕通知");
  48. //执行目标
  49. joinPoint.proceed();//用来执行目标
  50. //后面的代码
  51. logger.info("后环绕通知");
  52. }
  53. //最终通知
  54. //finally语句块中的通知
  55. @After("commonAspect()")
  56. public void After()
  57. {
  58. logger.info("最终通知");
  59. }
  60. //异常通知
  61. @AfterThrowing("commonAspect()")
  62. public void AfterThrowing()
  63. {
  64. logger.info("异常通知");
  65. }
  66. }
  67. package com.powernode.spring6.service;
  68. import org.aspectj.lang.JoinPoint;
  69. import org.aspectj.lang.ProceedingJoinPoint;
  70. import org.aspectj.lang.Signature;
  71. import org.aspectj.lang.annotation.*;
  72. import org.slf4j.Logger;
  73. import org.slf4j.LoggerFactory;
  74. import org.springframework.core.annotation.Order;
  75. import org.springframework.stereotype.Component;
  76. @Component
  77. //切面类是需要使用@Aspect注解标注的,标注了就是一个切面
  78. @Aspect
  79. @Order(2)
  80. public class LogAspect //切面
  81. {
  82. private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);
  83. //切面等于通知加上切点
  84. //通知等于增强,就是说要编写的增强代码
  85. //这里的Advice以方法的形式出现(因为方法里面写代码)
  86. //Before注解只要标注,就是一个前置通知,内部写切点表达式
  87. @Pointcut("execution(* com.powernode.spring6.service..*(..))")
  88. //定义通用的切点表达式
  89. public void commonAspect()
  90. {
  91. //这个方法只是一个标记,方法名随意,方法体也不需要写东西
  92. }
  93. @Before("commonAspect()")
  94. public void Before(JoinPoint joinPoint)
  95. {
  96. //这个joinPoint会在Spring容器中调用这个方法的时候自动传过来
  97. //我们可以直接使用
  98. Signature signature = joinPoint.getSignature();
  99. //获取目标方法的签名,内部有方法的具体信息
  100. logger.info(signature.getName());
  101. logger.info("我是一段前置通知");
  102. }
  103. //后置通知
  104. @AfterReturning("commonAspect()")
  105. public void AfterReturning()
  106. {
  107. logger.info("我是一段后置通知");
  108. }
  109. //环绕通知
  110. @Around("commonAspect()")
  111. public void Around(ProceedingJoinPoint joinPoint) throws Throwable {
  112. //前面的代码
  113. logger.info("前环绕通知");
  114. //执行目标
  115. joinPoint.proceed();//用来执行目标
  116. //后面的代码
  117. logger.info("后环绕通知");
  118. }
  119. //最终通知
  120. //finally语句块中的通知
  121. @After("commonAspect()")
  122. public void After()
  123. {
  124. logger.info("最终通知");
  125. }
  126. //异常通知
  127. @AfterThrowing("commonAspect()")
  128. public void AfterThrowing()
  129. {
  130. logger.info("异常通知");
  131. }
  132. }
  133. package com.powernode.spring6.service;
  134. import org.aspectj.lang.annotation.Aspect;
  135. import org.aspectj.lang.annotation.Before;
  136. import org.slf4j.Logger;
  137. import org.slf4j.LoggerFactory;
  138. import org.springframework.core.annotation.Order;
  139. import org.springframework.stereotype.Component;
  140. @Component
  141. @Aspect
  142. @Order(0)//数字越小优先级越高
  143. public class SecurityAspect//安全模块切面
  144. {
  145. private static final Logger logger = LoggerFactory.getLogger(SecurityAspect.class);
  146. @Before("com.powernode.spring6.service.LogAspect.commonAspect()")
  147. public void before()
  148. {
  149. logger.info("安全模块前置通知");
  150. }
  151. }
  152. package com.powernode.spring6.service;
  153. import org.aspectj.lang.annotation.Aspect;
  154. import org.aspectj.lang.annotation.Before;
  155. import org.slf4j.Logger;
  156. import org.slf4j.LoggerFactory;
  157. import org.springframework.core.annotation.Order;
  158. import org.springframework.stereotype.Component;
  159. @Component
  160. @Aspect
  161. @Order(0)//数字越小优先级越高
  162. public class SecurityAspect//安全模块切面
  163. {
  164. private static final Logger logger = LoggerFactory.getLogger(SecurityAspect.class);
  165. @Before("com.powernode.spring6.service.LogAspect.commonAspect()")
  166. public void before()
  167. {
  168. logger.info("安全模块前置通知");
  169. }
  170. }
  171. package com.powernode.spring6.test;
  172. import com.powernode.spring6.service.OrderService;
  173. import org.junit.Test;
  174. import org.springframework.context.ApplicationContext;
  175. import org.springframework.context.support.ClassPathXmlApplicationContext;
  176. public class SpringAOPTest
  177. {
  178. @Test
  179. public void TestBefore()
  180. {
  181. ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
  182. OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
  183. orderService.generate();
  184. }
  185. }
  186. package com.powernode.spring6.test;
  187. import com.powernode.spring6.service.OrderService;
  188. import org.junit.Test;
  189. import org.springframework.context.ApplicationContext;
  190. import org.springframework.context.support.ClassPathXmlApplicationContext;
  191. public class SpringAOPTest
  192. {
  193. @Test
  194. public void TestBefore()
  195. {
  196. ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
  197. OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
  198. orderService.generate();
  199. }
  200. }

发表评论

表情:
评论列表 (有 0 条评论,113人围观)

还没有评论,来说两句吧...

相关阅读