Spring AOP: 织入的顺序

spring AOP 采用和 AspectJ 一样的优先顺序来织入增强处理：在进入连接点时，高优先级的增强处理将先被织入；在退出连接点时，高优先级的增强处理会后被织入。

当不同的切面里的两个增强处理需要在同一个连接点被织入时，Spring AOP将以随机的顺序来织入这两个增强处理。如果应用需要指定不同切面类里增强处理的优先级，Spring提供了如下两种解决方案：

① 让切面类实现org.springframework.core.Ordered接口，实现该接口只需实现一个int getOrder( )方法，该方法返回值越小，则优先级越高。

② 直接使用@Order注解来修饰一个切面类，使用 @Order 时可指定一个int型的value属性，该属性值越小，则优先级越高。

Person.Java :

1. public interface Person {
2. public void eat(String food);
3. }

Chinese.java :

1. @Component
2. public class Chinese implements Person {
3. @Override
4. public void eat(String food) {
5. System.out.println("我正在吃:"+food);
6. }
7. }

AspectFirst.java :

1. import org.aspectj.lang.annotation.After;
2. import org.aspectj.lang.annotation.Aspect;
3. import org.aspectj.lang.annotation.Before;
4. import org.springframework.core.annotation.Order;
5. @Aspect
6. @Order(5)
7. public class AspectFirst {
8. @Before("execution(* com.bean.*.*(..))")
9. public void aspectFirstStart(){
10. System.out.println("@Before增强处理：我是AspectFirst切面，我的优先级为5");
11. }
12. @After("execution(* com.bean.*.*(..))")
13. public void aspectFirstEnd(){
14. System.out.println("@After增强处理：我是AspectFirst切面，我的优先级为5");
15. }
16. }

AspectSecond.java :

1. import org.aspectj.lang.annotation.After;
2. import org.aspectj.lang.annotation.Aspect;
3. import org.aspectj.lang.annotation.Before;
4. import org.springframework.core.annotation.Order;
5. @Aspect
6. @Order(1)
7. public class AspectSecond {
8. @Before("execution(* com.bean.*.*(..))")
9. public void aspectSecondStart(){
10. System.out.println("@Before增强处理：我是AspectSecond切面，我的优先级为1");
11. }
12. @After("execution(* com.bean.*.*(..))")
13. public void aspectSecondEnd(){
14. System.out.println("@After增强处理：我是AspectSecond切面，我的优先级为1");
15. }
16. }

bean.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:context="http://www.springframework.org/schema/context"
5. xmlns:aop="http://www.springframework.org/schema/aop"
6. xmlns:tx="http://www.springframework.org/schema/tx"
7. xsi:schemaLocation="http://www.springframework.org/schema/beans
8. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
9. http://www.springframework.org/schema/context
10. http://www.springframework.org/schema/context/spring-context-2.5.xsd
11. http://www.springframework.org/schema/tx
12. http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
13. http://www.springframework.org/schema/aop
14. http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
15. <context:component-scan base-package="com.bean">
16. <context:include-filter type="annotation"
17. expression="org.aspectj.lang.annotation.Aspect"/>
18. </context:component-scan>
19. <aop:aspectj-autoproxy/>
20. </beans>

Test.java :

1. public class Test {
2. public static void main(String[] args) {
3. ApplicationContext ctx=new ClassPathXmlApplicationContext("bean.xml");
4. Person p=(Person) ctx.getBean("chinese");
5. p.eat("西瓜");
6. }
7. }

运行程序，控制台输出：

同一个切面类里的两个相同类型的增强处理在同一个连接点被织入时，Spring AOP将以随机顺序来织入这两个增强处理，没有办法指定它们的织入顺序。如果确实需要保证它们以固有的顺序被织入，则可考虑将多个增强处理压缩成一个，或者将不同增强处理重构到不同切面类中，通过在切面类级别上进行排序。