Spring学习--切面优先级及重用切点表达式

指定切面的优先级：

在同一个链接点上应用不止一个切面时 , 除非明确指定 , 否则它们的优先级是不确定的。

切面的优先级可以通过实现 Ordered 接口或利用 @Order 注解指定。

实现 Ordered 接口 , getOrder() 方法的返回值越小 , 优先级越高 , 若使用 @Order 注解 , 序号出现在注解中 , 数字越小优先级越高。

 <?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">

     <!-- IOC 扫描包 -->

     <context:component-scan base-package="com.itdoc.spring.aop.circular"></context:component-scan>

     <!-- 使 AspectJ 注解起作用, 自动为匹配的类生成代理对象 -->

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

 </beans>

 package com.itdoc.spring.aop.circular;

 import org.springframework.stereotype.Component;

 /**

  * http://www.cnblogs.com/goodcheap

  *

  * @author: Wáng Chéng Dá

  * @create: 2017-03-03 19:34

  */

 public interface Arithmetic {

     int add(int i, int j);

     int sub(int i, int j);

     int mul(int i, int j);

     int div(int i, int j);

 }

 package com.itdoc.spring.aop.circular;

 import org.springframework.stereotype.Component;

 /**

  * http://www.cnblogs.com/goodcheap

  *

  * @author: Wáng Chéng Dá

  * @create: 2017-03-03 19:35

  */

 @Component("arithmetic")

 public class ArithmeticImpl implements Arithmetic {

     @Override

     public int add(int i, int j) {

         int result = i + j;

         return result;

     }

     @Override

     public int sub(int i, int j) {

         int result = i - j;

         return result;

     }

     @Override

     public int mul(int i, int j) {

         int result = i * j;

         return result;

     }

     @Override

     public int div(int i, int j) {

         int result = i / j;

         return result;

     }

 }

 package com.itdoc.spring.aop.circular;

 import org.aspectj.lang.ProceedingJoinPoint;

 import org.aspectj.lang.annotation.Around;

 import org.aspectj.lang.annotation.Aspect;

 import org.springframework.stereotype.Component;

 import java.util.Arrays;

 /**

  * 通知

  * http://www.cnblogs.com/goodcheap

  *

  * @author: Wáng Chéng Dá

  * @create: 2017-03-04 9:50

  */

 @Aspect

 @Component

 public class AsjectLogging {

     /**

      * 环绕通知需携带 ProceedingJoinPoint 类型的参数。

      * 环绕通知类似于动态代理的全过程: ProceedingJoinPoint 类型参数可以决定是否执行目标方法。

      * 环绕通知必须有返回值, 返回值即目标方法的返回值。

      *

      * @param point

      * @return

      */

     @Around("execution(* com.itdoc.spring.aop.circular.*.*(..))")

     public Object around(ProceedingJoinPoint point) {

         Object methodName = point.getSignature().getName();

         Object[] args = point.getArgs();

         Object result = null;

         try {

             //前置通知

             System.out.println("The method " + methodName + " begins with" + Arrays.asList(args));

             //执行方法

             result = point.proceed();

             //返回通知

             System.out.println("The method " + methodName + " ends with " + result);

         } catch (Throwable e) {

             e.printStackTrace();

             //异常通知

             System.out.println("The method " + methodName + " exception with " + e);

         } finally {

             //后置通知

             System.out.println("The method " + methodName + " ends");

         }

         return result;

     }

 }

 package com.itdoc.spring.aop.circular;

 import org.aspectj.lang.annotation.Aspect;

 import org.aspectj.lang.annotation.Before;

 import org.springframework.core.annotation.Order;

 import org.springframework.stereotype.Component;

 /**

  * http://www.cnblogs.com/goodcheap

  *

  * @author: Wáng Chéng Dá

  * @create: 2017-03-04 12:20

  */

 @Order(2147483647)

 @Aspect

 @Component

 public class Validate {

     @Before("execution(* com.itdoc.spring.aop.circular.*.*(..))")

     public void beforeValidate() {

         System.out.println("I am Validate's beforeValidate method...");

     }

 }

 package com.itdoc.spring.aop.circular;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 /**

  * http://www.cnblogs.com/goodcheap

  *

  * @author: Wáng Chéng Dá

  * @create: 2017-03-04 9:54

  */

 public class Main {

     public static void main(String[] args) {

         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

         Arithmetic arithmetic = (Arithmetic) ctx.getBean("arithmetic");

         System.out.println("result = " + arithmetic.div(1, 1));

     }

 }

控制台输出：

The method div begins with[1, 1]
I am Validate's beforeValidate method...
The method div ends with 1
The method div ends
result = 1

重用切入点表达式：

 package com.itdoc.spring.aop.circular;

 import org.aspectj.lang.annotation.Aspect;

 import org.aspectj.lang.annotation.Before;

 import org.aspectj.lang.annotation.Pointcut;

 import org.springframework.core.annotation.Order;

 import org.springframework.stereotype.Component;

 /**

  * http://www.cnblogs.com/goodcheap

  *

  * @author: Wáng Chéng Dá

  * @create: 2017-03-04 12:20

  */

 @Order(2147483647)

 @Aspect

 @Component

 public class Validate {

     @Pointcut("execution(* com.itdoc.spring.aop.circular.*.*(..))")

     public void declareJointPointExpression() {}

     /**

      * 同包引入可以不写包名, 若是不同包引用需要引入包名。

      */

     @Before("com.itdoc.spring.aop.circular.Validate.declareJointPointExpression()")

     public void beforeValidate() {

         System.out.println("I am Validate's beforeValidate method...");

     }

 }

巴特西

Spring学习--切面优先级及重用切点表达式

最新文章

热门文章