Overview

Spring provides comprehensive transaction management capabilities through its abstraction layer over various transaction APIs. This framework simplifies handling database transactions by offering both programmatic and declarative approaches.

Core Interfaces

PlatformTransactionManager

The PlatformTransactionManager interface serves as the central contract for managing transactions:

public interface PlatformTransactionManager {
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
    void commit(TransactionStatus status) throws TransactionException;
    void rollback(TransactionStatus status) throws TransactionException;
}

This interface defines how to acquire, commit, and roll back transactions.

TransactionDefinition

The TransactionDefinition interface specifies transaction properties:

public interface TransactionDefinition {
    int PROPAGATION_REQUIRED = 0;
    int PROPAGATION_SUPPORTS = 1;
    // Additional propagation constants...
    
    int ISOLATION_DEFAULT = -1;
    int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;
    // Additional isolation levels...
    
    int getPropagationBehavior();
    int getIsolationLevel();
    int getTimeout();
    boolean isReadOnly();
    String getName();
}

TransactionStatus

The TransactionStatus interface represents the runtime state of a transaction:

public interface TransactionStatus extends SavepointManager {
    boolean isNewTransaction();
    boolean hasSavepoint();
    void setRollbackOnly();
    boolean isRollbackOnly();
    boolean isCompleted();
}

Declarative Transaction Configuration

XML-Based Approach

For XML-based configuration, define transaction manager and advice:

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

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED" read-only="false" />
        <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="serviceMethods" expression="execution(* com.example.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethods"/>
</aop:config>

Annotation-Based Configuration

Using annotasions requires enabling transaction support:

@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
public class AccountService {
    
    @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
    public void transfer(String from, String to, float amount) {
        // Business logic here
        // Exception handling for rollback scenarios
    }
}

Enable annotation support in XML:

<tx:annotation-driven transaction-manager="transactionManager"/>

Pure Java Configuration

For fully annotated configuration, use:

@Configuration
@ComponentScan("com.example")
@EnableTransactionManagement
public class AppConfig {
    
    @Bean
    public DataSource dataSource() {
        // Data source configuration
    }
    
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

Transaction Behavior

Spring's default propagation behavior is REQUIRED. When a method calls enother within the same class, it typically uses the same transaction context unless configured otherwise.

Transaction Rollback Conditions

Transactions roll back automatically on unchecked exceptions (RuntimeException and Error). Checked exceptions require explicit configuration for rollback behavior.

Common Failure Scenarios

1. Self-invocation bypasses proxy mechanisms
2. Non-public methods cannot be proxied
3. Database engine lacks transaction support
4. Improper exception handling prevents rollback

Connection Uniqueness

Spring maintains connection uniqueness using ThreadLocal storage within the TransactionSynchronizationManager, ensuring each thread accesses its designated database connection during transaction execution.