AOP基于xml配置方式实现

Spring基于xml开发AOP

　　　　定义目标类（接口及实现类）

 /**

  * 目标类

  */

 public interface UserService {

     //业务方法

     public void getById();

     public void add();

     public void delete();

     public String update();

     public void batch();

 }

 public class UserServiceImpl implements UserService {

     @Override

     public void getById() {

         System.out.println("UserServiceImpl类的getById方法被调用...");

         //抛出异常

         System.out.println(1/0);

     }

     @Override

     public void add() {

         System.out.println("UserServiceImpl类的add方法被调用...");

     }

     @Override

     public void delete() {

         System.out.println("UserServiceImpl类的delete方法被调用...");

 //        System.out.println(1/0);

     }

     @Override

     public String update() {

         System.out.println("UserServiceImpl类的update方法被调用...");

 //        System.out.println(1/0);

         return "update的返回值";

     }

     @Override

     public void batch() {

         System.out.println("UserServiceImpl类的batch方法被调用...");

     }

 }

　　　　定义切面类

 /**

  * 切面

  */

 public class UserAspect {

     //前置通知

     public void beforeAdvice(JoinPoint jp){

         //获取切入点的方法的名称

         String name = jp.getSignature().getName();

         System.out.println("前置通知切入点的方法的名称："+name);

         System.out.println("前置通知");

     }

     //后置通知

     public void afterAdvice(JoinPoint jp){

         //获取切入点的方法的名称

         String name = jp.getSignature().getName();

         System.out.println("后置通知切入点的方法的名称："+name);

         System.out.println("后置通知");

     }

     //返回通知

     //可以获取object类型的返回值

     //注意：result名称必须和配置文件中的returning的名称保持一致

     public void afterReturningAdvice(JoinPoint jp,Object result){

         //获取切入点的方法的名称

         String name = jp.getSignature().getName();

         System.out.println("返回通知切入点的方法的名称："+name);

         //打印返回值

         System.out.println(result);

         System.out.println("返回通知");

     }

     //异常通知

     public void exceptionAdvice(JoinPoint jp,Exception ex){

         //获取切入点的方法的名称

         String name = jp.getSignature().getName();

         System.out.println("异常通知切入点的方法的名称："+name);

         //打印异常信息

         System.out.println(ex.getMessage());

         System.out.println("异常通知");

     }

     //环绕通知

     //必须有一个参数：ProceedingJoinPoint

     //有返回值：Object

     public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{

         System.out.println("环绕通知前");

         //执行业务逻辑方法

         Object result = pjp.proceed();

         //获取切入点的方法的名称

         String name = pjp.getSignature().getName();

         System.out.println("环绕通知切入点的方法的名称："+name);

         System.out.println("环绕通知后");

         return result;

     }

 }

　　　　配置spring核心配置文件

<?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.2.xsd

        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

    <!-- 把切面和业务对象放到容器中 -->

    <bean id="userAspect" class="spring.aop.xml.UserAspect"></bean>

    <bean id="userServiceImpl" class="spring.aop.xml.UserServiceImpl"></bean>

    <!-- 配置aop的实现 -->

    <aop:config>

        <!--

            切入点的配置

            expression(切入点表达式)：指定切哪个方法

         -->

         <aop:pointcut expression="execution(* *.add*(..))" id="pointCut01"/>

         <aop:pointcut expression="execution(* *.delete*(..))" id="pointCut02"/>

         <aop:pointcut expression="execution(* *.update*(..))" id="pointCut03"/>

         <aop:pointcut expression="execution(* *.getById*(..))" id="pointCut04"/>

         <aop:pointcut expression="execution(* *.batch*(..))" id="pointCut05"/>

         <!-- 切面的配置 -->

         <aop:aspect ref="userAspect">

             <!--

                 前置通知的配置：在pointCut01切入点的位置添加beforeAdvice的通知

              -->

              <aop:before method="beforeAdvice" pointcut-ref="pointCut01"/>              

             <!--

                 后置通知的配置：在pointCut02切入点的位置添加afterAdvice的通知

              -->

              <aop:after method="afterAdvice" pointcut-ref="pointCut02"/>

             <!--

                 返回通知的配置：在pointCut03切入点的位置添加afterReturningAdvice的通知

                 returning：返回值的参数名称

              -->

              <aop:after-returning method="afterReturningAdvice" pointcut-ref="pointCut03" returning="result"/>

             <!--

                 异常通知的配置：在pointCut04切入点的位置添加exceptionAdvice的通知

                 throwing：抛出异常的名称，必须和通知上的形参名称一致

              -->

              <aop:after-throwing method="exceptionAdvice" pointcut-ref="pointCut04" throwing="ex"/>

             <!--

                 环绕通知的配置：在pointCut05切入点的位置添加aroundAdvice的通知

              -->

              <aop:around method="aroundAdvice" pointcut-ref="pointCut05"/>

         </aop:aspect>

    </aop:config>

</beans>

　　　　测试

 //使用xml方式配置AOP

 @RunWith(SpringJUnit4ClassRunner.class)

 @ContextConfiguration("classpath:applicationContext-aop-xml.xml")

 public class XmlAopTest {

     //注入业务对象

     @Autowired

     private UserService userService;

     //测试AOP，对切入点进行增强

     @Test

     public void test(){

         //前置通知的测试

 //        userService.add();

         //后置通知的测试(无论有没有异常都会执行)

 //        userService.delete();

         //返回通知的测试(只有业务方法正常执行时，才会执行的通知)

 //        userService.update();

         //异常通知的测试

 //        userService.getById();

         //环绕通知的测试

         userService.batch();

     }

 }

AOP的切入点表达式execution

　　　　表达式的写法：修饰关键词返回值类型包名.类名.方法名(..)

修饰关键词：protected , public , private ….一般都省略不写

返回值类型：一般返回值类型用 * 号代替，表示任意的返回值都可以

方法名中的两个点：表示所带的参数的个数。

　　　　　　　　举例如下：

　　任意以public修饰的方法都可以

execution(public * *(..))

　　任何以set开头的方法都可以

execution(* set*(..))

　　任何在AccountService 这个接口下面的方法都可以

execution(* com.xyz.service.AccountService.*(..))

　　任何在com.xyz.service 这个包下面的所有类的所有方法都可以

execution(* com.xyz.service.*.*(..))

　　任何在com.xyz.service 这个包以及整个包下面的所有子包的所有类的所有方法都可以

execution(* com.xyz.service..*.*(..))

　　..代表这个包及这个包下面的所有子包

Spring中的5种通知类型及参数

- - 　　前置通知：在目标方法开始之前进行执行的通知
    
    　　　　参数：JoinPoint
  - 　　后置通知：在目标方法执行之后，无论是否发生异常，都进行执行的通知
    
    　　　　参数：JoinPoint
  - 　　返回通知：在目标方法正常结束时，才执行的通知
    
    　　　　参数：JoinPoint，Object
  - 　　异常通知：在目标方法出现异常时才会进行执行的通知
    
    　　　　参数：JoinPoint，Exception
  - 　　环绕通知：在目标方法执行之前、之后都会执行的通知
    
    　　　　参数：ProceedingJoinPoint(必须有)

AOP基于注解方式的实现

xml配置中开启spring注解扫描及开启aop注解的自动代理

<?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.2.xsd

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd

        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

    <!-- 开启spring的注解驱动 -->

    <context:component-scan base-package="spring.aop.annotation"></context:component-scan>

    <!-- 开启aop的自动代理：使用注解实现AOP，这个必须配置 -->

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

　　　　定义接口及接口实现类

 此处省略，同xml配置方式相同

　　　　通过注解的方式定义切面类

 /**

  * 切面

  */

 @Component

 @Aspect

 public class UserAspect {

     //前置通知

     @Before(value = "execution(* *.add*(..))")

     public void beforeAdvice(JoinPoint jp){

         String name = jp.getSignature().getName();

         System.out.println("前置通知的切入点的方法名：" + name);

         System.out.println("前置通知...");

     }

     //后置通知

     @After(value = "execution(* *.delete*(..))")

     public void afterAdvice(JoinPoint jp){

         String name = jp.getSignature().getName();

         System.out.println("后置通知的切入点的方法名：" + name);

         System.out.println("后置通知...");

     }

     //返回通知

     @AfterReturning(value = "execution(* *.update*(..))",returning="result")

     public void afterReturningAdvice(JoinPoint jp,Object result){

         String name = jp.getSignature().getName();

         System.out.println("返回通知的切入点的方法名：" + name);

         System.out.println(result);

         System.out.println("返回通知...");

     }

     //异常通知

     @AfterThrowing(value = "execution(* *.getById*(..))",throwing="ex")

     public void exceptionAdvice(JoinPoint jp,Exception ex){

         String name = jp.getSignature().getName();

         System.out.println("异常通知的切入点的方法名：" + name);

         System.out.println(ex.getMessage());

         System.out.println("异常通知...");

     }

     //环绕通知

     @Around(value = "execution(* *.batch*(..))")

     public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{

         System.out.println("环绕通知前...");

         Object result = pjp.proceed();

         String name = pjp.getSignature().getName();

         System.out.println("环绕通知的切入点的方法名：" + name);

         System.out.println("环绕通知后...");

         return result;

     }

 }

　　　　测试

 /**

  * 注解形式的AOP的单元测试类

  */

 @RunWith(SpringJUnit4ClassRunner.class)

 @ContextConfiguration("classpath:applicationContext-aop-annotation.xml")

 public class AnnotationAopTest {

     @Autowired

     private UserService userService;

     @Test

     public void test(){

         //注解：前置通知的测试

 //        userService.add();

         //后置通知的测试

 //        userService.delete();

         //返回通知

 //        userService.update();

         //异常通知

 //        userService.getById();

         //环绕通知

         userService.batch();

     }

 }

巴特西

AOP的实现