or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

exception-translation.mdhibernate-configuration.mdhibernate-transaction-management.mdindex.mdjpa-configuration.mdjpa-transaction-management.mdjpa-vendor-adapters.mdpersistence-unit-management.mdshared-resources.mdutility-classes.mdweb-integration.md
tile.json

hibernate-configuration.mddocs/

Hibernate SessionFactory Configuration

Native Hibernate SessionFactory configuration with comprehensive mapping and property configuration options.

Quick Setup

import org.hibernate.SessionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@EnableTransactionManagement
public class HibernateConfig {

    @Bean
    public LocalSessionFactoryBean sessionFactory(DataSource dataSource) {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setPackagesToScan("com.example.domain");

        Properties properties = new Properties();
        properties.put("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
        properties.put("hibernate.show_sql", "false");
        properties.put("hibernate.format_sql", "true");
        properties.put("hibernate.hbm2ddl.auto", "validate");  // validate in production
        properties.put("hibernate.jdbc.batch_size", "20");
        properties.put("hibernate.order_inserts", "true");
        properties.put("hibernate.order_updates", "true");

        sessionFactory.setHibernateProperties(properties);
        return sessionFactory;
    }
}

Configuration Examples

With Multiple Packages and Mapping Files

@Bean
public LocalSessionFactoryBean sessionFactory(DataSource dataSource) {
    LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
    sessionFactory.setDataSource(dataSource);

    // Scan multiple packages
    sessionFactory.setPackagesToScan(
        "com.example.domain",
        "com.example.entities",
        "com.example.model"
    );

    // Include XML mapping files
    sessionFactory.setMappingResources(
        "mappings/User.hbm.xml",
        "mappings/Order.hbm.xml"
    );

    Properties properties = new Properties();
    properties.put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
    properties.put("hibernate.show_sql", "true");
    properties.put("hibernate.cache.use_second_level_cache", "true");
    properties.put("hibernate.cache.region.factory_class",
        "org.hibernate.cache.jcache.JCacheRegionFactory");

    sessionFactory.setHibernateProperties(properties);
    return sessionFactory;
}

With Custom Naming Strategy

import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
import org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy;

@Bean
public LocalSessionFactoryBean sessionFactory(DataSource dataSource) {
    LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
    sessionFactory.setDataSource(dataSource);
    sessionFactory.setPackagesToScan("com.example.domain");

    // Custom naming strategy
    PhysicalNamingStrategy namingStrategy = new SpringPhysicalNamingStrategy();
    sessionFactory.setPhysicalNamingStrategy(namingStrategy);

    Properties properties = new Properties();
    properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
    sessionFactory.setHibernateProperties(properties);

    return sessionFactory;
}

With Entity Interceptor

import org.hibernate.Interceptor;
import org.hibernate.EmptyInterceptor;
import org.hibernate.type.Type;

@Bean
public LocalSessionFactoryBean sessionFactory(DataSource dataSource) {
    LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
    sessionFactory.setDataSource(dataSource);
    sessionFactory.setPackagesToScan("com.example.domain");

    // Entity interceptor for auditing
    Interceptor interceptor = new EmptyInterceptor() {
        @Override
        public boolean onSave(Object entity, Object id, Object[] state,
                             String[] propertyNames, Type[] types) {
            if (entity instanceof Auditable) {
                ((Auditable) entity).setCreatedDate(new Date());
            }
            return super.onSave(entity, id, state, propertyNames, types);
        }

        @Override
        public boolean onFlushDirty(Object entity, Object id, Object[] currentState,
                                   Object[] previousState, String[] propertyNames,
                                   Type[] types) {
            if (entity instanceof Auditable) {
                ((Auditable) entity).setModifiedDate(new Date());
            }
            return super.onFlushDirty(entity, id, currentState, previousState,
                                     propertyNames, types);
        }
    };
    sessionFactory.setEntityInterceptor(interceptor);

    Properties properties = new Properties();
    properties.put("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
    sessionFactory.setHibernateProperties(properties);

    return sessionFactory;
}

Common Hibernate Properties

Properties properties = new Properties();

// Database dialect
properties.put("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");

// SQL logging
properties.put("hibernate.show_sql", "false");
properties.put("hibernate.format_sql", "true");
properties.put("hibernate.use_sql_comments", "true");

// Schema generation (use "validate" or "none" in production)
properties.put("hibernate.hbm2ddl.auto", "validate");
// Options: none, validate, update, create, create-drop

// Connection pool (when not using external DataSource)
properties.put("hibernate.connection.pool_size", "10");

// Second-level cache
properties.put("hibernate.cache.use_second_level_cache", "true");
properties.put("hibernate.cache.use_query_cache", "true");
properties.put("hibernate.cache.region.factory_class",
    "org.hibernate.cache.jcache.JCacheRegionFactory");

// Statistics
properties.put("hibernate.generate_statistics", "true");

// JDBC batch processing
properties.put("hibernate.jdbc.batch_size", "20");
properties.put("hibernate.order_inserts", "true");
properties.put("hibernate.order_updates", "true");

// Fetch strategy
properties.put("hibernate.max_fetch_depth", "3");
properties.put("hibernate.default_batch_fetch_size", "16");

// Lazy loading
properties.put("hibernate.enable_lazy_load_no_trans", "false");

Service Layer Usage

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class ProductService {

    private final SessionFactory sessionFactory;

    public ProductService(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public Product create(String name) {
        Session session = sessionFactory.getCurrentSession();
        Product product = new Product();
        product.setName(name);
        session.persist(product);
        return product;
    }

    @Transactional(readOnly = true)
    public Product findById(Long id) {
        Session session = sessionFactory.getCurrentSession();
        return session.get(Product.class, id);
    }

    public void update(Long id, String name) {
        Session session = sessionFactory.getCurrentSession();
        Product product = session.get(Product.class, id);
        if (product != null) {
            product.setName(name);
            // Flush happens automatically on transaction commit
        }
    }

    public void delete(Long id) {
        Session session = sessionFactory.getCurrentSession();
        Product product = session.load(Product.class, id);
        session.remove(product);
    }

    @Transactional(readOnly = true)
    public List<Product> search(String namePattern) {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery(
            "from Product p where p.name like :pattern", Product.class)
            .setParameter("pattern", "%" + namePattern + "%")
            .list();
    }
}

API Reference

class LocalSessionFactoryBean {

    // DataSource configuration
    void setDataSource(DataSource dataSource);

    // Hibernate configuration files
    void setConfigLocation(Resource configLocation);
    void setConfigLocations(Resource... configLocations);

    // Mapping resources
    void setMappingResources(String... mappingResources);
    void setMappingLocations(Resource... mappingLocations);
    void setMappingJarLocations(Resource... mappingJarLocations);
    void setMappingDirectoryLocations(Resource... mappingDirectoryLocations);

    // Entity scanning
    void setPackagesToScan(String... packagesToScan);
    void setAnnotatedClasses(Class<?>... annotatedClasses);
    void setAnnotatedPackages(String... annotatedPackages);

    // Hibernate properties
    void setHibernateProperties(Properties properties);

    // Entity interceptor
    void setEntityInterceptor(Interceptor interceptor);

    // Naming strategies
    void setPhysicalNamingStrategy(PhysicalNamingStrategy strategy);
    void setImplicitNamingStrategy(ImplicitNamingStrategy strategy);

    // Multi-tenancy
    void setCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver resolver);
    void setMultiTenantConnectionProvider(MultiTenantConnectionProvider provider);

    // JTA integration
    void setJtaPlatform(JtaPlatform jtaPlatform);

    // Async bootstrap
    void setBootstrapExecutor(AsyncTaskExecutor bootstrapExecutor);

    // Access to SessionFactory
    SessionFactory getObject();
    Class<? extends SessionFactory> getObjectType();
}

LocalSessionFactoryBuilder

For programmatic configuration:

import org.springframework.orm.hibernate5.LocalSessionFactoryBuilder;
import org.springframework.core.io.ResourceLoader;

@Bean
public SessionFactory sessionFactory(DataSource dataSource, ResourceLoader resourceLoader) {
    LocalSessionFactoryBuilder builder =
        new LocalSessionFactoryBuilder(dataSource, resourceLoader);

    builder.scanPackages("com.example.domain");
    builder.addAnnotatedClasses(User.class, Order.class, Product.class);

    builder.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
    builder.setProperty("hibernate.show_sql", "true");

    return builder.buildSessionFactory();
}

DAO Pattern with Hibernate

@Repository
public class UserDao {

    private final SessionFactory sessionFactory;

    public UserDao(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    protected Session getCurrentSession() {
        return sessionFactory.getCurrentSession();
    }

    public User findById(Long id) {
        return getCurrentSession().get(User.class, id);
    }

    public void save(User user) {
        getCurrentSession().persist(user);
    }

    public void update(User user) {
        getCurrentSession().merge(user);
    }

    public void delete(User user) {
        getCurrentSession().remove(user);
    }

    public List<User> findAll() {
        return getCurrentSession()
            .createQuery("from User", User.class)
            .list();
    }
}

Related Topics

  • Hibernate Transaction Management - Transaction configuration
  • JPA Configuration - JPA alternative