O Spring Framework oferece suporte robusto para controle transacional, especialmente em aplicações que seguem uma arquitetura em camadas. O gerenciamento de transações é tipicamente aplicado na camada de serviço (business layer), e o Spring implementa essa funcionalidade com base em AOP (Programação Orientada a Aspectos), permitindo tanto configuração declarativa quanto por meio de anotações.

O artefato necessário para habilitar essa funcionalidade é spring-tx-5.2.9.RELEASE.jar.

Principais Componentes do Controle Transacional

O ponto central do gerenciamento de transações no Spring é a interface PlatformTransactionManager, que define operações fundamentais:

• getTransaction(TransactionDefinition): obtém um objeto de transação com base nas regras definidas.
• commit(): confirma a transação após desabiiltar o modo automático de commit.
• rollback(): reverte a transação e libera os recursos associados.

Implementações comuns incluem:

• DataSourceTransactionManager: usado com JDBC ou MyBatis.
• HibernateTransactionManager: utilizado com o Hibernate.

A interface TransactionDefinition especifica as propriedades da transação:

• getIsolationLevel(): nível de isolamento.
• getPropagationBehavior(): comportamento de propagação.
• getTimeout(): tempo máximo de execução.
• isReadOnly(): indica se a transação é somente leitura.

Níveis de Isolamento

• ISOLATION_DEFAULT: usa o nível padrão do banco de dados.
• ISOLATION_READ_UNCOMMITTED (1): permite leitura de dados não confirmados.
• ISOLATION_READ_COMMITTED (2): evita leitura suja.
• ISOLATION_REPEATABLE_READ (4): garante consistência em leituras repetidas.
• ISOLATION_SERIALIZABLE (8): mais restritivo, evita qualquer interferência concorrente.

Comportamentos de Propagação

• REQUIRED: participa de uma transação existente ou cria uma nova (padrão).
• SUPPORTS: executa dentro de uma transação se houver uma ativa; caso contrário, executa sem transação.
• MANDATORY: exige uma transação ativa; lança exceção se não houver.
• REQUIRES_NEW: suspende qualquer transação atual e inicia uma nova.
• NOT_SUPPORTED: executa sem transação, suspendendo a atual se existir.
• NEVER: executa sem transação; lança exceção se houver uma ativa.
• NESTED: executa em uma transação aninhada se houver uma externa; caso contrário, age como REQUIRED.

Configuração Declarativa de Transações

Passos para configurar transações via XML:

1. Definir o gerenciador de transações: ```

2. Configurar as regras transacionais: ``` <tx:advice id="transactionAdvice" transaction-manager="transactionManager"> tx:attributes <tx:method name="*" propagation="REQUIRED" isolation="DEFAULT" read-only="false" timeout="-1" /> </tx:attributes> </tx:advice>

   
   Os atributos incluem nome do método, isolamento, propagação, modo somente leitura, tempo limite e regras de rollback.
   

3. Vincular as regras aos pontos de corte (pointcuts) usando AOP: ``` aop:config <aop:advisor advice-ref="transactionAdvice" pointcut="execution(* com.exemplo.servico..(..))" /> </aop:config>

Controle Transacional com Anotações

Alternativamente, é possível usar anotações diretamente no código-fonte:

1. Incluir o namespace tx no cabeçalho do XML de configuração: ``` xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"

2. Habilitar o suporte a anotações transacionais: ``` <tx:annotation-driven transaction-manager="transactionManager" />

3. Aplicar a anotação @Transactional em classes ou métodos: ``` @Transactional(propagation = Propagation.REQUIRED, readOnly = false, timeout = -1, rollbackFor = Exception.class) public void realizarOperacao() { ... }

   
   Quando aplicaad em uma classe, todos os seus métodos públicos herdam a configuração. Se um método também tiver a anotação, ela sobrescreve a definição da classe.
   
   

Em contextos baseados em Java (sem XML), pode-se usar @EnableTransactionManagement junto com @Configuration para ativar o mesmo comportamento do <tx:annotation-driven/>.