La diferencia entre transacciones de bases de datos Java y transacciones de aplicaciones
1.getCurrentSession() vs. openSession()?
* Las sesiones creadas con getCurrentSession() están vinculadas al hilo actual, pero las sesiones creadas con openSession() no.
* Al confirmar o revertir, use getCurrentSession() La sesión creada la sesión se cerrará automáticamente, mientras que la sesión creada usando openSession() debe cerrarse manualmente
2. Debe estar en hibernate.cfg. Si está utilizando transacciones locales (java), puede hacerlo en hibernación. Agregue la siguiente configuración al archivo cfg.xml. Si está utilizando transacciones locales (transacciones jdbc),
Los anteriores son algunos usos de hibernación , hablemos de ello a continuación La diferencia entre jdbc y jta es:
Transacciones JDBC
Las transacciones JDBC se controlan mediante el objeto Conexión. La interfaz de conexión JDBC (java.sql.Connection) proporciona dos modos de transacción: envío automático y envío manual.
# En jdbc, el modo predeterminado de operación de transacción es la confirmación automática. En otras palabras, las expresiones de actualización de la base de datos representan operaciones de transacción. Después de que la operación sea exitosa, el sistema llamará automáticamente a commit () para enviar; de lo contrario, llamará a rollback () para revertir.
# En jdbc, puede llamar a setAutoCommit(false) para desactivar la confirmación automática. Después de eso, puede usar las expresiones de múltiples operaciones de base de datos como una transacción y llamar a commit() una vez completada la operación para enviar la operación completa. Si una de las operaciones de expresión falla, commit() no se ejecutará y se enviará una respuesta. se generará una excepción; en este punto, puede revertir llamando a rollback() cuando detecte la excepción.
Esto mantendrá los datos consistentes en múltiples operaciones de actualización, como se muestra en el siguiente ejemplo:
try {
conn =
DriverManager.getConnection
("jdbc:oracle:thin:@host:1521:SID"," nombre de usuario", "userpwd";
conn.setAutoCommit(false);//deshabilitar la confirmación automática, configurar la reversión punto
stmt = conn.createStatement();
stmt.executeUpdate("alterar tabla..."); //Operación de actualización de base de datos 1
stmt .executeUpdate("insertar en la tabla ..."); //Operación de actualización de la base de datos 2
conn.commit(); //Envío de transacción
}catch(Exception ex) {
ex.printStackTrace();
intente {
conn. rollback(); //revertir si la operación no tiene éxito
}catch(Excepción e) {
e.printStackTrace()
}
}
}
Una desventaja de las transacciones JDBC es que el alcance de una transacción se limita a una única conexión de base de datos.
Transacciones JTA
Se proporciona JTA (Java Transaction API) para la plataforma J2EE. Servicio de transacciones distribuidas.
Para definir una transacción usando JTA, la aplicación necesita llamar a métodos en la interfaz javax.transaction.UserTransaction. Por ejemplo:
utx.begin(); /p >
// ...
DataSource ds = getXADataSource();
Conexión conn = ds.getConnection()
pstmt = conn. prepareStatement("ACTUALIZAR PELÍCULAS ...");
pstmt.setString(1, "Spinal Tap");
pstmt.executeUpdate(); p> // ...
utx.commit();
Centrémonos en el siguiente texto:
"Entonces, definir transacciones con JTA requiere una implementación de la interfaz javax para las interfaces .sql.XADataSource, javax.sql.XAConnection y javax.sql.XAResource. Los conductores que implementen estas interfaces podrán participar en las transacciones JTA. Los objetos XADataSource son fábricas de objetos XAConnection. Una XAConnection es una conexión JDBC que participa en una transacción JTA.
Para usar transacciones JTA, debe usar un XADataSource para generar una conexión de base de datos, y la conexión generada es una conexión XA.
La diferencia entre las conexiones XA (javax.sql.XAConnection) y las conexiones no XA (java.sql.Connection) es que XA puede participar en transacciones JTA, pero no admite la confirmación automática.
Nota:
Oracle, Sybase, DB2, SQL Server y otras bases de datos grandes solo admiten XA, que admite transacciones distribuidas.
Mi SQL ni siquiera admite transacciones locales, y mucho menos transacciones distribuidas.
El proceso de implementación de JTA:
XADataSource y XAConnection extienden un método getXAResource() a través del cual las transacciones se agregan al contenedor de transacciones para su administración. Para la persona que llama, no ve cómo se administra la transacción, simplemente declara el inicio de la transacción, le dice al contenedor que necesito la participación de la transacción en las siguientes operaciones y, finalmente, le dice que la transacción se puede confirmar o revertir aquí. , todo lo demás es caja negra.
Antes de usar JTA, primero debes implementar una clase Xid para identificar la transacción (en circunstancias normales, esto será manejado por el administrador de transacciones). Xid contiene tres elementos: formatID, gtrid (identificador de transacción global) y bqual (identificador de modificador de sucursal).
El siguiente ejemplo ilustra la implementación de Xid:
import javax.transaction.xa.*
clase pública MyXid implementa Xid
>{
protegido int formatId; <
byte protegido gtrid[];
byte protegido bqual[]; )
{
}
MyXid público(int formatId, byte gtrid[], byte bqual[])
{
this.formatId = formatId;
this.gtrid = gtrid
this.bqual = bqual; p>public int getFormatId()
{
return formatId
}
byte público[] getBranchQualifier()
{
return bqual
}
p>byte público[] getGlobalTransactionId()
{
return gtrid;
}
}
}
En segundo lugar, necesita crear datos para la base de datos que usará Fuente:
public DataSource getDataSource()
lanza SQLException
{
SQLServerDataSource xaDS = new
com .merant.datadirect.jdbcx.sqlserver.SQLServerDataSource();
xaDS.setDataSourceName("SQLServer");
xaDS.setServerName("servidor"); >
xaDS.setPortNumber(1433);
xaDS.setSelectMethod("cursor");
devuelve xaDS
}
xaDS.setPortNumber(1433);
xaDS.setSelectMethod("cursor");
devuelve xaDS; Ejemplo 1 Este es un ejemplo de confirmación de una rama de transacción utilizando el "protocolo de confirmación de dos pasos"
XADataSource xaDS
XAConnection xaCon
XAResource xaRes;
Xid xid;
Conexión con;
Conexión de estado
Conexión de estado
>ConexiónEstado ;
ConexiónEstado;
ConexiónEstado.
Declaración stmt;
int ret; >
xaDS = getDataSource();
xaCon = xaDS.getXAConnection("jdbc_user", "jdbc_password");
xaRes = xaCon.getXAResource(); con = xaCon.getConnection();
stmt = con.createStatement();
xid = new MyXid(100, nuevo byte[ ]{0x01}, nuevo byte[]{ 0x02});
prueba {
xaRes.start(xid, XAResource.TMNOFLAGS);
stmt.executeUpdate("insertar en valores de test_table ( 100) ");
xaRes.end(xid, XAResource.TMSUCCESS);