¿Cuántas formas hay de configurar elementos de primavera?
------------------------------------------- ----- ----------------
La gestión de transacciones proporcionada por Spring se puede dividir en dos categorías: programática y declarativa.
La programación es más flexible, pero la cantidad de código es grande y hay muchos códigos duplicados; la declarativa es más flexible y conveniente que la programática.
1. Gestión de transacciones tradicional usando JDBC
En el pasado, JDBC se usaba para operaciones de datos y DataSource se usaba para obtener la conexión de la fuente de datos. es seguro para subprocesos y la conexión no es segura para subprocesos, por lo que se recupera una conexión de la fuente de datos para cada solicitud. Las fuentes de datos generales se gestionan mediante contenedores, incluidos los grupos de conexiones. Por ejemplo, los contenedores comerciales J2EE como TOMCAT, WEBSPHERE, WEBLOGIC, etc. proporcionan esta función.
En el pasado, cuando usábamos JDBC para escribir código, la gestión de transacciones podía verse así:
Connection conn = null
try{
conn = DBConnectionFactory.getConnection;
conn.setAutoCommit(false);
//hacer algo
conn.commit(); confirmar la transacción
}catch(Exception e){
conn.rollback()
}
finalmente{
try{
conn.close();
} catch(SQLException se){ //hacer algo}
//cerrar ResultSet, PreparedStatement, Connection
//aviso: Puede ocurrir una excepción al cerrar rs, pstmt, conn
}
Escriba el código de acuerdo con las ideas anteriores, el La cantidad de código es relativamente larga y es fácil ser descuidado, olvidar algunos intentos/capturas y provocar algunas excepciones que no se pueden detectar. Aunque a veces escribiremos la clase DBTool para cerrar estos recursos y asegurarnos de que no se produzcan excepciones. cerrar estos recursos, pero hacerlo causará problemas adicionales.
2. Procesamiento programático de transacciones proporcionado por Spring
Spring proporciona varias clases para el procesamiento de transacciones: TransactionDefinition //Definición de atributos de transacción
TranscationStatus // representa la transacción actual , que se puede enviar o revertir.
PlatformTransactionManager es la interfaz básica proporcionada por Spring para administrar transacciones. Hay una clase abstracta AbstractPlatformTransactionManager implementada debajo. Las clases de administración de transacciones que utilizamos, como DataSourceTransactionManager, son todas subclases de esta clase.
Nuestro proceso de gestión de transacciones programáticas puede ser el siguiente:
(1) Declarar la fuente de datos.
(2) Declarar una clase de gestión de transacciones, como: DataSourceTransactionManager, HibernateTransactionManger, JTATransactionManager, etc.
(3) Agregar código de procesamiento de transacciones a nuestro código:
TransactionDefinition td = new TransactionDefinition();
TransactionStatus ts = transactionManager.getTransaction(td);
try{
//hacer algo
transactionManager.commit(ts);
}catch(Exception e){transactionManager.rollback(ts);}
Utilice la plantilla de transacción TransactionTemplate proporcionada por Spring:
void add()
{
transactionTemplate.execute( new TransactionCallback(){
objeto pulic doInTransaction(TransactionStatus ts)
{ //hacer algo}
}
}
TransactionTemplate también nos ahorra algunos códigos de envío y reversión de transacciones para definir plantillas de transacciones al hacerlo; por lo tanto, es necesario inyectar objetos de gestión de transacciones
3. Procesamiento de transacciones declarativas de Spring
El procesamiento de transacciones declarativas de Spring también utiliza principalmente ideas de IoC y AOP, y proporciona interceptores TransactionInterceptor y los de uso común. La clase de proxy TransactionProxyFactoryBean puede realizar directamente transacciones proxy en componentes.
Pasos para usar TransactionInterceptor:
(1) Definir fuente de datos, clase de gestión de transacciones
(2) Definir interceptor de transacciones, por ejemplo:
class="org.springframework.transaction.interceptor.TransactionInterceptor">
(3) Declarar una clase de proxy para el componente ：ProxyFactoryBean
＜/list＞ ＜/property＞ ＜/bean＞ Utilice TransactionProxyFactoryBean: class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">