Spring?AOP與代理類的執行順序是什么

本篇內容介紹了“Spring AOP與代理類的執行順序是什么”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

關于 Spring AOP和Aspectj的關系，兩個都實現了切面編程，Spring AOP更多地是為了Spring框架本身服務的，而Aspectj具有更強大、更完善的切面功能，我們在寫業務時一般使用AspectJ。不過他們的概念、原理都差不多。

Spring AOP說：

the Spring Framework’s AOP functionality is normally used in conjunction with the Spring IoC container. Aspects are configured using normal bean definition syntax (although this allows powerful “autoproxying” capabilities): this is a crucial difference from other AOP implementations. There are some things you cannot do easily or efficiently with Spring AOP, such as advise very fine-grained objects (such as domain objects typically): AspectJ is the best choice in such cases. However, our experience is that Spring AOP provides an excellent solution to most problems in enterprise Java applications that are amenable to AOP

Spring AOP currently supports only method execution join points (advising the execution of methods on Spring beans). Field interception is not implemented, although support for field interception could be added without breaking the core Spring AOP APIs. If you need to advise field access and update join points, consider a language such as AspectJ.

Spring AOP will never strive to compete with AspectJ to provide a comprehensive AOP solution

可參考 Spring AOP vs AspectJ

AspectJ項目中提供了@AspecJ注解，Spring interprets the same annotations @Aspect as AspectJ 5

Spring AOP提供了定義切面的兩種方式

• schema-based approach ： XML-based format 通常不用了

• @AspectJ annotation style：注解形式，起這個名字是因為借鑒了AspectJ項目，其實用的Spring AOP的注解是@Aspect沒有J

注解案例：

@Aspect
@Component 
public class NotVeryUsefulAspect {
	@Pointcut("execution(* transfer(..))")// the pointcut expression
	private void anyOldTransfer() {}// the pointcut signature
	@Before("execution(* com.xyz.myapp.dao.*.*(..))")
    public void doAccessCheck() {
        // ...
    }
 	@AfterReturning(
        pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
        returning="retVal")
    public void doAccessCheck(Object retVal) {
        // ...
    }
	@AfterThrowing(
        pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
        throwing="ex")
    public void doRecoveryActions(DataAccessException ex) {
        // ...
    }
	@After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
    public void doReleaseLock() {
        // ...
    }
	@Around("com.xyz.myapp.SystemArchitecture.businessService()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
        // start stopwatch
        Object retVal = pjp.proceed();
        // stop stopwatch
        return retVal;
    }
}

AOP概念

• Aspect：cut cross multiple classes. Spring AOP通過 schema-based approach 或 @AspectJ annotation style 兩種方式定義切面。

• Join Point：程序執行點，通常代表一個方法的執行。

• Advice：Aspect中針對不同Join Point執行的操作，包括 around before after 三種advice。很多AOP框架將advice建模成interceptor，在Join Point外層維護一個 chain of interceptors。

• Pointcut：匹配 Join Points的規則，如@PointCut("pointcut expression")，滿足point expression的將進行切面。

• Target object：被切面的對象。

• AOP proxy：代理，Spring Framework通常使用JDK 動態代理或CGLIB動態代理。

• Weaving：linking aspects with other application types or objects to create an advised object. 發生在編譯、加載或運行時。

Type of advice

• before : @Before

• after returning : @AfterReturning

• after throwing : @AfterThrowing

• after (finally) : @After

• around : @Around

代理順序

當一個target object有多個Spring AOP代理時，代理類執行的順序有時很重要，比如分布式鎖代理和事務代理的順序，分布式鎖必須包裹住事務。

先下結論：

Spring通過接口或注解來判斷代理的順序，順序級別越低，代理越靠內層。順序級別獲取步驟如下：

• 是否實現org.springframework.core.Ordered接口

• 是否注解了org.springframework.core.annotation.Order注解

• 是否注解了javax.annotation.Priority注解

• 如果都沒有，默認最低優先級LOWEST_PRECEDENCE = Integer.MAX_VALUE，如@Transanctional注解就是最低級別

優先級定義范圍在Integer.MIN_VALUE到 Integer.MAX_VALUE（參見Orderd接口）。越小，優先級越高，越在外層先執行。

注解方式生成代理類是通過BeanPostProcessor實現的，由AspectJAwareAdvisorAutoProxyCreator完成，該類實現了BeanPostProcessor。

注意到該類有一個Comparator類字段。最終優先級由AnnotationAwareOrderComparator來判斷：

public class AnnotationAwareOrderComparator extends OrderComparator {
	/**
	 * Shared default instance of {@code AnnotationAwareOrderComparator}.
	 */
	public static final AnnotationAwareOrderComparator INSTANCE = new AnnotationAwareOrderComparator();
		@Override
	@Nullable
	protected Integer findOrder(Object obj) {
		// 父類，判斷是否實現了Orderd接口
		// (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null)
		Integer order = super.findOrder(obj);
		if (order != null) {
			return order;
		}
		// 沒有實現則繼續搜尋@Order和@Priority注解
		// 如果返回null，表示找不到，會返回父類執行getOrder方法返回Ordered.LOWEST_PRECEDENCE
		return findOrderFromAnnotation(obj);
	}
	@Nullable
	private Integer findOrderFromAnnotation(Object obj) {
		...
		// 找@Order和@Priority注解
		Integer order = OrderUtils.getOrderFromAnnotations(element, annotations);
		// 如果該類沒有注解，遞歸找被代理類
		if (order == null && obj instanceof DecoratingProxy) {
			return findOrderFromAnnotation(((DecoratingProxy) obj).getDecoratedClass());
		}
		// 被代理類有則返回優先級，沒有則返回null
		return order;
	}
}

“Spring AOP與代理類的執行順序是什么”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！