1. Mecanismo de transação da primavera
Todas as tecnologias de acesso a dados possuem mecanismos de processamento de transações, que fornecem APIs para ativar transações, comprometer transações para concluir operações de dados ou reverter dados quando ocorrer um erro.
O mecanismo de transação da Spring usa um mecanismo unificado para lidar com transações de diferentes tecnologias de acesso a dados. O mecanismo de transação da Spring fornece uma interface PlatformTransactionManager, e as transações de diferentes tecnologias de acesso a dados são implementadas usando diferentes interfaces:
O código para definir um gerente de transações em um programa é o seguinte:
@Bean Public PlatformTransactionManager transactionManager () {jpatransactionManager transactionManager = new JPatransactionManager (); transactionManager.SetDataSource (DataSource ()); retorno transactionManager; }2. Transações declarativas
A mola suporta transações declarativas, ou seja, usando anotações para selecionar o método que precisa usar transações. Ele usa a anotação @Transaction para indicar no método que o método requer suporte à transação.
@Transaction Public void Savesomething (longo id, nome da string) {// Operação do banco de dados}É importante observar aqui que esta anotação @Transaction vem do pacote org.springframework.transaction.annotation, não javax.transaction.
A Spring fornece uma anotação @enableTransaction -gerenciamento para permitir o suporte a transações declarativas nas classes de configuração. Depois de usar o @enableTransactionManagement, o contêiner de mola digitalizará automaticamente os métodos e as classes anotadas @Transactional. @Enabletransaction management é usado da seguinte forma:
@Configuration @enabletransactionManagement public class AppConfig {}3. Use @Transactional no nível da aula
@Transactional não pode apenas anotar os métodos, mas também em classes. Ao anotar uma classe, significa que todos os métodos públicos desta classe são ativados por transações. Se o nível de classe e o nível do método usarem a anotação @Transactional no nível da classe, a anotação do nível do método será sobrecarregada usando o nível da classe.
4. Suporte à transação para os dados da primavera JPA
Os dados da primavera JPA permitem o suporte à transação para todos os métodos padrão, e a propriedade readonly = true é ativada por padrão para transações de consulta.
Isso pode ser visto no código -fonte SimplejParepository, que o simplesjparepository define @Transaction (readonly = true) no nível da classe, enquanto a propriedade @Transaction é reescrita em operações relacionadas a salvar e excluir. Neste momento, a propriedade READONLY é falsa e as outras operações de consulta readonly ainda são falsas.
5. Suporte de transação da Botta de primavera
1. Configurado automaticamente gerente de transação
Ao usar o JDBC como tecnologia de acesso a dados, o Springboot define o feijão do PlatformTransactionManager para nós. Consulte a definição no org.springframework.boot.autoconfigure.jdbc.datasourceTransaction
@Bean @ConditionalonMissingBean @conditionalonBean (DataSource.Class) PlatformTransactionManager transactionManager () {retornar novo DataSourCetransactionManager (this.datasource); }Ao usar a JPA como tecnologia de acesso a dados, a Spring Boot define um feijão para a implementação do JPatransactionManager do PlatformTransaction; Consulte a definição no org.springframework.boot.autoconfigure.orm.jpa.jpabaseConfiguration.class Class:
@Bean @conditionalonMissingBean (plataformTransactionManager.class) PlatformTransactionManager transactionManager () {return New JPatransactionManager (); } 2. Ative automaticamente o suporte para transações de anotação
A inicialização da primavera é usada especialmente para configurar transações como org.springframework.boot.autoconfigure.transaction.transactionAutoconfiguration. Esta classe de configuração depende da figuração do JPABASECON e do DataSourCetransactionManageRautoconfiguration.
O suporte para transações declarativas também é ativado na configuração DataSourCetransactionManageRautoconfiguration, o código é o seguinte:
@ConditionalonMissingBean (AbstractTransactionManagementConfiguration.Class) @Configuration @enableTransactionManagement Classe estática protegida transactionManagementConfiguration {}Portanto, na inicialização da primavera, não há necessidade de exibir a anotação @enableTransactionManagement ativada.
6. Exemplo (Springboot)
1.pom.xml:
<Depencency> <PuerpId> org.springframework.boot </frugiD> <ArtifactId> Spring-boot-starter-web </artifactId> </dependency> <pendence> <purbumid> org.springframework.boot </groupid> <stifactid> spring-boot-starer-data- jpatawork.boot </groupid> <stifactid> spring-boot-starer-data- jpata- jpra-jPerwentAning.Boot </groupid> <stifactid> spring-boot-starer-data-jpá <BOOT> </grupo> </artifactid> spring-boot-starter-data-jpa <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-rest</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency>
2.Application.yml:
Servidor: Porta: 5000 Spring: DataSource: Driver-Class-name: com.mysql.jdbc.driver URL: JDBC: mysql: // localhost: 3306/teste? useUnicode = true & caracterenCoding = utf8 & caractereSetRes = utf8 Username: root senha: senha: jpA = JPA = hibrf8 e caracteres (utf8 username: root: senha: jpA jpA = utf8 e caracteres. show-sql: true
3. Funcionários da classe de entidade:
@Entity Public Class Staff {@id @GeneratedValue Private Long Id; nome de string privado; idade inteira privada; endereço de string privado; Public Staff () {super (); } equipe pública (ID longo, nome da string, idade inteira, endereço da string) {super (); this.id = id; this.name = nome; this.age = idade; this.address = endereço; } // omita os métodos Get and Set}4. Repositório da equipe:
Public Interface StaffRepository estende JParepository <Staff, Long> {}5. Interface de serviço:
Public Interface StaffService {Public Staff SaveStaffWithRollback (equipe da equipe); // Rollingback Public Staff SaveStaffWithouTrollback (equipe da equipe); // Don't Rollback}6. Implementação de serviço:
@Service Public Class StaffServiceImpl implementa o StaffService {@AUTOWIRED STAFFEPOSIENTE STAFFEPOSITEMENT; // Você pode injetar diretamente o feijão do nosso RersonRepository. @Override // Use o atributo RollbackFor da anotação @Transaction para especificar uma exceção específica, os dados serão revertidos. @Transactional (rollbackfor = {ilegalargumentException.class}) Public Staff SaveStaffWithRollback (equipe da equipe) {Staff s = StaffRepository.Save (Staff); if (Staff.getName (). Equals ("Zhang San")) {lança nova ilegalArgumentException ("Zhang San já existe, reversão"); } retornar s; } @Override Public Staff SaveStaffWithouTrollback (equipe da equipe) {Staff s = StaffRepository.Save (Staff); if (Staff.getName (). Equals ("Zhang San")) {lança nova ilegalArgumentException ("Zhang San já existe, os dados não reversam"); } retornar s; }}7. Controlador:
@RestController @RequestMapping ("/Staff") Public Class Staffcontroller {@AUTOWIRED STAFFSERVICE STAFFSERVICE; // Teste a situação de reversão @RequestMapping ("/rollback") Rollback da equipe pública (equipe da equipe) {retorna StaffService.SaveStaffWithRollback (Staff); } // Teste a situação de reversão @RequestMapping ("/Notrollback") Public Staff Norollback (equipe da equipe) {Return StaffService.SaveStaffWithouTrollback (Staff); }}8. Execute o teste:
(1) Rollback: http: // localhost: 5000/Staff/Rollback? Nome = Zhang San & Age = 18
Console:
banco de dados:
(2) Sem reversão: http: // localhost: 5000/Staff/Notrollback? Nome = Zhang San & Age = 18
Console:
banco de dados:
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.