Anotações de transação no Spring Boot

Em aplicativos, o gerenciamento de transações é um conceito muito importante. Uma transação é uma sequência de operações em que todas são bem-sucedidas ou todas falham. No Spring Boot, as anotações de transação podem ser usadas para gerenciar transações. Ao usar anotações de transação, um conceito muito importante é o comportamento de propagação da transação.

O que é Comportamento de Propagação de Transação

O comportamento de propagação de transação refere-se a qual comportamento de transação ocorre quando um método chama outro método. No Spring Boot, o comportamento de propagação da transação é gerenciado pela estrutura do Spring. A estrutura Spring usa algumas regras para decidir como lidar com transações em diferentes situações.

Anotações de transação no Spring Boot

O Spring Boot fornece uma @Transactionalanotação para controlar as transações. Esta anotação pode ser colocada no método ou na classe. Se colocados em uma classe, todos os métodos herdarão essa anotação.

@TransactionalAs anotações têm algumas propriedades muito importantes, incluindo propagatione isolation. propagationOs atributos são usados ​​para especificar o comportamento de propagação da transação e isolationos atributos são usados ​​para especificar o nível de isolamento das transações.

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
public void doSomething() {
    
    
    // ...
}

No código acima, propagationo atributo especifica o comportamento de propagação da transação Propagation.REQUIRED, o que significa que se uma transação já existe, use esta transação; se não houver transação atual, crie uma nova transação. isolationO atributo especifica o nível de isolamento da transação Isolation.READ_COMMITTED, o que significa ler os dados confirmados.

Princípios de transação no Spring Boot

No Spring Boot, as transações são gerenciadas pelo framework Spring. A estrutura Spring usa a tecnologia AOP (programação orientada a aspectos) para implementar o gerenciamento de transações. Especificamente, a estrutura Spring implementa o gerenciamento de transações por meio de um mecanismo de proxy.

Quando um método é @Transactionalanotado, o Spring cria um objeto proxy para o método. Quando esse método é chamado, ele realmente chama o método do objeto proxy. O objeto proxy iniciará uma transação antes que o método seja executado e decidirá se confirma a transação ou reverte a transação de acordo com o resultado da execução após a execução do método.

A estrutura Spring usa um TransactionInterceptorinterceptador para implementar o gerenciamento de transações. Este interceptor interceptará antes e depois da execução do método e decidirá se abre uma nova transação ou usará uma transação existente de acordo com o comportamento de propagação e condições anormais da transação e decidirá se deseja confirmar a transação ou retorná-la de acordo com o resultado da execução depois que o método é executado. Saia do negócio.

Uso de transações no Spring Boot

No Spring Boot, podemos usar @Transactionalanotações para controlar transações. Ao usar @Transactionalanotações, você precisa prestar atenção aos seguintes pontos:

1. @TransactionalAs anotações só podem ser colocadas em métodos públicos.
2. O método deve ser não estático.
3. @TransactionalAs transações não funcionarão se o método anotado for chamado na mesma classe . Isso ocorre porque o Spring implementa o gerenciamento de transações por meio de proxies, e os proxies só podem entrar em vigor quando um método é chamado.
4. Se vários métodos anotados existirem em uma classe ao mesmo tempo @Transactional, esses métodos compartilharão a mesma transação.
5. Ao usar @Transactionalanotações, certifique-se de que as anotações estejam configuradas corretamente, caso contrário, a transação pode não ser revertida ou a reversão pode estar incompleta.

Aqui está um @Transactionalexemplo usando anotações:

@Service
public class UserService {
    
    

    @Autowired
    private UserRepository userRepository;

    @Transactional(rollbackFor = Exception.class)
    public void addUser(User user) {
    
    
        userRepository.save(user);
        // ...
## 代码解读

在上面的代码中，我们定义了一个`UserService`类，这个类使用了`@Transactional`注解来控制事务。在`addUser`方法中，我们首先调用了`userRepository.save(user)`方法来保存用户信息。由于这个方法上使用了`@Transactional`注解，因此在调用`userRepository.save(user)`方法之前，Spring框架会开启一个事务。如果在`userRepository.save(user)`方法执行期间发生了异常，那么这个事务将会被回滚。

`@Transactional`注解还有一些其他的属性，包括`readOnly`、`timeout`和`noRollbackFor`等。这些属性可以帮助我们更好地控制事务的行为。例如，`readOnly`属性可以指定事务是否为只读事务；`timeout`属性可以指定事务超时时间；`noRollbackFor`属性可以指定哪些异常不应该回滚事务。

```java
@Transactional(readOnly = true, timeout = 30, noRollbackFor = IllegalArgumentException.class)
public void doSomething() {
    
    
    // ...
}

No código acima, usamos @Transactionalos atributos readOnly, timeoute da anotação noRollbackFor. Este método é especificado como uma transação somente leitura com um tempo limite de 30 segundos. Se ocorrer uma exceção durante a execução do método IllegalArgumentException, a transação não será revertida.

Resumir

No Spring Boot, o gerenciamento de transações é um conceito muito importante. Podemos usar anotações de transação para controlar o comportamento das transações. Ao usar anotações de transação, precisamos prestar atenção ao comportamento de propagação da transação, nível de isolamento da transação e outras propriedades de configuração. A estrutura Spring usa a tecnologia AOP para implementar o gerenciamento de transações, especificamente, por meio de um mecanismo de proxy. Ao usar anotações de transação, precisamos garantir que as anotações sejam configuradas corretamente, caso contrário, a transação pode não ser revertida ou a reversão pode ser incompleta.