Configuration Management

In Hibernate 6 (and modern Spring Boot 3 applications), the Configuration object's role has been largely absorbed by the JPA Persistence bootstrap API and Spring's auto-configuration, but it is still relevant for programmatic or non-Spring setups.

What the Configuration object does:

1. Specifies database connection settings — URL, driver, username, password, dialect.
2. Registers entity mappings — either by scanning annotated classes or by loading .hbm.xml mapping files.
3. Sets Hibernate properties — cache settings, DDL mode, batch size, etc.
4. Builds the SessionFactory — the heavyweight, application-scoped object that represents one database.

Programmatic usage (Hibernate 6, without Spring):

import org.hibernate.cfg.Configuration;
import org.hibernate.SessionFactory;

SessionFactory sessionFactory = new Configuration()
    .setProperty("hibernate.connection.url", "jdbc:postgresql://localhost/mydb")
    .setProperty("hibernate.connection.username", "user")
    .setProperty("hibernate.connection.password", "secret")
    .setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect")
    .setProperty("hibernate.hbm2ddl.auto", "validate")
    .addAnnotatedClass(Product.class)
    .addAnnotatedClass(Order.class)
    .buildSessionFactory();

In Spring Boot 3 (most common setup):

Spring Boot auto-configures Hibernate via application.properties — no Configuration object is instantiated manually:

spring.datasource.url=jdbc:postgresql://localhost/mydb
spring.datasource.username=user
spring.datasource.password=secret
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.hibernate.ddl-auto=validate

Spring's LocalContainerEntityManagerFactoryBean internally creates and manages the SessionFactory.

Interview angle: Know the Configuration API for standalone/legacy scenarios, but emphasise that in Spring Boot 3 projects it is replaced by application.properties + JPA auto-configuration. Also note hibernate.cfg.xml is an alternative to programmatic configuration.

hibernate.cfg.xml is Hibernate's primary XML configuration file for standalone (non-Spring) applications. It centralises database connection settings, dialect selection, entity mappings, and Hibernate behaviour properties in one place.

Location: Placed on the classpath root (src/main/resources/hibernate.cfg.xml).

Structure and key settings:

        org.postgresql.Driver
        jdbc:postgresql://localhost:5432/mydb
        user
        secret


        org.hibernate.dialect.PostgreSQLDialect


        validate


        true
        true


        5
        20

Loading in code:

SessionFactory sf = new Configuration()
    .configure()          // reads hibernate.cfg.xml from classpath
    .buildSessionFactory();

Hibernate 6 / Spring Boot 3 context:

Spring Boot applications do not use hibernate.cfg.xml. Spring Boot reads application.properties (or application.yml) and wires Hibernate through JPA auto-configuration. hibernate.cfg.xml is relevant for:

• Standalone Hibernate applications
• Legacy projects not yet migrated to Spring Boot
• Interview questions about Hibernate fundamentals independent of Spring

hbm2ddl.auto values — frequently asked:

• none — make no schema changes (production default)
• validate — verify schema matches mappings; fail if not
• update — add missing columns/tables (risky in production)
• create — drop and recreate schema on startup
• create-drop — create on startup, drop on SessionFactory close (for testing)

In Hibernate 6.x with Spring Boot 3.x, mapping resources are specified almost exclusively through annotations on entity classes. XML mapping files (hbm.xml) still exist but are deprecated in Hibernate 6 and rarely used in new projects.

Annotation-based mapping (current standard)

Annotate each entity with @Entity from jakarta.persistence. Spring Boot's auto-configuration scans the package tree of the main class and registers all annotated types automatically:

import jakarta.persistence.*;

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String description;
}

To control which packages are scanned, add @EntityScan to a configuration class:

@SpringBootApplication
@EntityScan("com.example.domain")
public class App { ... }

Explicit registration via LocalContainerEntityManagerFactoryBean

When configuring JPA manually (no Spring Boot auto-config), specify packages directly:

factory.setPackagesToScan("com.example.domain");

XML mapping files (legacy)

For legacy hbm.xml-based projects, register files through LocalSessionFactoryBean:

@Bean
public LocalSessionFactoryBean sessionFactory() {
    LocalSessionFactoryBean sf = new LocalSessionFactoryBean();
    sf.setMappingResources("mappings/Order.hbm.xml");
    return sf;
}

Or via hibernate.cfg.xml:

Key interview gotchas

• All JPA annotations must import from jakarta.persistence, not javax.persistence — this changed with Jakarta EE 9 and Spring Boot 3.
• hbm.xml support is deprecated in Hibernate 6 and will be removed in a future major version.
• @EntityScan and @ComponentScan are distinct — forgetting @EntityScan when entities live in a separate module is a common production bug.
• Mixing annotation and XML mapping for the same entity causes conflicts and should be avoided.

The SessionFactory is the central, heavyweight object in Hibernate's architecture. It is created once at application startup and shared across all threads for the lifetime of the application.

Primary responsibilities

• Session creation: acts as a factory for Session instances, each of which represents a single unit of work (a database conversation).
• Second-level cache host: the SessionFactory owns the second-level cache (e.g., Ehcache, Caffeine, Infinispan). Data cached at this level survives individual sessions.
• Compiled mapping metadata: all entity mappings, SQL generation, and type resolution are resolved and compiled when the SessionFactory is built — this is why construction is expensive.
• Connection pool reference: it holds a reference to the configured connection pool and delegates connection acquisition to ConnectionProvider.

SessionFactory vs EntityManagerFactory

In modern JPA-based applications (jakarta.persistence), you work with EntityManagerFactory, which is the JPA equivalent. Hibernate's SessionFactory extends EntityManagerFactory, so either API can be used:

// Pure JPA (preferred with Spring Boot 3)
EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-pu");
EntityManager em = emf.createEntityManager();

// Hibernate-native (unwrap when you need Hibernate-specific features)
SessionFactory sf = emf.unwrap(SessionFactory.class);
Session session = sf.openSession();

Spring Boot context

In a Spring Boot 3 application, SessionFactory / EntityManagerFactory is created and managed automatically by HibernateJpaAutoConfiguration. You never build it manually in typical setups:

@Autowired
private EntityManagerFactory emf;  // injected by Spring

If you need the native SessionFactory:

SessionFactory sf = emf.unwrap(SessionFactory.class);

Key interview gotchas

• SessionFactory is thread-safe and expensive to create; Session is not thread-safe and is cheap.
• Creating a new SessionFactory per request is a classic performance anti-pattern.
• In Hibernate 6, the Configuration bootstrapping API changed — the preferred approach uses StandardServiceRegistryBuilder or Spring's LocalSessionFactoryBean.
• The second-level cache is disabled by default and must be explicitly enabled via hibernate.cache.use_second_level_cache=true.

Hibernate does not include a production-grade connection pool by default (it ships with a minimal built-in pool for testing only). In real applications you integrate an external pool — HikariCP, Apache DBCP2, or c3p0 — with Hibernate either through Spring Boot auto-configuration or manual configuration.

Spring Boot 3 (recommended approach)

Spring Boot auto-configures HikariCP when it is on the classpath (it is the default pool in spring-boot-starter-data-jpa). Configure pool properties in application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=user
spring.datasource.password=secret
spring.datasource.driver-class-name=org.postgresql.Driver

# HikariCP pool tuning
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.connection-timeout=20000
spring.datasource.hikari.max-lifetime=1800000

Spring Boot wires the DataSource into the EntityManagerFactory automatically.

Manual Hibernate configuration (without Spring Boot)

Pass pool properties via hibernate.cfg.xml or programmatically. With HikariCP:

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:postgresql://localhost:5432/mydb");
config.setUsername("user");
config.setPassword("secret");
config.setMaximumPoolSize(20);
HikariDataSource ds = new HikariDataSource(config);

StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
    .applySetting(AvailableSettings.DATASOURCE, ds)
    .build();

SessionFactory sf = new MetadataSources(registry)
    .addAnnotatedClass(Order.class)
    .buildMetadata()
    .buildSessionFactory();

Key pool properties to know for interviews

Key interview gotchas

• Hibernate's built-in pool (hibernate.connection.pool_size) is documented as not suitable for production use.
• max-lifetime should always be shorter than the database's wait_timeout (MySQL) or tcp_keepalives_idle to avoid stale connections.
• With Spring Boot, do not set both spring.datasource.* and raw hibernate.connection.* properties — they conflict.
• Connection pool exhaustion under load surfaces as SQLTimeoutException / Connection is not available — a common production issue interviewers ask about.