Inicio>Tutorial de programación de red>Tutorial de Java

Cuatro métodos de gestión de transacciones en primavera (transferencia bancaria como ejemplo)

Autor：Eve Cole Fecha de actualización：2025-08-25 23:16:01

Prefacio

La dirección de descarga del código de muestra para este artículo (se ejecute completamente, incluidos los archivos SQL, modifique la configuración de la base de datos después de descargar): haga clic aquí para descargar

1. El papel de los asuntos

Varias operaciones de bases de datos se controlan en su conjunto, y tienen éxito o fallan juntas.

Atomicidad: se refiere a que una transacción es una unidad de trabajo inseparable, y las operaciones en una transacción ocurren o no ocurren ninguna.

Consistencia: significa que la integridad de los datos antes y después de una transacción debe ser consistente.

Aislamiento: cuando múltiples usuarios acceden a la base de datos simultáneamente, las transacciones de un usuario no pueden ser interfiridas por las transacciones de otros usuarios, y los datos entre múltiples transacciones concurrentes deben aislarse entre sí.

Persistencia: una vez que se comete una transacción, sus cambios en los datos en la base de datos son permanentes, y la falla de la base de datos instantánea no debería tener ningún impacto en ello.

2. Gestión de transacciones de primavera La abstracción de alto nivel incluye principalmente 3 interfaces

-Platform TransactionManager Transaction Manager (Commit, Rollback Transactions)

Spring proporciona diferentes implementaciones de interfaz de plataforma de plataforma para diferentes marcos de persistencia. como:

Uso de DataSourCetransactionManager cuando persiste los datos utilizando Spring JDBC o Ibatis

Use HibernatetransactionManager cuando use Hibernate3.0 para datos persistentes

-Información de definición de transacción de TRANSACTIONDEFINITION (aislamiento, propagación, tiempo de espera, solo lectura)

Lectura sucia: una transacción lee datos que han sido reescritos por otra transacción pero que aún no se ha enviado. Si estos datos se retroceden, los datos de lectura no son válidos.

No hay lectura repetitiva: en la misma transacción, los resultados devueltos al leer los mismos datos varias veces son diferentes.

Lectura de fantasía: después de una transacción lee varias líneas de registros, otra transacción inserta algunos registros y se produce lectura de fantasía. En la consulta posterior, la primera transacción encontrará algunos registros que no estaban originalmente disponibles.

Nivel de aislamiento de transacciones: (cinco tipos)

  • Predeterminado: use el nivel de aislamiento predeterminado de la base de datos de backend (seleccionada en primavera)
  • Read_uncomited: le permite leer datos modificados no comprometidos. Puede causar sucio, fantasma y no repetible
  • Read_commited: permite leer después de que se haya cometido una transacción concurrente. Puede evitar una lectura sucia, pero la lectura fantasma y la lectura no repetible aún pueden ocurrir
  • Las lecturas de Multiple repetibles en el mismo campo son consistentes a menos que la transacción cambie los datos. Puede prevenir una lectura sucia y no repetible, pero la lectura fantasma aún puede ocurrir
  • Serializable-Full obedre el nivel de ácido de aislamiento para garantizar que no haya lectura sucia, ilusión y no repetible. Este es el más lento de todos los niveles de aislamiento, y generalmente se hace bloqueando completamente las tablas de datos involucradas en la transacción

Entre ellos, MySQL usa el nivel de aislamiento repetible_read de forma predeterminada; Oracle usa el nivel de aislamiento read_commeted de forma predeterminada

Comportamiento de comunicación de transacciones: (siete tipos)

  • Se requiere para soportar la transacción actual. Si no hay transacciones en la actualidad, cree una nueva transacción. Esta es la elección más común.
  • Supports-soporta la transacción actual. Si no hay transacción, se ejecutará de manera no transaccional.
  • Apoya obligatorio la transacción actual. Si no hay transacciones en la actualidad, se lanzará una excepción.
  • Requiere_new- Crea una nueva transacción. Si actualmente existe una transacción, suspenda la transacción actual.
  • No_Supported-Executs Operations de manera no transaccional, y si actualmente existe una transacción actualmente, la transacción actual se suspenderá.
  • Nunca se ejecutan de manera no transaccional, lanza una excepción si actualmente existe una transacción.
  • Anidados: eje dentro de una transacción anidada si actualmente existe una transacción. Si no hay transacciones en la actualidad, realice operaciones similares a las requeridas. Al tener múltiples puntos de guardado que se pueden revertir, la reversión interna no afectará las transacciones externas. Solo válido para DataSourCetransactionManager

-Estado de operación específico de transacción de transacción Estatus

3. La primavera proporciona los siguientes métodos para controlar las transacciones

a. Gestión de transacciones de programación (basada en el control de programación de Java, rara vez usado)-Consulte el paquete Demo1

Use TransactionTemplate para encapsular múltiples operaciones DAO

*b. Gestión de transacciones declarativas (control de configuración de AOP basado en primavera)

- Basado en la transacción ProXyFactoryBean. (Rara vez usado)-Ver paquete Demo2

Es necesario configurar una transacción ProfactyFactoryBean para cada clase que está experimentando una gestión de transacciones para mejorar.

-Basado en la configuración XML (utilizada con frecuencia)-Vea el paquete Demo3

Una vez configurado, no es necesario agregar nada a la clase.

Si la acción es un objeto objetivo para ingresar la transacción, debe agregar el atributo proxy-Target-Class = "True" al elemento <aop: config>. La razón es informar al marco de Spring para usar la tecnología CGLIB para generar clases de acción con funciones de gestión de transacciones.

-Basado en anotaciones (configuración simple, a menudo utilizada)

Habilitar la configuración de anotación de transacciones en ApplicationContext.xml. (En ApplicationContext.xml, simplemente defina el bean y agregue los siguientes elementos)

 <bean id = "txManager"> <Property name = "sessionFactory"> </property> <tx: anotation-maneation-ganager = "txmanager"/>

Use @Transactional en la clase de componente de destino, que se puede definir antes de la clase o antes del método.

4. Ejemplo (transferencia bancaria)

--Programación

 / *** @Description: interfaz de capa DAO del caso de transferencia**/ Public Interface Accountdao {/ *** @param out*: cuenta de transferencia* @param dinero*: cantidad de transferencia*/ public void outMoney (string out, doble dinero); / ** * * * @param en *: cuenta de transferencia * @param dinero *: cantidad de transferencia */ public void inMoney (cadena en, doble dinero); }
 / *** @Description: La clase de implementación de la capa DAO del caso de transferencia*/ public class AccountDaoMpl extiende JDBCDAOSUPPORT implementa Accountdao {/ *** @param out*: Cuenta de transferencia* @param Money*: Money de transferencia*/ @Override OutMoney OutMoney (String Out, Double Money) {Cadena sql = "Actualidad de actualización = Money Money = Money: this.getJDBCTemplate (). Update (SQL, Money, Out); } / *** @param in*: cuenta de transferencia* @param dinero*: cantidad de transferencia* / @Override public void inMoney (cadena en, doble dinero) {String sql = "Actualy Cuenta set Money = Money+? this.getjdbctemplate (). update (sql, dinero, in); }}
 / *** @Description: Interfaz comercial del caso de transferencia**/ Public Interface AccountService {/ *** @param Out: Transfer Out* @param in: Cuenta de transferencia* @param dinero: transferir cantidad*/ public void Transfer (String out, String in, doble dinero); }
 / *** @Description: Clase de implementación de la capa de negocios del caso de transferencia*/ Public ClasserServiceImpl implementa AccountService {// DAO Private Accountdao Accountdao; // plantilla para inyectar gestión de transacciones TransactionTemplate TransactionTemplate; / ** * @param out *: transferir * @param en *: cuenta de transferencia * @param dinero *: cantidad de transferencia */ @Override public void transfer (cadena final, cadena final en, dinero doble final) {// Si se produce una excepción durante el proceso, se puede completar la operación anterior. Si este último no puede, la transferencia es exitosa pero la transferencia no se recibe. // Accountdao.outmoney (fuera, dinero); // int i = 1/0; // Accountdao.inmoney (en, dinero); transaccionTemplate.exCute (new TransActionCallBackWitHoUtResult () {@Override void dointransactionWithoUtResult (TransactionStatus TransactionStatus) {AccountDao.outmoney ( Accountdao.inmoney (en, dinero); } public void setaccountdao (Accountdao Accountdao) {this.accountdao = Accountdao; } public void setTransactionTemplate (TransActionTemplate TransActionTemplate) {this.TransactionTemplate = TransActionTemplate; }}

ApplicationContext1.xml

 < name = "user" value = "$ {jdbc.username}" /> <propiedad name = "contraseña" value = "$ {jdbc.password}" /> < /bean> <!-Configure la clase de capa de negocios-> <bean id = "cuentas de cuentas"> <name de propiedad = "cuentooo" ref = "cuento" /> <!-inject the oject the theatplate para la protección de la transacción " name = "TransActionTemplate" ref = "transactionTemplate" /> < /bean> <!-Configure la clase DAO (simplificada, JDBCTemplate se configurará automáticamente)-> <bean id = "Accountdao"> <name de propiedad = "dataSource" ref = "dataSource" /> < /bean> <! id = "JDBCTemplate"> <Property Name = "DataSource" ref = "DataSource" /> < /bean> <bean id = "Accountdao"> <Property name = "jdbctemplate" ref = "jdbctemplate" /> < /bean>-<!-! =======================================================================================================================================================================================================================================================================================. ================================================================================================================ ================================================================================================================ ================================================================================================================ Configurar la plantilla de gestión de transacciones: clases proporcionadas por Spring para simplificar el código de administración de transacciones -> <bean id = "transaccionTemplate"> <Property name = "TransactionManager" ref = "TransactionManager"/> </bean>

prueba:

 @RunWith (SpringJunit4ClassRunner.class) @ContextConfiguration ("ClassPath: ApplicationContext1.xml") Public Class TransactionTest {@Resource (name = "AccountService") Private AccountService AccountService; @Test public void demo1 () {cuentOservice.transfer ("aaa", "bbb", 200d); }}

-Un método basado en TransactionProxyFactoryBean

 Public Class AccountServiceImpl implementa AccountService {// DAO Private Accountdao Accountdao; / ** * @param out *: transferir * @param in *: cuenta de transferencia * @param dinero *: transferir el monto */ @Override public void transfer (cadena, cadena en, doble dinero) {Accountdao.outMoney (Out, Money); // int i = 1/0; Accountdao.inmoney (en, dinero); } public void setaccountdao (Accountdao Accountdao) {this.accountdao = Accountdao; }}

ApplicationContext2.xml

 < name = "user" value = "$ {jdbc.username}" /> <propiedad name = "contraseña" value = "$ {jdbc.password}" /> < /bean> <!-Configurar la clase de capa de negocios-> <bean id = "cuentas de cuentas"> <name de propiedad = "cuento de cuenta" ref = "cuento" /> </reme> < JDBCTemplate)-> <bean id = "Accountdao"> <Property Name = "DataSource" ref = "dataSource" /> </ bean> <!-!- ==========================================================================================================================================================================. ====================================================================================================================================================================== ¡ ==========================================================================================================================================================================. ====================================================================================================================================================================== ¡ -> <!-Configurar Transaction Manager-> <Bean id = "TransactionManager"> <Property Name = "DataSource" ref = "dataSource" /> </ bean> <!-Configurar el proxy para el recubre de la capa de negocios-> <bean id = "cuentas de cuentas"> <! Configurar el objeto de destino-> <nombre de propiedad = "refering" refer "de cuentas" /> <! name = "TransActionManager" ref = "TransactionManager"> </Property> <!-Propiedades de transacción de inyección-> <Property Name = "TransactionATtributes"> <props> <!-Formato de Prop:* Propagación: Comportamiento de propagación de transacciones* ISOTACIÓN: Nivel de aislamiento de transacciones* Readonly: Readinge* -Exception: Exception: What Exceptions Roll Back Transactions* +Excepción: Excepción: Excepción: no Roll Transacciones no <proping key = "transfer"> propagation_required </pr> <!-<proping key = "transfer"> propagation_required, readonly </pr>-> <!-<proping key = "transfer"> propagation_required, readonly </pr>-> <!-<aprop key = "transfer"> propagation_required,+java.lang.arithmeticeiciciceicice </props> </property> </bean>

prueba:

 @RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("ClassPath: ApplicationContext2.xml") public class TransactionTest { / *** Asegúrese de inyectar la clase proxy: porque la clase proxy realiza operaciones mejoradas* / // @Resource (name = "cuentas de cuentas") @Resource (name = "cuentas mejoradas* / // @Resource (name =" cuentas de cuentas ") @resource (name =" cuenta mejorada* / // @Resource (name = "cuentas de cuentas") @Resource (name = "") AccountService AccountService; @Test public void demo1 () {cuentOservice.transfer ("aaa", "bbb", 200d); }}

-Basado en la configuración XML

 Public Class AccountServiceImpl implementa AccountService {// DAO Private Accountdao Accountdao; / ** * @param out *: transferir * @param in *: cuenta de transferencia * @param dinero *: transferir el monto */ @Override public void transfer (cadena, cadena en, doble dinero) {Accountdao.outMoney (Out, Money); // int i = 1/0; Accountdao.inmoney (en, dinero); } public void setaccountdao (Accountdao Accountdao) {this.accountdao = Accountdao; }}

ApplicationContext3.xml

 < name = "user" value = "$ {jdbc.username}" /> <propiedad name = "contraseña" value = "$ {jdbc.password}" /> < /bean> <!-Configurar la clase de capa de negocios-> <bean id = "cuentas de cuentas"> <name de propiedad = "cuento de cuenta" ref = "cuento" /> </reme> < JDBCTemplate)-> <bean id = "Accountdao"> <Property Name = "DataSource" ref = "dataSource" /> </ bean> <!-!- ================================================================ ====================================================================== ====================================================================== ====================================================================== ====================================================================== ====================================================================== ====================================================================== ====================================================================== : Aislamiento del comportamiento de propagación de transacciones: nivel de aislamiento de transacción solo lectura: reucilla de lectura de solo reversión: qué excepciones han ocurrido sin-rollback-por: qué excepciones han ocurrido no tiempo de retroceso: información de vencimiento-> <tx: name de método = "transferir" propagación = "requerido"/> </tx: atributas> </triol Punto-> <aop: puntos expresión = "ejecución (* com.zs.spring.demo3.accountservice+.* (..))" id = "PointCut1"/> <!-Sección de configuración-> <aop: Advisor Advance-REF = "TXADVICE" PointCut-Ref = "PointCut1"/> </aop>

prueba:

 / *** @Description: Método de gestión de transacciones declarativo de Spring Dos: configuración XML basada en aspectos*/ @runwith (SpringJunit4ClassRunner.class) @ContextConfiguration ("classpath: applicationContext3.xml") public classTest {/ *** Debe inyectar la clase proxy: porque la clase proxy realiza mejoras mejoradas* (nombre* (nombre* (nombre* (nombre* (nombre* (nombre @Resure "AccountService") Reservice de cuentas privado AccountService; @Test public void demo1 () {cuentOservice.transfer ("aaa", "bbb", 200d); }}

-Basado en la anotación

 / *** @Transactional Propagation: Aislamiento del comportamiento de propagación de transacciones: nivel de aislamiento de transacciones Readonly: lectura de solo* reversión: qué excepciones han ocurrido norollback para: qué excepciones han ocurrido no reversión* reversión de reversión. False) Public ClasserServiceImpl implementa AccountService {// DAO inyectando transferencia de cuenta privada Accountdao; / *** @param out*: cuenta de transferencia* @param en*: cuenta de transferencia* @param dinero*: transferir el monto*/ @Override public void Transfer (String out, String in, Double Money) {Accountdao.outMoney (Out, Money); // int i = 1/0; Accountdao.inmoney (en, dinero); } public void setaccountdao (Accountdao Accountdao) {this.accountdao = Accountdao; }}

ApplicationContext4.xml

 < name = "user" value = "$ {jdbc.username}" /> <propiedad name = "contraseña" value = "$ {jdbc.password}" /> < /bean> <!-Configurar la clase de capa de negocios-> <bean id = "cuentas de cuentas"> <name de propiedad = "cuento de cuenta" ref = "cuento" /> </reme> < JDBCTemplate)-> <bean id = "Accountdao"> <Property Name = "DataSource" ref = "dataSource" /> </ bean> <!-!- ==========================================================================================================================================================================. ====================================================================================================================================================================== ¡ ==========================================================================================================================================================================. ====================================================================================================================================================================== ¡ Configurar Transaction Manager-> <Bean id = "TransactionManager"> <Property Name = "DataSource" ref = "dataSource"/> </le bean> <!-Activa la transacción de anotación-> <tx: manager de transacción-anotación = "TransactionManager"/>>/>>

prueba:

 @RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration ("ClassPath: ApplicationContext4.xml") Public Class TransactionTest { / *** Asegúrese de inyectar la clase Proxy: la clase de cuentas de cuentas de cuentas privadas; @Test public void demo1 () {cuentOservice.transfer ("aaa", "bbb", 200d); }}

Para el código específico y el proyecto de referencia de archivo de base de datos Código completo:

http://xiazai.vevb.com/201805/yuanma/spring-transaction_jb51.rar

Resumir

Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo tenga cierto valor de referencia para el estudio o el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.

Artículos relacionados