Core AOP Terminology

Aspect-Oriented Programming (AOP) in Spring relies on a specific set of concepts to modularize cross-cutting concerns. Understanding these terms is essential for configuring proxies and interceptors correctly:

• Target Object: The original bean that contains the primary business logic.
• Proxy: A dynamically generated wrapper that intercepts method calls directed at the target object.
• Join Point: Any identifiable point during program execution, such as method invocation or exception handling, where additional behavior could be applied.
• Pointcut: A predicate or expression that filters join points, defining exactly where advice will be executed.
• Advice: The actual cross-cutting logic (e.g., logging, caching, security validation) that runs at a matched join point.
• Aspect: A cohesive module that combines pointcuts and advice into a single unit.
• Weaving: The runtime or compile-time process of linking aspects with target objects to produce the final proxied instance.

Configuring Annotation-Driven AOP

To enable AspectJ-style annotations alongside Spring's component scanning, the application context must be configured to automatically generate proxies. The following XML setup activates auto-proxying and defines the component scan boundary:

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- Enable automatic proxy creation for @Aspect beans -->
    <aop:aspectj-autoproxy proxy-target-class="true" />

    <!-- Register annotated components within the specified package -->
    <context:component-scan base-package="io.enterprise.module" />
</beans>

Setting proxy-target-class="true" forces Spring to use CGLIB-based subclass proxies instead of JDK dynamic interfaces, which is necessary when targeting concrete classes without interfaces.

Transaction Propagation and Attributes

Spring's transaction management defines how transactional boundaries behave when methods call one another. The propagation strategy dictates whether a method joins, suspends, or creates a transaction:

• REQUIRED (Default): Joins the active transaction if one exists; otherwise, initializes a new transaction. When Service A calls Service B, B participates in A's transaction or starts its own if A is non-transactional.
• SUPPORTS: Executes within the current transaction if present. If no transaction exists, the method runs non-transactionally.
• REQUIRES_NEW: Always suspends any active transaction and starts a completely independent transaction. The outer transaction resumes only after the inner one completes.
• NOT_SUPPORTED: Executes outside of a transaction. If a transaction is currently active, it is temporarily suspended.
• NEVER: Mandates a non-transactional execution context. Throws an exception if called within an active transaction.
• NESTED: Executes within a nested transaction using savepoints if a transaction exists. Behaves identically to REQUIRED when no transaction is active.

Additional transaction metadata includes timeout (specified in seconds, defaults to -1 for no limit) and read-only (optimizes database connections for SELECT operations by preventing write locks).

Programmatic Transaction Management Components

When manual transaction control is required, Spring exposes three core interfaces that work in tandem:

• PlatformTransactionManager: The strategy interface responsible for creating, committing, and rolling back transactions acros different persistence APIs (JDBC, JPA, Hibernate, etc.).
• TransactionDefinition: A metadata holder that encapsulates propagation behavior, isolation level, timeout duration, and read-only flags.
• TransactionStatus: Represents the live state of a transaction, providing methods to check completion status, trigger rollbacks, or verify if a savepoint exists.

The operational flow follows a clear pattern: the PlatformTransactionManager consumes a TransactionDefinition to instantiate and return a TransactionStatus object, which is then used to control the transaction lifecycle programmatically.

Declarative Transaction Management via XML

Declarative transactions leverage AOP to separate transactional infrastructure from business logic. This approach ensures that service classes remain unaware of transacsion management, allowing configuration changes without code recompilation. The XML-based strategy defines a transaction manager, specifies transactional rules, and weaves them into target methods.

1. Transaction Manager Bean

<bean id="appTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="primaryDataSource" />
</bean>

2. Transactional Advice and Rules

<tx:advice id="businessTxAdvice" transaction-manager="appTxManager">
    <tx:attributes>
        <!-- Default rule for all service methods -->
        <tx:method name="*" propagation="REQUIRED" rollback-for="Exception" />
        
        <!-- Read-optimized rule for retrieval operations -->
        <tx:method name="query*" propagation="SUPPORTS" read-only="true" />
        <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
        
        <!-- Isolated transaction for bulk data processing -->
        <tx:method name="processBatch*" propagation="REQUIRES_NEW" timeout="60" />
    </tx:attributes>
</tx:advice>

3. AOP Weaving Configuration

<aop:config>
    <aop:pointcut id="serviceLayerExecution" 
                  expression="execution(* io.enterprise.module.service..*(..))" />
    <aop:advisor advice-ref="businessTxAdvice" pointcut-ref="serviceLayerExecution" />
</aop:config>

Pointcut Expression Syntax

The execution designator is the most common pointcut expression in Spring AOP. It follows the pattern execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?). In the configuration above, execution(* io.enterprise.module.service..*(..)) matches any return type (*), targets all classes within the service package and its subpackages (..), applies to any method name (*), and accepts any number or type of arguments ((..)). This expression acts as the filter that determines which beans receive the transactional proxy.