Hibernate Deep Dive — Sessions, Caching & HQL

// Hibernate Native API
SessionFactory sessionFactory = new Configuration()
    .configure("hibernate.cfg.xml")
    .buildSessionFactory();

try (Session session = sessionFactory.openSession()) {
    Transaction tx = session.beginTransaction();
    session.persist(new Order("ORD-001", BigDecimal.valueOf(99.99)));
    tx.commit();
}

// JPA API (Spring manages this)
@PersistenceContext
private EntityManager em; // This wraps a Hibernate Session

// State transitions in code
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

// TRANSIENT: not associated with any session
Order order = new Order("ORD-001", BigDecimal.valueOf(99.99));

// PERSISTENT: managed by session, dirty checking active
session.persist(order);
order.setAmount(BigDecimal.valueOf(109.99)); // Auto-detected at flush!

// REMOVED: scheduled for DELETE
session.remove(order);

tx.commit();
session.close();

// DETACHED: session is closed, entity is no longer managed
order.setAmount(BigDecimal.valueOf(50.00)); // No effect on DB!

// Re-attach to new session
Session session2 = sessionFactory.openSession();
session2.beginTransaction();
Order managed = session2.merge(order); // PERSISTENT again
session2.getTransaction().commit();

Session session = sessionFactory.openSession();

// First call: hits database (SELECT)
Order order1 = session.get(Order.class, 1L);

// Second call: returns SAME instance from L1 cache (no SQL)
Order order2 = session.get(Order.class, 1L);

assert order1 == order2; // Same object reference! Identity guarantee.

// evict removes from L1 cache
session.evict(order1);

// Now hits database again
Order order3 = session.get(Order.class, 1L);
assert order1 != order3; // Different object

@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private BigDecimal price;

    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
    @OneToMany(mappedBy = "product", fetch = FetchType.LAZY)
    private List<Review> reviews; // Collection cache
}

// Enable query cache
// application.properties
// spring.jpa.properties.hibernate.cache.use_query_cache=true

// Mark query as cacheable
List<Product> products = session.createQuery(
        "FROM Product p WHERE p.category = :cat", Product.class)
    .setParameter("cat", "Electronics")
    .setCacheable(true)
    .setCacheRegion("product-by-category")
    .getResultList();

// HQL (Hibernate Query Language) - object-oriented SQL
List<Order> orders = session.createQuery(
    "SELECT o FROM Order o " +
    "JOIN FETCH o.customer c " +
    "WHERE c.tier = :tier AND o.total > :minTotal " +
    "ORDER BY o.createdAt DESC", Order.class)
    .setParameter("tier", CustomerTier.PREMIUM)
    .setParameter("minTotal", BigDecimal.valueOf(100))
    .setMaxResults(50)
    .getResultList();

// JPQL (JPA Query Language) - subset of HQL, portable
@Query("SELECT new com.app.dto.OrderSummary(o.id, o.total, c.name) " +
       "FROM Order o JOIN o.customer c " +
       "WHERE o.status = :status")
List<OrderSummary> findOrderSummaries(@Param("status") OrderStatus status);

// Type-safe, dynamic query building
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Order> cq = cb.createQuery(Order.class);
Root<Order> order = cq.from(Order.class);
Join<Order, Customer> customer = order.join("customer");

List<Predicate> predicates = new ArrayList<>();
if (minTotal != null) {
    predicates.add(cb.greaterThan(order.get("total"), minTotal));
}
if (status != null) {
    predicates.add(cb.equal(order.get("status"), status));
}

cq.where(predicates.toArray(new Predicate[0]));
cq.orderBy(cb.desc(order.get("createdAt")));

List<Order> results = em.createQuery(cq)
    .setMaxResults(50)
    .getResultList();

// When you need database-specific features
@Query(value = "SELECT * FROM orders o " +
               "WHERE o.created_at > NOW() - INTERVAL '7 days' " +
               "AND o.total > :minTotal " +
               "FOR UPDATE SKIP LOCKED", nativeQuery = true)
List<Order> findRecentOrdersForProcessing(@Param("minTotal") BigDecimal minTotal);

@Entity
public class Order {

    @ManyToOne(fetch = FetchType.LAZY)  // Default for @ManyToOne is EAGER!
    private Customer customer; // Loaded as proxy

    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY) // Default
    private List<OrderItem> items; // PersistentBag (lazy collection)
}

// Accessing outside session throws LazyInitializationException
Order order = orderRepository.findById(1L).orElseThrow();
// Session closes after repository call...
order.getCustomer().getName(); // LazyInitializationException!

// JOIN FETCH solution
@Query("SELECT o FROM Order o JOIN FETCH o.customer JOIN FETCH o.items WHERE o.id = :id")
Optional<Order> findByIdWithDetails(@Param("id") Long id);

// EntityGraph solution
@EntityGraph(attributePaths = {"customer", "items"})
Optional<Order> findById(Long id);

@Transactional
public void updatePrice(Long productId, BigDecimal newPrice) {
    Product product = em.find(Product.class, productId);
    product.setPrice(newPrice); // NO explicit save/update needed!
    // Hibernate detects the change and generates:
    // UPDATE product SET name=?, price=?, ... WHERE id=?
}

@Entity
@DynamicUpdate // Only include changed columns in UPDATE
@DynamicInsert // Only include non-null columns in INSERT
public class Product {
    // With @DynamicUpdate:
    // UPDATE product SET price=? WHERE id=?  (only changed column)
}

// Disable dirty checking for read-only operations
@Transactional(readOnly = true) // Skips dirty checking entirely
public List<Product> searchProducts(String keyword) {
    return productRepository.findByNameContaining(keyword);
}

@Transactional
public void importProducts(List<ProductDTO> dtos) {
    for (int i = 0; i < dtos.size(); i++) {
        Product product = mapper.toEntity(dtos.get(i));
        em.persist(product);

        if (i % 50 == 0) { // Match batch_size
            em.flush();  // Execute batched INSERTs
            em.clear();  // Release L1 cache memory
        }
    }
}

// For large batch operations where persistence context overhead is unacceptable
StatelessSession stateless = sessionFactory.openStatelessSession();
Transaction tx = stateless.beginTransaction();

ScrollableResults results = stateless.createQuery("FROM Order WHERE status = :s")
    .setParameter("s", OrderStatus.PENDING)
    .scroll(ScrollMode.FORWARD_ONLY);

int count = 0;
while (results.next()) {
    Order order = (Order) results.get(0);
    order.setStatus(OrderStatus.PROCESSING);
    stateless.update(order); // Explicit update required (no dirty checking)
    count++;
}

tx.commit();
stateless.close();
log.info("Updated {} orders", count);

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "payment_type", discriminatorType = DiscriminatorType.STRING)
public abstract class Payment {
    @Id @GeneratedValue private Long id;
    private BigDecimal amount;
    private LocalDateTime createdAt;
}

@Entity
@DiscriminatorValue("CREDIT_CARD")
public class CreditCardPayment extends Payment {
    private String cardNumber;  // NULL for other types
    private String expiryDate;
}

@Entity
@DiscriminatorValue("BANK_TRANSFER")
public class BankTransfer extends Payment {
    private String iban;        // NULL for other types
    private String bic;
}
// Single table: payment(id, amount, created_at, payment_type, card_number, expiry_date, iban, bic)

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public abstract class Payment {
    @Id @GeneratedValue private Long id;
    private BigDecimal amount;
}

@Entity
public class CreditCardPayment extends Payment {
    private String cardNumber;
    // Table: credit_card_payment(id FK, card_number)
}
// Polymorphic query: SELECT p.*, cc.* FROM payment p LEFT JOIN credit_card_payment cc ON p.id = cc.id

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public abstract class Payment {
    @Id @GeneratedValue private Long id;
    private BigDecimal amount;
}

@Entity
public class CreditCardPayment extends Payment {
    private String cardNumber;
    // Table: credit_card_payment(id, amount, card_number) -- all fields duplicated
}
// Polymorphic query: SELECT * FROM credit_card_payment UNION ALL SELECT * FROM bank_transfer ...

// BAD: N+1 queries
List<Order> orders = orderRepository.findAll(); // 1 query
for (Order order : orders) {
    order.getCustomer().getName(); // N queries (one per order)!
}

// GOOD: JOIN FETCH (1 query)
@Query("SELECT o FROM Order o JOIN FETCH o.customer")
List<Order> findAllWithCustomers();

// GOOD: @EntityGraph
@EntityGraph(attributePaths = {"customer"})
List<Order> findAll();

// GOOD: @BatchSize on collection
@OneToMany(mappedBy = "order")
@BatchSize(size = 25) // Load 25 customers per query instead of 1
private List<OrderItem> items;

session.setHibernateFlushMode(FlushMode.COMMIT); // Optimize read-heavy session