03Spring实现AOP前置后置等

张创琦

代码详见 spring03_aop

以下代码共用一个测试类和service类

Test01.java

  1. package com.kkb.test;
  3. import com.kkb.service.NBAService;
  4. import com.kkb.service.TeamService;
  5. import org.junit.Test;
  6. import org.springframework.context.ApplicationContext;
  7. import org.springframework.context.support.ClassPathXmlApplicationContext;
  9. public class Test01 {
  11.     @Test
  12.     public void test01(){
  13.         ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
  14.         TeamService teamService = (TeamService)ac.getBean("teamService");
  15.         teamService.add(1001, "湖人队");
  16.         System.out.println("----------");
  17.         boolean update = teamService.update(888);
  18.         System.out.println("update结果：   " + update);
  19.         System.out.println("---------------------");
  20.         NBAService nbaService = (NBAService)ac.getBean("nbaService");
  21.         nbaService.add(1002, "热火队");
  22.         System.out.println("----------");
  23.         boolean update2 = teamService.update(888);
  24.         System.out.println("update2结果：   " + update2);
  25.     }
  27. }

IService.java

  1. package com.kkb.service;
  3. public interface IService {
  4.     void add(int id, String name);
  5.     boolean update(int num);
  6. }

NBAService.java

标头引入相关依赖。

  1. package com.kkb.service;
  3. import org.springframework.stereotype.Service;
  5. @Service("nbaService")
  6. public class NBAService implements IService {
  8.     @Override
  9.     public void add(int id, String name) {
  10.         System.out.println("NBAService------add------");
  11.     }
  13.     @Override
  14.     public boolean update(int num) {
  15.         System.out.println("NBAService------update------");
  16.         if(num > 666){
  17.             return true;
  18.         }
  19.         return false;
  20.     }
  22. }

TeamService.java

  1. package com.kkb.service;
  3. import org.springframework.stereotype.Service;
  5. @Service
  6. public class TeamService implements IService {
  8.     @Override
  9.     public void add(int id, String name) {
  10.         //int num = 10 / 0;
  11.         System.out.println("TeamService------add------");
  12.     }
  14.     @Override
  15.     public boolean update(int num) {
  16.         System.out.println("TeamService------update------");
  17.         if(num > 666){
  18.             return true;
  19.         }
  20.         return false;
  21.     }
  23. }

方法1: 通过注解方式实现

MyAspect.java

  1. package com.kkb.aop;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.annotation.*;
  6. import org.springframework.stereotype.Component;
  8. //切面类
  9. @Component //切面对象的创建权限依然交给Spring容器
  10. @Aspect //aspectj框架的注解，标识当前类是一个切面类
  11. public class MyAspect {
  13.     //统一提取切入点表达式
  14.     //其它的通知可以直接在value直接使用方法名称
  15.     @Pointcut("execution(* com.kkb.service..*.*(..))")  //注解表示切入点表达式，方法一般声明为私有
  16.     private void pointCut(){
  18.     }
  20.     //可以声明多个
  21.     @Pointcut("execution(* com.kkb.service..*.update*(..))")  //注解表示切入点表达式，方法一般声明为私有
  22.     private void pointCut2(){
  24.     }
  26.     @Before("execution(* com.kkb.service..*.*(..))")
  27.     //也可以写成@Before(pointCut())
  28.     public void before(JoinPoint jp){
  29.         System.out.println("前置通知：在目标方法调用之前被调用的通知。");
  30.         String name = jp.getSignature().getName();
  31.         System.out.println("拦截的方法名称："+name);
  32.         Object[] args = jp.getArgs();
  33.         System.out.println("方法的参数格式："+args.length);
  34.         System.out.println("方法的参数列表：");
  35.         for (Object arg: args) {
  36.             System.out.println("\t"+arg);
  37.         }
  39.     }
  41.     //Return表示返回的结果，如果需要的话可以在后置方法通知中修改结果，value依然表示切入点表达式
  42.     @AfterReturning(value="execution(* com.kkb.service..*.update*(..))", returning = "result")
  43.     public Object after(Object result){
  44.         if(result != null){
  45.             boolean res = (boolean) result;
  46.             if(res){
  47.                 result = false;
  48.             }
  49.         }
  50.         System.out.println("后置通知：在目标方法调用之后被调用的通知。result="+result);
  51.         return result;
  52.     }
  54.     //注解声明环绕通知方法
  55.     //ProceedingJoinPoint中的proceed方法表示目标方法被执行
  56.     @Around("execution(* com.kkb.service..*.*(..))")
  57.     public Object around(ProceedingJoinPoint pjp) throws Throwable {
  58.         System.out.println("环绕方法------目标方法执行之前");
  59.         Object proceed = pjp.proceed();
  60.         System.out.println("环绕方法------目标方法执行之后");
  61.         return proceed;
  62.     }
  64.     //注解声明异常通知方法
  65.     @AfterThrowing(value="execution(* com.kkb.service..*.*(..))", throwing = "ex")
  66.     public void exception(JoinPoint jp, Throwable ex){
  67.         //一般会把异常发生的时间 位置 缘由记录下来
  68.         System.out.println("异常通知：在目标方法执行出现异常被调用的通知。否则不执行");
  69.         System.out.println(jp.getSignature() + "方法出现异常，异常信息是：" +ex.getMessage());
  72.     }
  74.     //注解声明最终通知方法
  75.     @After("execution(* com.kkb.service..*.*(..))")
  76.     public void myFinally(){
  77.         System.out.println("最终通知：无论是否出现异常都会调用的通知。");
  78.     }
  80. }

spring.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xmlns:context="http://www.springframework.org/schema/context"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
  8.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  9. ">
  11.     <!-- 在beans标签中引入AOP和context约束 -->
  12.     <context:component-scan base-package="com.kkb.service, com.kkb.aop"/>
  14.     <!-- aspectj的相关配置, true开启代理模式 -->
  15.     <aop:aspectj-autoproxy proxy-target-class="true"/>
  17. </beans>

方法2: 通过xml配置实现

MyAOP.java

  1. package com.kkb.aop;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.annotation.*;
  6. import org.springframework.stereotype.Component;
  8. /**
  9.  * 切面类
  10.  */
  11. //通过xml调取
  12. @Component //切面对象的创建权限依然交给Spring容器
  13. @Aspect //aspectj框架的注解，标识当前类是一个切面类
  14. public class MyAOP {
  16.     public void before(JoinPoint jp){
  17.         System.out.println("AOP前置通知：在目标方法调用之前被调用的通知。");
  18.     }
  20.     public void after(Object result){
  21.         System.out.println("AOP后置通知：在目标方法调用之后被调用的通知。result="+result);
  23.     }
  25.     public Object around(ProceedingJoinPoint pjp) throws Throwable {
  26.         System.out.println("AOP环绕方法------目标方法执行之前");
  27.         Object proceed = pjp.proceed();
  28.         System.out.println("AOP环绕方法------目标方法执行之后");
  29.         return proceed;
  30.     }
  32.     public void exception(JoinPoint jp, Throwable ex){
  33.         //一般会把异常发生的时间 位置 缘由记录下来
  34.         System.out.println("AOP异常通知：在目标方法执行出现异常被调用的通知。否则不执行");
  35.         System.out.println(jp.getSignature() + "方法出现异常，异常信息是：" +ex.getMessage());
  36.     }
  38.     public void myFinally() {
  39.         System.out.println("AOP最终通知：无论是否出现异常都会调用的通知。");
  40.     }
  42. }

spring.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xmlns:context="http://www.springframework.org/schema/context"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
  8.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  9. ">
  11.     <!-- 在beans标签中引入AOP和context约束 -->
  12.     <context:component-scan base-package="com.kkb.service, com.kkb.aop"/>
  14.     <!-- aspectj的相关配置, true开启代理模式 -->
  15.     <aop:aspectj-autoproxy proxy-target-class="true"/>
  17.     <!-- xml方式实现AOP -->
  18.     <aop:config>
  19.         <aop:pointcut id="pt1" expression="execution(* com.kkb.service..*.*(..))"/>
  20.         <aop:pointcut id="pt2" expression="execution(* com.kkb.service..*.add*(..))"/>
  21.         <aop:aspect ref="myAOP" >
  22.             <!-- 声明切入点的表达式 -->
  23.             <aop:before method="before" pointcut-ref="pt1"></aop:before>
  24.             <!-- 也可以写成 <aop:before method="before" pointcut="execution(* com.kkb.service..*.*(..))"></aop:before>-->
  25.             <aop:after-returning method="after" pointcut-ref="pt2" returning="result"></aop:after-returning>
  26.             <aop:after-throwing method="exception" pointcut-ref="pt1" throwing="ex"></aop:after-throwing>
  27.             <aop:after method="myFinally" pointcut-ref="pt1"></aop:after>
  28.             <aop:around method="around" pointcut-ref="pt2"></aop:around>
  29.         </aop:aspect>
  30.     </aop:config>
  32. </beans>