When multiple pieces of advice are applied to the same join point in Spring AOP, the order in which they are executed is crucial for maintaining predictable and reliable application behavior. Spring AOP uses a systematic process to determine this order, known as advice ordering and precedence.

Internally, Spring AOP assigns a precedence to each advice using two main mechanisms: the @Order annotation and the Ordered interface. When the proxy is created for a target object, Spring collects all applicable advice and sorts them according to these precedence rules. Advice with a lower order value is given higher priority and will run earlier in the advice chain. If no explicit order is provided, Spring uses a default precedence based on the order in which the advice was registered in the application context.

This approach ensures that the advice chain is constructed consistently, allowing each advice to execute in the intended sequence. By managing advice precedence at the framework level, Spring AOP provides a robust and predictable way to coordinate multiple cross-cutting concerns on the same join point.

Precedence Rules in Spring AOP

Spring AOP allows you to apply multiple pieces of advice to the same join point. When this happens, Spring must decide the order in which these advices are executed. This order is determined by a combination of explicit ordering annotations, advice types, and Spring’s internal mechanisms.

How Spring Determines Advice Precedence

1. Order Annotations:

   • You can specify the execution order of advice classes using the @Order annotation or by implementing the Ordered interface;
   • Lower values have higher priority (run earlier);
   • If two advices have the same order value, Spring uses further rules to determine precedence.

2. Advice Type Priority:

   • Spring AOP always applies advice types in a specific order, regardless of any @Order values;
   • The precedence order for advice types is:
     1. @Around advice (highest priority);
     2. @Before advice;
     3. @After advice;
     4. @AfterReturning advice;
     5. @AfterThrowing advice (lowest priority).
   • If multiple advices of the same type are present, @Order is used to resolve their order.

3. Proxy Creation and Internal Priority:

   • When multiple proxies are involved (such as combining AOP with other proxy-based features), Spring applies internal rules to determine which proxy wraps the others;
   • In most cases, the order of bean definition and proxy creation can slightly affect advice precedence, but explicit ordering and advice type rules take priority.

Example: Combining Order and Advice Type

Suppose you have two advice classes:

• LoggingAdvice with @Order(2) and @Before advice;
• SecurityAdvice with @Order(1) and @Around advice.

Spring will execute SecurityAdvice first because @Around advice always has the highest precedence, regardless of the @Order value. If both were @Before advices, then SecurityAdvice would run first due to its lower @Order value.

Key Takeaways

• Use the @Order annotation or Ordered interface to control the order of advice execution within the same advice type;
• Understand that advice type always takes precedence over @Order values;
• Rely on Spring’s internal proxy mechanisms only when necessary, and prefer explicit ordering for clarity.

This system ensures that your aspects execute in a predictable and maintainable order, even as your application grows in complexity.