JPA and Hibernate Basics

ORM (Object-Relational Mapping) maps Java classes to tables and objects to rows, so you work with Product objects instead of writing SQL and reading ResultSet columns by hand.

• Removes boilerplate: no manual mapping, connection and statement handling.
• Gives you dirty checking, caching, lazy loading, cascading and optimistic locking for free.
• Database-independent queries (JPQL) and generated SQL per dialect.
• Cost: less control over SQL; you must understand what SQL it generates (N+1, extra updates).

Stack: your code → Spring Data JPA → JPA API → Hibernate → JDBC → database. Since Jakarta EE 9 the package is jakarta.persistence.*, not javax.persistence.*.

The persistence context is the set of managed entity instances for one unit of work (usually one transaction). It works as a first-level cache and identity map: one row = one Java object inside it, and Hibernate tracks changes to those objects.

EntityManager is the JPA interface to the persistence context; Hibernate's Session extends it. Get the native API with entityManager.unwrap(Session.class).

• persist(e): makes a new object managed; the same instance becomes managed. Returns void. Throws if given a detached entity.
• merge(e): copies the state of a detached (or new) object onto a managed instance and returns that managed copy; the argument stays detached.
• Hibernate 6 deprecated save(), update() and saveOrUpdate(); use persist()/merge().
• Spring Data save(e) calls persist if the entity is new (id null or @Version null) else merge. Always use the returned object.

Product detached = new Product(1L, "Laptop");      // id set: not new
Product managed = productRepository.save(detached); // merge -> SELECT + copy
System.out.println(managed == detached);            // false

• Annotated with @Entity and has a primary key marked @Id (or @EmbeddedId).
• Has a public or protected no-arg constructor (Hibernate instantiates it by reflection).
• Should not be final, and its persistent methods should not be final, so Hibernate can create lazy proxies.
• A top-level class; records cannot be entities (they are final and immutable) but are great as DTOs/projections.

@Entity
@Table(name = "products")
public class Product {
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;

    @Column(nullable = false, length = 120)
    private String name;

    private BigDecimal price;

    protected Product() {}               // for Hibernate
    public Product(String name, BigDecimal price) { this.name = name; this.price = price; }
}