Hibernate Integration

/**
 * Hibernate ConnectionProvider implementation using HikariCP
 * Integrates with Hibernate's connection management lifecycle
 */
public class HikariConnectionProvider 
    implements ConnectionProvider, Configurable, Stoppable, ServiceRegistryAwareService {
    
    /**
     * Get connection from HikariCP pool
     * @return Connection from the pool
     * @throws SQLException if connection cannot be obtained
     */
    @Override
    public Connection getConnection() throws SQLException;
    
    /**
     * Close/return connection to pool
     * @param connection Connection to close
     * @throws SQLException if error occurs during close
     */
    @Override
    public void closeConnection(Connection connection) throws SQLException;
    
    /**
     * Check if connection provider supports aggressive connection release
     * @return true - HikariCP supports aggressive release
     */
    @Override
    public boolean supportsAggressiveRelease();
    
    /**
     * Check if connection provider is unwrappable
     * @return false - HikariConnectionProvider is not unwrappable
     */
    @Override
    public boolean isUnwrappableAs(Class<?> unwrapType);
    
    /**
     * Unwrap connection provider (not supported)
     * @throws UnknownUnwrapTypeException always thrown
     */
    @Override
    public <T> T unwrap(Class<T> unwrapType);
    
    /**
     * Configure the connection provider with Hibernate properties
     * @param configurationValues Map of configuration properties
     */
    @Override
    public void configure(Map<String, Object> configurationValues);
    
    /**
     * Initialize the connection provider with service registry
     * @param serviceRegistry Hibernate service registry
     */
    @Override
    public void injectServices(ServiceRegistryImplementor serviceRegistry);
    
    /**
     * Stop the connection provider and close HikariCP pool
     */
    @Override
    public void stop();
}

/**
 * Utility for converting Hibernate properties to HikariCP configuration
 */
public class HikariConfigurationUtil {
    
    /**
     * Load HikariCP configuration from Hibernate properties
     * @param props Map of Hibernate configuration properties  
     * @return Configured HikariConfig instance
     */
    public static HikariConfig loadConfiguration(Map<String, Object> props);
    
    /**
     * Copy Hibernate connection properties to HikariConfig
     * @param hikariConfig Target HikariConfig instance
     * @param props Source properties map
     */
    public static void copyConfigurationValues(HikariConfig hikariConfig, Map<String, Object> props);
}

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">dbuser</property>
        <property name="hibernate.connection.password">dbpass</property>
        
        <!-- HikariCP connection provider -->
        <property name="hibernate.connection.provider_class">com.zaxxer.hikari.hibernate.HikariConnectionProvider</property>
        
        <!-- HikariCP-specific settings -->
        <property name="hibernate.hikari.maximumPoolSize">20</property>
        <property name="hibernate.hikari.minimumIdle">5</property>
        <property name="hibernate.hikari.connectionTimeout">30000</property>
        <property name="hibernate.hikari.idleTimeout">600000</property>
        <property name="hibernate.hikari.maxLifetime">1800000</property>
        <property name="hibernate.hikari.leakDetectionThreshold">60000</property>
        
        <!-- DataSource properties -->
        <property name="hibernate.hikari.dataSource.cachePrepStmts">true</property>
        <property name="hibernate.hikari.dataSource.prepStmtCacheSize">250</property>
        <property name="hibernate.hikari.dataSource.prepStmtCacheSqlLimit">2048</property>
        
        <!-- Other Hibernate settings -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
        <property name="hibernate.show_sql">false</property>
        <property name="hibernate.hbm2ddl.auto">validate</property>
    </session-factory>
</hibernate-configuration>

# Database connection
hibernate.connection.driver_class=com.mysql.cj.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost:3306/mydb
hibernate.connection.username=dbuser
hibernate.connection.password=dbpass

# HikariCP connection provider
hibernate.connection.provider_class=com.zaxxer.hikari.hibernate.HikariConnectionProvider

# HikariCP pool settings
hibernate.hikari.maximumPoolSize=20
hibernate.hikari.minimumIdle=5
hibernate.hikari.connectionTimeout=30000
hibernate.hikari.idleTimeout=600000
hibernate.hikari.maxLifetime=1800000
hibernate.hikari.poolName=Hibernate-Pool
hibernate.hikari.registerMbeans=true

# DataSource properties
hibernate.hikari.dataSource.cachePrepStmts=true
hibernate.hikari.dataSource.prepStmtCacheSize=250
hibernate.hikari.dataSource.useServerPrepStmts=true

# Hibernate settings
hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
hibernate.show_sql=false
hibernate.hbm2ddl.auto=validate

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    url: jdbc:mysql://localhost:3306/mydb
    username: dbuser
    password: dbpass
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
      pool-name: SpringBoot-Pool
      register-mbeans: true
      data-source-properties:
        cachePrepStmts: true
        prepStmtCacheSize: 250
        prepStmtCacheSqlLimit: 2048
        useServerPrepStmts: true
        
  jpa:
    hibernate:
      ddl-auto: validate
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL8Dialect
        show_sql: false

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;

@Configuration
public class HibernateConfig {
    
    @Bean
    public HikariDataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("dbuser");
        config.setPassword("dbpass");
        config.setMaximumPoolSize(20);
        config.setMinimumIdle(5);
        config.setConnectionTimeout(30000);
        config.setIdleTimeout(600000);
        config.setMaxLifetime(1800000);
        config.setPoolName("Spring-Hibernate-Pool");
        config.setRegisterMbeans(true);
        
        // MySQL optimizations
        config.addDataSourceProperty("cachePrepStmts", "true");
        config.addDataSourceProperty("prepStmtCacheSize", "250");
        config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
        config.addDataSourceProperty("useServerPrepStmts", "true");
        
        return new HikariDataSource(config);
    }
    
    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan("com.myapp.entities");
        
        Properties hibernateProperties = new Properties();
        hibernateProperties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
        hibernateProperties.setProperty("hibernate.show_sql", "false");
        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", "validate");
        sessionFactory.setHibernateProperties(hibernateProperties);
        
        return sessionFactory;
    }
}

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class HibernateUtil {
    
    private static SessionFactory sessionFactory;
    
    static {
        try {
            // Create HikariCP DataSource
            HikariConfig hikariConfig = new HikariConfig();
            hikariConfig.setJdbcUrl("jdbc:postgresql://localhost:5432/mydb");
            hikariConfig.setUsername("dbuser");
            hikariConfig.setPassword("dbpass");
            hikariConfig.setMaximumPoolSize(15);
            hikariConfig.setMinimumIdle(3);
            hikariConfig.setConnectionTimeout(20000);
            hikariConfig.setIdleTimeout(300000);
            hikariConfig.setMaxLifetime(900000);
            hikariConfig.setPoolName("Hibernate-Pool");
            
            HikariDataSource dataSource = new HikariDataSource(hikariConfig);
            
            // Configure Hibernate
            Configuration configuration = new Configuration();
            
            // Use HikariConnectionProvider
            configuration.setProperty("hibernate.connection.provider_class", 
                "com.zaxxer.hikari.hibernate.HikariConnectionProvider");
            
            // Set the DataSource
            configuration.getProperties().put("hibernate.connection.datasource", dataSource);
            
            // Other Hibernate properties
            configuration.setProperty("hibernate.dialect", 
                "org.hibernate.dialect.PostgreSQL10Dialect");
            configuration.setProperty("hibernate.show_sql", "false");
            configuration.setProperty("hibernate.hbm2ddl.auto", "validate");
            
            // Add annotated classes
            configuration.addAnnotatedClass(User.class);
            configuration.addAnnotatedClass(Order.class);
            
            sessionFactory = configuration.buildSessionFactory();
            
        } catch (Exception e) {
            throw new ExceptionInInitializerError("Failed to create SessionFactory: " + e);
        }
    }
    
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    
    public static void shutdown() {
        if (sessionFactory != null) {
            sessionFactory.close();
        }
    }
}

# Pool sizing
hibernate.hikari.maximumPoolSize=20
hibernate.hikari.minimumIdle=5

# Timeouts  
hibernate.hikari.connectionTimeout=30000
hibernate.hikari.validationTimeout=5000
hibernate.hikari.idleTimeout=600000
hibernate.hikari.maxLifetime=1800000
hibernate.hikari.leakDetectionThreshold=60000

# Connection behavior
hibernate.hikari.autoCommit=true
hibernate.hikari.readOnly=false
hibernate.hikari.transactionIsolation=TRANSACTION_READ_COMMITTED
hibernate.hikari.catalog=mydb
hibernate.hikari.schema=public

# Pool management
hibernate.hikari.poolName=Hibernate-Pool
hibernate.hikari.registerMbeans=true
hibernate.hikari.allowPoolSuspension=false

# Connection testing
hibernate.hikari.connectionTestQuery=SELECT 1
hibernate.hikari.connectionInitSql=SET SESSION sql_mode = 'STRICT_TRANS_TABLES'

# DataSource properties (database-specific optimizations)
hibernate.hikari.dataSource.cachePrepStmts=true
hibernate.hikari.dataSource.prepStmtCacheSize=250
hibernate.hikari.dataSource.prepStmtCacheSqlLimit=2048
hibernate.hikari.dataSource.useServerPrepStmts=true
hibernate.hikari.dataSource.useLocalSessionState=true
hibernate.hikari.dataSource.rewriteBatchedStatements=true

import org.hibernate.Session;
import org.hibernate.Transaction;

public class UserService {
    
    public void saveUser(User user) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;
        
        try {
            transaction = session.beginTransaction();
            session.save(user);
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            throw e;
        } finally {
            session.close(); // Connection returned to HikariCP pool
        }
    }
    
    public User findUser(Long id) {
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.get(User.class, id);
        } // Connection automatically returned to pool
    }
}

import com.zaxxer.hikari.HikariDataSource;
import com.zaxxer.hikari.HikariPoolMXBean;
import org.hibernate.SessionFactory;
import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
import org.hibernate.internal.SessionFactoryImpl;

public class HibernateMonitoring {
    
    public void monitorConnectionPool(SessionFactory sessionFactory) {
        if (sessionFactory instanceof SessionFactoryImpl) {
            SessionFactoryImpl impl = (SessionFactoryImpl) sessionFactory;
            ConnectionProvider provider = impl.getServiceRegistry()
                .getService(ConnectionProvider.class);
                
            if (provider instanceof HikariConnectionProvider) {
                // Access HikariCP metrics through reflection or custom methods
                // This requires implementation-specific access
                System.out.println("Using HikariCP connection provider");
            }
        }
    }
    
    // Alternative: Monitor via JMX if registerMbeans=true
    public void monitorViaJMX() {
        try {
            MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            ObjectName poolName = new ObjectName("com.zaxxer.hikari:type=Pool (Hibernate-Pool)");
            
            Integer active = (Integer) server.getAttribute(poolName, "ActiveConnections");
            Integer idle = (Integer) server.getAttribute(poolName, "IdleConnections");
            
            System.out.printf("Hibernate Pool - Active: %d, Idle: %d%n", active, idle);
        } catch (Exception e) {
            System.err.println("Failed to access JMX metrics: " + e.getMessage());
        }
    }
}