Transaction Management

/**
 * Represents a database transaction
 */
public interface Transaction {
    /**
     * Begin the transaction
     * @throws HibernateException if transaction cannot be started
     */
    void begin();

    /**
     * Commit the transaction
     * @throws HibernateException if transaction cannot be committed
     */
    void commit();

    /**
     * Rollback the transaction
     * @throws HibernateException if transaction cannot be rolled back
     */
    void rollback();

    /**
     * Mark the transaction for rollback only
     */
    void setRollbackOnly();

    /**
     * Check if the transaction is marked for rollback only
     * @return true if marked for rollback only
     */
    boolean getRollbackOnly();

    /**
     * Check if the transaction is active
     * @return true if transaction is active
     */
    boolean isActive();

    /**
     * Get the transaction status
     * @return the current transaction status
     */
    TransactionStatus getStatus();

    // Timeout management

    /**
     * Set the transaction timeout in seconds
     * @param seconds timeout in seconds
     */
    void setTimeout(int seconds);

    /**
     * Get the transaction timeout
     * @return timeout in seconds, or -1 if not set
     */
    int getTimeout();

    // Registration callbacks

    /**
     * Register a synchronization callback
     * @param synchronization the synchronization callback
     */
    void registerSynchronization(Synchronization synchronization);
}

/**
 * Transaction status enumeration
 */
public enum TransactionStatus {
    /** Transaction not yet started */
    NOT_ACTIVE,
    /** Transaction is active */
    ACTIVE,
    /** Transaction has been committed */
    COMMITTED,
    /** Transaction has been rolled back */
    ROLLED_BACK,
    /** Transaction is marked for rollback only */
    MARKED_ROLLBACK,
    /** Transaction is committing */
    COMMITTING,
    /** Transaction is rolling back */
    ROLLING_BACK
}

/**
 * Transaction synchronization callback
 */
public interface Synchronization {
    /**
     * Called before transaction completion
     */
    void beforeCompletion();

    /**
     * Called after transaction completion
     * @param status the completion status
     */
    void afterCompletion(int status);
}

/**
 * Contract for coordinating transactions
 */
public interface TransactionCoordinator {
    /**
     * Get the current transaction
     * @return the current Transaction
     */
    Transaction getCurrentTransaction();

    /**
     * Begin a new transaction
     * @return the started Transaction
     */
    Transaction beginTransaction();

    /**
     * Check if there is an active transaction
     * @return true if transaction is active
     */
    boolean isActive();

    /**
     * Get the transaction status
     * @return current transaction status
     */
    TransactionStatus getTransactionStatus();
}

/**
 * JTA platform abstraction
 */
public interface JtaPlatform {
    /**
     * Locate the JTA TransactionManager
     * @return the TransactionManager
     */
    TransactionManager retrieveTransactionManager();

    /**
     * Locate the JTA UserTransaction
     * @return the UserTransaction
     */
    UserTransaction retrieveUserTransaction();

    /**
     * Can we register synchronizations directly with TransactionManager
     * @return true if direct registration is supported
     */
    boolean canRegisterSynchronization();

    /**
     * Register a synchronization with the current transaction
     * @param synchronization the synchronization to register
     */
    void registerSynchronization(Synchronization synchronization);

    /**
     * Get the current transaction status
     * @return the transaction status
     */
    int getCurrentStatus();
}

/**
 * Modes for releasing JDBC connections
 */
public enum ConnectionReleaseMode {
    /**
     * Release connections when transaction completes
     */
    ON_CLOSE,

    /**
     * Release connections after each statement execution
     */
    AFTER_STATEMENT,

    /**
     * Release connections after each transaction
     */
    AFTER_TRANSACTION,

    /**
     * Automatically determine release mode
     */
    AUTO
}

import org.hibernate.*;

// Manual transaction management
Session session = sessionFactory.openSession();
Transaction tx = null;

try {
    tx = session.beginTransaction();

    // Perform database operations
    User user = new User("john.doe", "John Doe");
    session.persist(user);

    // Update existing entity
    User existingUser = session.find(User.class, 123L);
    existingUser.setEmail("new.email@example.com");

    // Commit transaction
    tx.commit();

} catch (Exception e) {
    // Rollback on error
    if (tx != null && tx.isActive()) {
        tx.rollback();
    }
    throw e;
} finally {
    session.close();
}

// Automatic resource management
try (Session session = sessionFactory.openSession()) {
    Transaction tx = session.beginTransaction();

    // Database operations
    List<User> users = session.createQuery("FROM User WHERE active = true", User.class)
        .getResultList();

    for (User user : users) {
        user.setLastLoginCheck(LocalDateTime.now());
    }

    tx.commit();

} // Session automatically closed

// Execute work in a transaction
User createdUser = sessionFactory.inTransaction(session -> {
    User user = new User("jane.doe", "Jane Doe");
    session.persist(user);
    return user;
});

// Execute work in a session (manual transaction control)
List<Order> orders = sessionFactory.inSession(session -> {
    Transaction tx = session.beginTransaction();

    List<Order> result = session.createQuery(
        "FROM Order o WHERE o.status = :status", Order.class)
        .setParameter("status", OrderStatus.PENDING)
        .getResultList();

    // Perform bulk update
    session.createMutationQuery(
        "UPDATE Order SET processedDate = :date WHERE status = :status")
        .setParameter("date", LocalDateTime.now())
        .setParameter("status", OrderStatus.PENDING)
        .executeUpdate();

    tx.commit();
    return result;
});

try (Session session = sessionFactory.openSession()) {
    Transaction tx = session.beginTransaction();

    // Set transaction timeout (30 seconds)
    tx.setTimeout(30);

    try {
        // Long-running operation
        performBulkDataProcessing(session);

        // Check if we need to rollback due to business logic
        if (someBusinessCondition) {
            tx.setRollbackOnly();
        }

        // Commit if not marked for rollback
        if (!tx.getRollbackOnly()) {
            tx.commit();
        } else {
            tx.rollback();
        }

    } catch (Exception e) {
        tx.rollback();
        throw e;
    }
}

// Custom synchronization for cleanup operations
public class AuditSynchronization implements Synchronization {
    private final String operation;
    private final Long entityId;

    public AuditSynchronization(String operation, Long entityId) {
        this.operation = operation;
        this.entityId = entityId;
    }

    @Override
    public void beforeCompletion() {
        // Prepare audit log entry
        log.debug("Preparing audit log for {} on entity {}", operation, entityId);
    }

    @Override
    public void afterCompletion(int status) {
        if (status == Status.STATUS_COMMITTED) {
            // Log successful operation
            auditLogger.logOperation(operation, entityId, "SUCCESS");
        } else {
            // Log failed operation
            auditLogger.logOperation(operation, entityId, "FAILED");
        }
    }
}

// Usage
try (Session session = sessionFactory.openSession()) {
    Transaction tx = session.beginTransaction();

    User user = new User("test.user", "Test User");
    session.persist(user);

    // Register synchronization
    tx.registerSynchronization(new AuditSynchronization("CREATE_USER", user.getId()));

    tx.commit();
}

// Efficient batch processing with periodic commits
try (Session session = sessionFactory.openSession()) {
    Transaction tx = session.beginTransaction();

    int batchSize = 100;
    int count = 0;

    // Process large dataset
    try (ScrollableResults<User> results = session.createQuery("FROM User", User.class)
            .scroll(ScrollMode.FORWARD_ONLY)) {

        while (results.next()) {
            User user = results.get();

            // Process user
            user.setProcessedDate(LocalDateTime.now());
            user.setStatus(UserStatus.PROCESSED);

            // Periodic flush and commit
            if (++count % batchSize == 0) {
                session.flush();
                tx.commit();

                // Start new transaction
                tx = session.beginTransaction();
                session.clear(); // Clear first-level cache
            }
        }

        // Commit remaining items
        if (count % batchSize != 0) {
            tx.commit();
        }
    }
}

// Configuration for JTA transactions
@Configuration
public class HibernateConfig {

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource());
        em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());

        Properties props = new Properties();
        props.setProperty("hibernate.transaction.coordinator_class", "jta");
        props.setProperty("hibernate.transaction.jta.platform",
            "org.hibernate.engine.transaction.jta.platform.internal.WeblogicJtaPlatform");
        em.setJpaProperties(props);

        return em;
    }
}

// Using JTA transactions with @Transactional
@Service
@Transactional
public class UserService {

    @PersistenceContext
    private EntityManager entityManager;

    public User createUser(String username, String name) {
        // JTA transaction managed by container
        User user = new User(username, name);
        entityManager.persist(user);
        return user;
    }

    @Transactional(rollbackFor = Exception.class)
    public void updateUserBatch(List<Long> userIds) {
        for (Long userId : userIds) {
            User user = entityManager.find(User.class, userId);
            if (user != null) {
                user.setLastUpdated(LocalDateTime.now());
            }
        }
        // Transaction committed automatically
    }
}

public class TransactionalService {

    private final SessionFactory sessionFactory;
    private final int maxRetries = 3;

    public void performTransactionalOperation(Long userId) {
        int attempts = 0;

        while (attempts < maxRetries) {
            try (Session session = sessionFactory.openSession()) {
                Transaction tx = session.beginTransaction();

                try {
                    // Perform operation
                    User user = session.find(User.class, userId);
                    if (user == null) {
                        throw new EntityNotFoundException("User not found: " + userId);
                    }

                    user.incrementVersion();
                    session.merge(user);

                    tx.commit();
                    return; // Success, exit retry loop

                } catch (StaleObjectStateException | OptimisticLockException e) {
                    // Optimistic locking conflict - retry
                    tx.rollback();
                    attempts++;

                    if (attempts >= maxRetries) {
                        throw new TransactionRetryException(
                            "Failed after " + maxRetries + " attempts", e);
                    }

                    // Wait before retry (exponential backoff)
                    Thread.sleep(100 * attempts);

                } catch (Exception e) {
                    // Other errors - don't retry
                    tx.rollback();
                    throw new TransactionException("Transaction failed", e);
                }
            }
        }
    }
}

// Transaction-related configuration properties
Properties props = new Properties();

// Transaction coordinator strategy
props.setProperty("hibernate.transaction.coordinator_class", "jdbc"); // or "jta"

// JTA platform (for JTA transactions)
props.setProperty("hibernate.transaction.jta.platform",
    "org.hibernate.engine.transaction.jta.platform.internal.JBossStandAloneJtaPlatform");

// Connection release mode
props.setProperty("hibernate.connection.release_mode", "after_transaction");

// Auto-commit mode (for JDBC transactions)
props.setProperty("hibernate.connection.autocommit", "false");

// Transaction timeout (seconds)
props.setProperty("hibernate.transaction.timeout", "300");

@Configuration
@EnableTransactionManagement
public class TransactionConfig {

    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(emf);
        return transactionManager;
    }

    @Bean
    public TransactionTemplate transactionTemplate(PlatformTransactionManager txManager) {
        TransactionTemplate template = new TransactionTemplate(txManager);
        template.setTimeout(30); // 30 seconds
        template.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        return template;
    }
}