Gestión detallada de transacciones de Springboot

En la gestión de transacciones de Spring Boot, se implementa la interfaz PlatformTransactionManager.

public interface PlatformTransactionManager {
  org.springframework.transaction.TransactionStatus getTransaction(org.springframework.transaction.TransactionDefinition transactionDefinition) throws org.springframework.transaction.TransactionException;
  void commit(org.springframework.transaction.TransactionStatus transactionStatus) throws org.springframework.transaction.TransactionException;
  void rollback(org.springframework.transaction.TransactionStatus transactionStatus) throws org.springframework.transaction.TransactionException;
}

Cuando utilizamos spring-boot-starter-Cuando se depende de jdbc, el framework inyectará automáticamente DataSourceTransactionManager. Por lo tanto, no se necesita ninguna configuración adicional para usar la anotación @Transactional.

Administrador de transacciones jdbc

En el Service, los métodos anotados con @Transactional admitirán transacciones. Si la anotación está en la clase, todos los métodos de la clase admitirán transacciones por defecto.

Situação de múltiples administradores de transacciones

Uno: puede implementar la interfaz TransactionManagementConfigurer, y el valor de retorno del método es el administrador de transacciones predeterminado.

Dos: puede establecer el valor en el método de ejecución específico

Si hay múltiples instancias de PlatformTransactionManager en el contenedor de Spring y no se ha especificado un valor predeterminado mediante la interfaz TransactionManagementConfigurer, al usar la anotación @Transactional en el método, debe especificarse el valor de value. Si no se especifica, se lanzará una excepción.

//@EnableTransactionManagement // Habilitar la gestión de transacciones anotadas, equivalente a la configuración xml <tx:annotation-driven />
@SpringBootApplication
public class ProfiledemoApplication implements TransactionManagementConfigurer {
  @Resource(name="txManager2}
  private PlatformTransactionManager txManager2;
  // creación manual del gestor de transacciones1 el framework de datasource se inyecta automáticamente
  //En el contenedor de Spring, las anotaciones @Bean que se creen manualmente se cargan preferentemente, y el framework no reinicializará otras clases de implementación de PlatformTransactionManager.
  @Bean(name = "txManager1}
  public PlatformTransactionManager txManager(DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource);
  }
  // crea el gestor de transacciones2
  @Bean(name = "txManager2}
  public PlatformTransactionManager txManager2(EntityManagerFactory factory) {
    return new JpaTransactionManager(factory);
  }
  // Implementa el método de la interfaz TransactionManagementConfigurer, que representa el gestor de transacciones predeterminado en caso de tener múltiples gestores de transacciones
  @Override
  public PlatformTransactionManager annotationDrivenTransactionManager() {
    return txManager2;
  }
  public static void main(String[] args) {
    SpringApplication.run(ProfiledemoApplication.class, args);
  }
}

implementación específica

@Component
public class DevSendMessage implements SendMessage {
  // usando value para especificar qué gestor de transacciones se utilizará
  @Transactional(value="txManager1}
  @Override
  public void send() {
    System.out.println(">>>>>>>>Dev Send()<<<<<<<<");
    send2();
  }
  @Transactional
  public void send2()) {
    System.out.println(">>>>>>>>Dev Send2()<<<<<<<<");
  }
}

Nivel de aislamiento

public enum Isolation {
  DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),
  READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
  READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),
  REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),
  SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);
  private final int value;
  Isolation(int value) { this.value = value; }
  public int value() { return this.value; }
}

1. DEFAULT: este es el valor predeterminado, que indica que se utiliza el nivel de aislamiento predeterminado del subsistema de bases de datos. Para la mayoría de las bases de datos, este valor es generalmente: READ_COMMITTED.
2. READ_UNCOMMITTED: este nivel de aislamiento indica que una transacción puede leer los datos modificados por otra transacción pero no confirmados. Este nivel no puede evitar la lectura no válida y la lectura no repetible, por lo que este nivel se utiliza raramente.
3. READ_COMMITTED: este nivel de aislamiento indica que una transacción solo puede leer los datos que otra transacción ha confirmado. Este nivel puede evitar la lectura no válida, que es el valor recomendado en la mayoría de los casos.
4. REPEATABLE_READ: este nivel de aislamiento indica que una transacción puede repetir varias veces la ejecución de una consulta en todo el proceso, y cada vez se devuelven los mismos registros. Incluso si hay nuevos datos que satisfacen la consulta entre varias consultas, estos nuevos registros se ignoran. Este nivel puede evitar la lectura no válida y la lectura no repetible.
5. SERIALIZABLE: todas las transacciones se ejecutan sucesivamente una por una, de modo que entre las transacciones no es posible la interferencia, es decir, este nivel puede evitar la lectura no válida, la lectura no repetible y la lectura fantasma. Sin embargo, esto puede afectar significativamente el rendimiento del programa. En la mayoría de los casos, este nivel no se utiliza.

Método especificado: se puede configurar mediante la propiedad isolation, por ejemplo:

@Transactional(isolation = Isolation.DEFAULT)

Comportamiento de propagación

Se denomina comportamiento de propagación de transacciones a la opción que se puede especificar para la ejecución de un método transaccional cuando ya existe un contexto de transacción antes de comenzar la transacción actual.

Podemos ver que la clase enum Propagation definida en org.springframework.transaction.annotation.Propagation6valores enumerados que representan el comportamiento de propagación:

public enum Propagation {
  REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
  SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),
  MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
  REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
  NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
  NEVER(TransactionDefinition.PROPAGATION_NEVER),
  NESTED(TransactionDefinition.PROPAGATION_NESTED);
  private final int value;
  Propagation(int value) { this.value = value; }
  public int value() { return this.value; }
}

REQUIRED: Si existe una transacción actual, se une a esta transacción; si no existe una transacción, se crea una nueva transacción. Valor predeterminado.

SUPPORTS: Si existe una transacción actual, se une a esta transacción; si no existe una transacción, se continúa ejecutando de manera no transaccional.

MANDATORY: Si existe una transacción actual, se une a esta transacción; si no existe una transacción, se lanza una excepción. (Forzado a colocarse en la transacción).

REQUIRES_NEW: Crear una nueva transacción, si existe una transacción actual, se suspende la transacción actual. (Usado comúnmente para escribir registros, incluso si se deshace anteriormente, esta transacción se ejecutará y registrará la información de error).

NOT_SUPPORTED: Ejecutar de manera no transaccional, si existe una transacción actual, se suspende la transacción actual.

NEVER: Ejecutar de manera no transaccional, si existe una transacción actual, se lanza una excepción.

NESTED: Si existe una transacción actual, se crea una transacción como transacción anidada para ejecutarse; si no existe una transacción actual, este valor es equivalente a REQUIRED.

Método especificado: al usar la propiedad propagation, por ejemplo: }}

@Transactional(propagation = Propagation.REQUIRED)

Caso de no deshacer la transacción

Sólo se deshace la transacción cuando ocurre una RuntimeException no capturada

catch las excepciones lanzadas, ambas inserciones tendrán éxito

@Override
  @Transactional
  public void insertandinsert(Staff staff) {
    staffDao.insert(staff);
    try {
      int i = 1 / 0;
    }
      e.printStackTrace();
    }
    staffDao.insert(staff);
  }

Añadir la sentencia TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); en la cláusula catch de la método en la capa de servicio, manualmente deshacer no insertará datos

@Override
  @Transactional
  public void insertandinsert(Staff staff) throws Exception {
    try {
      staffDao.insert(staff);
      int i=1/0;
      staffDao.insert(staff);
    }
      TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
  }

Esto es todo el contenido de este artículo, espero que ayude a su aprendizaje y que todos apoyen a la tutorial de gritos.

Declaración: el contenido de este artículo se obtiene de la red, pertenece al propietario original, el contenido se contribuye y carga de manera autónoma por los usuarios de Internet, este sitio no posee los derechos de propiedad, no se ha realizado un procesamiento editorial humano y no asume la responsabilidad legal relevante. Si encuentra contenido sospechoso de infracción de derechos de autor, por favor envíe un correo electrónico a: notice#oldtoolbag.com (al enviar un correo electrónico, reemplace # con @ para denunciar y proporcione evidencia. Una vez verificada, este sitio eliminará inmediatamente el contenido sospechoso de infracción de derechos de autor.)