Java Persistence Frameworks

Almost every Java application needs to save data to a database and read it back. Java persistence frameworks do the heavy lifting, so you aren't writing hundreds of lines of raw JDBC code. This guide explains the main options (Hibernate, JPA, Spring Data JPA, MyBatis, jOOQ, and more), shows the same query in each, and helps you pick the right one.

What is a Java persistence framework?

"Persistence" means data that outlives your program: it's still there after a restart because it's stored in a database. A persistence framework connects your Java objects to database tables. It's like a translator between two languages: your code speaks in objects (book.getTitle()), the database speaks in rows and SQL, and the framework converts between them.

ORM vs SQL-first: the two styles

JPA vs Hibernate vs Spring Data JPA: what's the difference?

These three names confuse almost every beginner, because they're layers that work together:

A JPA entity is just a class with annotations telling the framework how it maps to a table:

import jakarta.persistence.*;

@Entity                          // this class maps to a table (named "book" by default)
public class Book {

    @Id
    @GeneratedValue              // let the database generate the id
    private Long id;

    private String title;

    @Column(name = "published_year")
    private int publishedYear;

    protected Book() { }         // JPA needs a no-argument constructor

    public Book(String title, int publishedYear) {
        this.title = title;
        this.publishedYear = publishedYear;
    }

    public String getTitle() { return title; }
    public int getPublishedYear() { return publishedYear; }
}

• @Entity — marks the class as persistent. Each object becomes one row.
• @Id and @GeneratedValue — the primary key, generated automatically.
• @Column(name = "published_year") — maps a field to a differently named column.
• jakarta.persistence — modern package name. Older code uses javax.persistence; the ideas are identical.

The main Java persistence frameworks

1. Hibernate ORM

The most widely used Java ORM and the most popular JPA implementation. It's the default persistence provider in both Spring Boot and Quarkus. Beyond standard JPA, it adds caching, batch processing, and many tuning options. hibernate.org

2. Spring Data JPA

Not an ORM itself, but the most common way Spring developers use one. Declare an interface such as BookRepository, and Spring generates methods like save, findById, and queries derived from method names. spring.io

3. MyBatis

A SQL mapper: you write the SQL (in annotations or XML files) and MyBatis maps the results to objects. Popular for complex queries, stored procedures, and databases designed long before the Java code. mybatis.org

4. jOOQ

Generates Java classes from your database schema so you can write SQL as type-safe Java code. If a column is renamed, your code stops compiling instead of failing in production. Free for open-source databases; commercial databases need a paid licence. jooq.org

5. EclipseLink

Another full JPA implementation, originally the official reference implementation of JPA. It's the default in GlassFish and Payara application servers. Because both follow the JPA standard, entity code like the Book class above works with either. eclipse.dev/eclipselink

6. Spring JDBC (JdbcClient / JdbcTemplate)

A thin, friendly layer over JDBC with no ORM. You write SQL, and Spring handles connections, parameters, and errors. JdbcClient (Spring Framework 6.1+) is the modern fluent API; JdbcTemplate is the long-standing original.

Older options you may meet in existing code

• Apache OpenJPA — another JPA implementation, historically used by Apache TomEE. Rarely chosen for new projects.
• Apache Torque — an early ORM that generates classes from an XML schema. Mostly found in legacy applications.

The same query in 5 frameworks

Here's one task, "find all books published after 2000", written in each style. Switch between them:

List<Book> books = entityManager
    .createQuery("SELECT b FROM Book b WHERE b.publishedYear > :year", Book.class)
    .setParameter("year", 2000)
    .getResultList();

public interface BookRepository extends JpaRepository<Book, Long> {
    List<Book> findByPublishedYearGreaterThan(int year);
}

// usage
List<Book> books = bookRepository.findByPublishedYearGreaterThan(2000);

@Mapper
public interface BookMapper {
    @Select("""
        SELECT id, title, published_year AS publishedYear
        FROM book WHERE published_year > #{year}
        """)
    List<Book> findNewerThan(int year);
}

List<BookRecord> books = dsl.selectFrom(BOOK)
    .where(BOOK.PUBLISHED_YEAR.gt(2000))
    .fetch();

List<Book> books = jdbcClient
    .sql("SELECT * FROM book WHERE published_year > :year")
    .param("year", 2000)
    .query(Book.class)
    .list();

Which Java persistence framework should you choose?

Comparison table

Quick recap

What's next?

Pick the web layer to go with your data layer in Java web frameworks, or turn your data into PDFs and dashboards with Java reporting frameworks.