JPA vs Hibernate — Specification vs Implementation

Direct Answer

JPA (Jakarta Persistence API) is a specification — a set of interfaces, annotations, and behavioral contracts. It has no implementation and cannot run on its own. Hibernate is the dominant JPA provider that implements the spec and adds extras: Session (extends EntityManager), HQL (superset of JPQL), @NaturalId, second-level caching, multi-tenancy, and StatelessSession. Code to JPA interfaces (jakarta.persistence.*) when you want portability — you can swap providers via configuration. Drop to org.hibernate.* only for features JPA does not cover, like natural ID lookups or scrollable batch reads. Spring Data JPA sits on top of JPA's EntityManager, so Hibernate is just the engine underneath.

Code Example

JPA is a specification in jakarta.persistence — a portable API. Hibernate is one of its implementations that adds non-standard features (second-level cache, @Formula, criteria extensions). Code that uses only JPA types is portable; code that imports org.hibernate.* is locked to Hibernate.

// ---------- 100% JPA (portable to EclipseLink, OpenJPA, DataNucleus) ----------
@Entity
@Table(name = "users")
public class User {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
    @Column(nullable = false, unique = true) private String email;

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Order> orders = new ArrayList<>();
}

@Repository
public class UserDao {
    @PersistenceContext private EntityManager em;      // JPA API
    public List<User> findByDomain(String domain) {
        return em.createQuery(
            "SELECT u FROM User u WHERE u.email LIKE :d", User.class)   // JPQL (portable)
            .setParameter("d", "%@" + domain).getResultList();
    }
}

// ---------- Hibernate-only (not portable) ----------
@Entity
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)  // Hibernate
@org.hibernate.annotations.DynamicUpdate                                        // Hibernate
public class Product {
    @Id private Long id;

    @org.hibernate.annotations.Formula("(SELECT AVG(r.stars) FROM reviews r WHERE r.product_id = id)")
    private Double avgRating;   // computed column — Hibernate extension
}

// Dropping to the native Hibernate Session:
@Autowired private EntityManager em;
Session session = em.unwrap(Session.class);
session.enableFilter("active").setParameter("flag", true);   // Hibernate filters

• Every Spring Data JPA project transitively uses Hibernate as the provider unless explicitly switched. You are already on Hibernate — the question is whether your code depends on its extensions.
• Stay in jakarta.persistence.* for 95% of code; reach for org.hibernate.* only when you need features JPA does not define (multi-tenancy filters, @Formula, @Any).
• JPA's EntityManager is a thin wrapper — em.unwrap(Session.class) gives you the Hibernate Session for advanced use without rewriting repositories.

Common Mistakes & Pitfalls

Saying 'JPA is a framework' — it's a specification with no implementation. You cannot run JPA without a provider like Hibernate, EclipseLink, or OpenJPA