tessl/maven-org-mybatis--mybatis
SQL mapping framework that eliminates JDBC boilerplate and couples objects with stored procedures or SQL statements using XML descriptors or annotations.
—
Pending
transaction-management.mddocs/
Transaction Management
Clean abstraction over JDBC and managed transactions with support for different transaction factories and isolation levels. MyBatis provides flexible transaction management suitable for both standalone applications and managed environments.
Capabilities
Transaction Interface
Core transaction abstraction that handles database connections and transaction lifecycle.
/**
* Database transaction abstraction
*/
interface Transaction {
/** Get the underlying database connection */
Connection getConnection() throws SQLException;
/** Commit the current transaction */
void commit() throws SQLException;
/** Rollback the current transaction */
void rollback() throws SQLException;
/** Close the transaction and release resources */
void close() throws SQLException;
/** Get timeout value for the transaction */
Integer getTimeout() throws SQLException;
}TransactionFactory Interface
Factory interface for creating transaction instances with different strategies.
/**
* Factory for creating transaction instances
*/
interface TransactionFactory {
/** Set configuration properties */
void setProperties(Properties props);
/** Create transaction from existing connection */
Transaction newTransaction(Connection conn);
/** Create transaction from DataSource with isolation level and autocommit setting */
Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit);
}JDBC Transaction Management
Standard JDBC-based transaction implementation for standalone applications.
JdbcTransactionFactory
Factory for creating JDBC-based transactions.
/**
* Factory for JDBC-based transactions
*/
class JdbcTransactionFactory implements TransactionFactory {
/** Create JDBC transaction factory */
public JdbcTransactionFactory();
/** Set factory properties */
public void setProperties(Properties props);
/** Create transaction from connection */
public Transaction newTransaction(Connection conn);
/** Create transaction from DataSource */
public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit);
}JdbcTransaction
JDBC transaction implementation that manages connection lifecycle and transaction boundaries.
/**
* JDBC-based transaction implementation
*/
class JdbcTransaction implements Transaction {
/** Create JDBC transaction with DataSource */
public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit);
/** Create JDBC transaction with existing Connection */
public JdbcTransaction(Connection connection);
/** Get database connection (lazy initialization) */
public Connection getConnection() throws SQLException;
/** Commit transaction if not in autocommit mode */
public void commit() throws SQLException;
/** Rollback transaction if not in autocommit mode */
public void rollback() throws SQLException;
/** Close connection and clean up resources */
public void close() throws SQLException;
/** Get transaction timeout */
public Integer getTimeout() throws SQLException;
}Usage Examples:
// Programmatic JDBC transaction management
DataSource dataSource = new HikariDataSource(config);
TransactionFactory transactionFactory = new JdbcTransactionFactory();
// Create transaction with specific isolation level
Transaction transaction = transactionFactory.newTransaction(
dataSource,
TransactionIsolationLevel.READ_COMMITTED,
false // autoCommit = false
);
try {
Connection conn = transaction.getConnection();
// Perform database operations
PreparedStatement stmt = conn.prepareStatement("INSERT INTO users (name) VALUES (?)");
stmt.setString(1, "John Doe");
stmt.executeUpdate();
// Commit transaction
transaction.commit();
} catch (SQLException e) {
// Rollback on error
transaction.rollback();
throw e;
} finally {
transaction.close();
}Managed Transaction Management
Container-managed transaction implementation for JEE environments where transaction management is handled externally.
ManagedTransactionFactory
Factory for creating managed transactions that delegate transaction control to the container.
/**
* Factory for container-managed transactions
*/
class ManagedTransactionFactory implements TransactionFactory {
/** Create managed transaction factory */
public ManagedTransactionFactory();
/** Set factory properties */
public void setProperties(Properties props);
/** Create managed transaction from connection */
public Transaction newTransaction(Connection conn);
/** Create managed transaction from DataSource */
public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit);
}ManagedTransaction
Managed transaction implementation that assumes external transaction management.
/**
* Container-managed transaction implementation
*/
class ManagedTransaction implements Transaction {
/** Create managed transaction with DataSource */
public ManagedTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean closeConnection);
/** Create managed transaction with existing Connection */
public ManagedTransaction(Connection connection, boolean closeConnection);
/** Get database connection */
public Connection getConnection() throws SQLException;
/** No-op commit (managed by container) */
public void commit() throws SQLException;
/** No-op rollback (managed by container) */
public void rollback() throws SQLException;
/** Close connection if configured to do so */
public void close() throws SQLException;
/** Get transaction timeout */
public Integer getTimeout() throws SQLException;
}Usage Examples:
// Managed transaction configuration (typically in JEE environment)
<environments default="production">
<environment id="production">
<transactionManager type="MANAGED">
<property name="closeConnection" value="false"/>
</transactionManager>
<dataSource type="JNDI">
<property name="data_source" value="java:comp/env/jdbc/MyDataSource"/>
</dataSource>
</environment>
</environments>
// Using managed transactions with Spring
@Transactional
@Service
public class UserService {
private final UserMapper userMapper;
public UserService(UserMapper userMapper) {
this.userMapper = userMapper;
}
@Transactional(isolation = Isolation.READ_COMMITTED)
public void createUser(User user) {
// MyBatis will participate in Spring's transaction
userMapper.insert(user);
// Transaction managed by Spring
}
}Transaction Isolation Levels
Enumeration of standard transaction isolation levels with their corresponding JDBC constants.
/**
* Transaction isolation levels
*/
enum TransactionIsolationLevel {
/** No transaction isolation */
NONE(Connection.TRANSACTION_NONE),
/** Read uncommitted isolation level */
READ_UNCOMMITTED(Connection.TRANSACTION_READ_UNCOMMITTED),
/** Read committed isolation level */
READ_COMMITTED(Connection.TRANSACTION_READ_COMMITTED),
/** Repeatable read isolation level */
REPEATABLE_READ(Connection.TRANSACTION_REPEATABLE_READ),
/** Serializable isolation level */
SERIALIZABLE(Connection.TRANSACTION_SERIALIZABLE);
/** Get JDBC isolation level constant */
public int getLevel();
}Usage Examples:
// Configure different isolation levels per operation
public interface OrderMapper {
// Read operations with lower isolation for better performance
@Select("SELECT * FROM orders WHERE id = #{id}")
@Options(isolation = IsolationLevel.READ_COMMITTED)
Order findById(@Param("id") Long id);
// Write operations with higher isolation for consistency
@Insert("INSERT INTO orders (customer_id, total) VALUES (#{customerId}, #{total})")
@Options(isolation = IsolationLevel.SERIALIZABLE)
int insert(Order order);
}
// Programmatic isolation level setting
try (SqlSession session = sqlSessionFactory.openSession(TransactionIsolationLevel.REPEATABLE_READ)) {
OrderMapper mapper = session.getMapper(OrderMapper.class);
Order order = mapper.findById(orderId);
// Operations within this session use REPEATABLE_READ isolation
order.setStatus("PROCESSED");
mapper.update(order);
session.commit();
}Environment Configuration
Configuration of database environments with transaction management settings.
/**
* Database environment configuration
*/
class Environment {
/** Create environment with ID, transaction factory, and data source */
public Environment(String id, TransactionFactory transactionFactory, DataSource dataSource);
/** Get environment ID */
public String getId();
/** Get transaction factory */
public TransactionFactory getTransactionFactory();
/** Get data source */
public DataSource getDataSource();
/** Environment builder for programmatic configuration */
public static class Builder {
public Builder(String id);
public Builder transactionFactory(TransactionFactory transactionFactory);
public Builder dataSource(DataSource dataSource);
public Environment build();
}
}Usage Examples:
// Programmatic environment configuration
DataSource dataSource = new HikariDataSource(hikariConfig);
TransactionFactory transactionFactory = new JdbcTransactionFactory();
Environment environment = new Environment.Builder("production")
.transactionFactory(transactionFactory)
.dataSource(dataSource)
.build();
Configuration configuration = new Configuration(environment);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(configuration);
// XML environment configuration
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">
<property name="autoCommit" value="false"/>
</transactionManager>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
<property name="username" value="user"/>
<property name="password" value="password"/>
</dataSource>
</environment>
<environment id="production">
<transactionManager type="MANAGED">
<property name="closeConnection" value="false"/>
</transactionManager>
<dataSource type="JNDI">
<property name="data_source" value="java:comp/env/jdbc/MyDB"/>
</dataSource>
</environment>
</environments>Transaction Lifecycle Management
Understanding transaction boundaries and lifecycle in different scenarios.
// Manual transaction management
try (SqlSession session = sqlSessionFactory.openSession(false)) { // autoCommit = false
try {
UserMapper userMapper = session.getMapper(UserMapper.class);
OrderMapper orderMapper = session.getMapper(OrderMapper.class);
// Multiple operations in single transaction
User user = new User("John", "john@example.com");
userMapper.insert(user);
Order order = new Order(user.getId(), new BigDecimal("99.99"));
orderMapper.insert(order);
// Commit all operations together
session.commit();
} catch (Exception e) {
// Rollback on any error
session.rollback();
throw e;
}
}
// Batch operations with transaction management
try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH, false)) {
UserMapper mapper = session.getMapper(UserMapper.class);
try {
// Batch multiple operations
for (User user : userList) {
mapper.insert(user);
}
// Execute batch and commit
List<BatchResult> results = session.flushStatements();
session.commit();
// Process batch results
for (BatchResult result : results) {
System.out.println("Batch affected " + Arrays.toString(result.getUpdateCounts()) + " rows");
}
} catch (Exception e) {
session.rollback();
throw e;
}
}Savepoint Support
Advanced transaction management with savepoints for partial rollbacks.
// Using savepoints for complex transaction management
try (SqlSession session = sqlSessionFactory.openSession(false)) {
Connection conn = session.getConnection();
UserMapper userMapper = session.getMapper(UserMapper.class);
OrderMapper orderMapper = session.getMapper(OrderMapper.class);
try {
// Create savepoint before risky operation
Savepoint savepoint1 = conn.setSavepoint("beforeUserInsert");
User user = new User("John", "john@example.com");
userMapper.insert(user);
// Another savepoint
Savepoint savepoint2 = conn.setSavepoint("beforeOrderInsert");
try {
Order order = new Order(user.getId(), new BigDecimal("99.99"));
orderMapper.insert(order);
} catch (Exception e) {
// Rollback to savepoint2, keeping user insert
conn.rollback(savepoint2);
System.out.println("Order insert failed, but user insert preserved");
}
// Commit entire transaction
session.commit();
} catch (Exception e) {
// Full rollback
session.rollback();
throw e;
}
}Types
/**
* Transaction-related exceptions
*/
class TransactionException extends PersistenceException {
public TransactionException(String message);
public TransactionException(String message, Throwable cause);
}
/**
* Transaction manager types for XML configuration
*/
enum TransactionManagerType {
/** JDBC transaction manager */
JDBC("JDBC"),
/** Managed transaction manager */
MANAGED("MANAGED");
public String getValue();
}
/**
* Transaction isolation annotation for method-level configuration
*/
@interface Transactional {
/** Transaction isolation level */
TransactionIsolationLevel isolation() default TransactionIsolationLevel.READ_COMMITTED;
/** Transaction propagation behavior */
Propagation propagation() default Propagation.REQUIRED;
/** Transaction timeout in seconds */
int timeout() default -1;
/** Read-only transaction hint */
boolean readOnly() default false;
}Install with Tessl CLI
npx tessl i tessl/maven-org-mybatis--mybatis