Persistence and Services: JPA, Transactions and Lazy Loading

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence" version="3.2">
    <persistence-unit name="bookshelf" transaction-type="JTA">
        <jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source>
        <class>org.example.bookshelf.jpa.AuthorEntity</class>
        <class>org.example.bookshelf.jpa.BookEntity</class>
        <class>org.example.bookshelf.jpa.ReviewEntity</class>
        <properties>
            <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
            <property name="hibernate.generate_statistics" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence" version="3.2">
    <persistence-unit name="bookshelf" transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <class>org.example.bookshelf.jpa.AuthorEntity</class>
        <class>org.example.bookshelf.jpa.BookEntity</class>
        <class>org.example.bookshelf.jpa.ReviewEntity</class>
        <properties>
            <property name="hibernate.generate_statistics" value="true"/>
            <property name="hibernate.show_sql" value="false"/>
        </properties>
    </persistence-unit>
</persistence>

<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>
  <groupId>x</groupId>
  <artifactId>g9libs</artifactId>
  <version>1</version>
  <dependencies>
    <dependency>
      <groupId>org.hibernate.orm</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>7.4.12.Final</version>
    </dependency>
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <version>2.4.240</version>
    </dependency>
    <dependency>
      <groupId>jakarta.data</groupId>
      <artifactId>jakarta.data-api</artifactId>
      <version>1.0.1</version>
    </dependency>
    <dependency>
      <groupId>jakarta.transaction</groupId>
      <artifactId>jakarta.transaction-api</artifactId>
      <version>2.0.1</version>
    </dependency>
  </dependencies>
</project>

package org.example.bookshelf.jpa;

import jakarta.annotation.PreDestroy;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.context.Initialized;
import jakarta.enterprise.context.RequestScoped;
import jakarta.enterprise.event.Observes;
import jakarta.enterprise.inject.Disposes;
import jakarta.enterprise.inject.Produces;
import jakarta.inject.Inject;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;
import java.util.HashMap;
import java.util.Map;
import org.hibernate.SessionFactory;
import org.hibernate.stat.Statistics;

/**
 * Plain-Tomcat plumbing: one EntityManagerFactory for the application and one EntityManager per request.
 * On a Jakarta EE server this class is replaced by a container-managed persistence context.
 */
@ApplicationScoped
public class PersistenceResources {

    private EntityManagerFactory emf;

    @Inject
    SeedData seed;

    void start(@Observes @Initialized(ApplicationScoped.class) Object init) {
        Map<String, Object> props = new HashMap<>();
        props.put("jakarta.persistence.jdbc.url", System.getProperty("bookshelf.jdbc.url", "jdbc:h2:mem:bookshelf;DB_CLOSE_DELAY=-1"));
        props.put("hibernate.hbm2ddl.auto", "create-drop");
        emf = Persistence.createEntityManagerFactory("bookshelf", props);
        seed.populate(emf);
    }

    @Produces
    @RequestScoped
    EntityManager entityManager() {
        return emf.createEntityManager();
    }

    void close(@Disposes EntityManager em) {
        if (em.isOpen()) {
            em.close();
        }
    }

    public Statistics statistics() {
        return emf.unwrap(SessionFactory.class).getStatistics();
    }

    @PreDestroy
    void stop() {
        if (emf != null) {
            emf.close();
        }
    }
}

package org.example.bookshelf.jpa;

import jakarta.annotation.Priority;
import jakarta.inject.Inject;
import jakarta.interceptor.AroundInvoke;
import jakarta.interceptor.Interceptor;
import jakarta.interceptor.InvocationContext;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityTransaction;
import jakarta.transaction.Transactional;

/**
 * A minimal resource-local implementation of jakarta.transaction.Transactional for a container that has no
 * transaction manager (Tomcat): TxType.REQUIRED only, rollback on runtime exceptions and errors.
 */
@Transactional
@Interceptor
@Priority(Interceptor.Priority.PLATFORM_BEFORE + 200)
public class ResourceLocalTransactionInterceptor {

    @Inject
    EntityManager em;

    @AroundInvoke
    Object around(InvocationContext ctx) throws Exception {
        EntityTransaction tx = em.getTransaction();
        if (tx.isActive()) {
            return ctx.proceed();
        }
        tx.begin();
        try {
            Object result = ctx.proceed();
            tx.commit();
            detachUnlessOpenInView();
            return result;
        } catch (RuntimeException | Error e) {
            if (tx.isActive()) {
                tx.rollback();
            }
            detachUnlessOpenInView();
            throw e;
        } catch (Exception checked) {
            tx.commit();
            detachUnlessOpenInView();
            throw checked;
        }
    }

    /** A container-managed, transaction-scoped context ends with the transaction; keeping it open is open-session-in-view. */
    private void detachUnlessOpenInView() {
        if (!Boolean.getBoolean("bookshelf.osiv")) {
            em.clear();
        }
    }
}

    @Transactional
    public void renameThenFail(long id, String title, String how) throws CatalogueException {
        em.find(BookEntity.class, id).setTitle(title);
        em.flush();
        switch (how) {
            case "runtime" -> throw new IllegalStateException("runtime failure");
            case "checked" -> throw new CatalogueException("checked failure");
            default -> { }
        }
    }

    @Transactional(rollbackOn = CatalogueException.class)
    public void renameThenFailRollingBack(long id, String title) throws CatalogueException {
        em.find(BookEntity.class, id).setTitle(title);
        em.flush();
        throw new CatalogueException("checked failure with rollbackOn");
    }

package org.example.bookshelf.service;

/** A checked business exception: unless the annotation says otherwise, a Jakarta Transactions interceptor commits when it escapes. */
public class CatalogueException extends Exception {
    public CatalogueException(String message) {
        super(message);
    }
}

package org.example.bookshelf.data;

import jakarta.ejb.Stateless;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.example.bookshelf.jpa.BookEntity;
import org.example.bookshelf.service.CatalogueException;

@Stateless
public class CatalogueEjb {

    @PersistenceContext
    EntityManager em;

    public long count() {
        return em.createQuery("select count(b) from BookEntity b", Long.class).getSingleResult();
    }

    public void renameThenFail(long id, String title, String how) throws CatalogueException {
        em.find(BookEntity.class, id).setTitle(title);
        em.flush();
        switch (how) {
            case "runtime" -> throw new IllegalStateException("runtime failure");
            case "checked" -> throw new CatalogueException("checked failure");
            case "app" -> throw new CatalogueRejectedException("application exception with rollback");
            default -> { }
        }
    }
}

package org.example.bookshelf.data;

import jakarta.ejb.ApplicationException;

/** A business failure that reaches the caller unwrapped and still rolls the container transaction back. */
@ApplicationException(rollback = true)
public class CatalogueRejectedException extends RuntimeException {
    public CatalogueRejectedException(String message) {
        super(message);
    }
}

    @Transactional
    public List<BookSummary> summaries() {
        return em.createQuery("""
                select new org.example.bookshelf.model.BookSummary(b.id, b.title, a.name, b.year, b.available)
                from BookEntity b join b.author a order by b.title
                """, BookSummary.class)
            .getResultList();
    }

    @Transactional
    public BookDetail detail(long id) {
        BookEntity b = em.createQuery("""
                select b from BookEntity b join fetch b.author left join fetch b.reviews where b.id = :id
                """, BookEntity.class)
            .setParameter("id", id)
            .getSingleResult();
        List<ReviewView> reviews = b.getReviews().stream().map(r -> new ReviewView(r.getRating(), r.getText())).toList();
        return new BookDetail(b.getId(), b.getTitle(), b.getAuthor().getName(), b.getYear(), reviews);
    }

package org.example.bookshelf.model;

import java.io.Serializable;
/** What a list row needs: five values, no association, nothing lazy. */
public record BookSummary(long id, String title, String authorName, int year, boolean available) implements Serializable {
}

package org.example.bookshelf.model;

import java.io.Serializable;
import java.io.Serializable;
import java.util.List;

/** What the details page needs, copied out of the entities while the transaction is still open. */
public record BookDetail(long id, String title, String authorName, int year, List<ReviewView> reviews) implements Serializable {
}

package org.example.bookshelf.model;

import java.io.Serializable;
public record ReviewView(int rating, String text) implements Serializable {
}

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="jakarta.faces.html"
      xmlns:ui="jakarta.faces.facelets">
<ui:composition template="/WEB-INF/templates/layout.xhtml">
  <ui:define name="title">Summaries in the view</ui:define>
  <ui:define name="content">
    <h1>Catalogue</h1>
    <ul>
      <ui:repeat value="#{queryLab.summaries}" var="book">
        <li>#{book.title} by #{book.authorName} (#{book.year})</li>
      </ui:repeat>
    </ul>
  </ui:define>
</ui:composition>
</html>

    @Transactional
    public List<BookEntity> findAllEntities() {
        return em.createQuery("select b from BookEntity b order by b.title", BookEntity.class).getResultList();
    }

    @Transactional
    public List<BookEntity> findAllEntitiesFetchingAuthor() {
        return em.createQuery("select b from BookEntity b join fetch b.author order by b.title", BookEntity.class)
            .getResultList();
    }

    @Transactional
    public List<BookEntity> findAllEntitiesWithGraph() {
        EntityGraph<BookEntity> graph = em.createEntityGraph(BookEntity.class);
        graph.addAttributeNodes("author", "reviews");
        return em.createQuery("select distinct b from BookEntity b order by b.title", BookEntity.class)
            .setHint("jakarta.persistence.fetchgraph", graph)
            .getResultList();
    }

package org.example.bookshelf.web;

import jakarta.annotation.PostConstruct;
import jakarta.faces.view.ViewScoped;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import java.io.Serializable;
import java.util.List;
import org.example.bookshelf.model.BookSummary;
import org.example.bookshelf.model.PageSlice;
import org.example.bookshelf.service.BookService;

/** A plain h:dataTable paged against the database: one count and one page query per page change. */
@Named("pager")
@ViewScoped
public class PagerBean implements Serializable {

    private static final int SIZE = 5;

    @Inject
    BookService books;

    private int first;
    private String sort = "title";
    private boolean ascending = true;
    private String titleContains;
    private PageSlice<BookSummary> slice;

    @PostConstruct
    void init() {
        reload();
    }

    public String search() {
        first = 0;
        reload();
        return null;
    }

    public String next() {
        if (first + SIZE < slice.total()) {
            first += SIZE;
            reload();
        }
        return null;
    }

    public String previous() {
        first = Math.max(0, first - SIZE);
        reload();
        return null;
    }

    public String sortBy(String key) {
        ascending = !key.equals(sort) || !ascending;
        sort = key;
        first = 0;
        reload();
        return null;
    }

    private void reload() {
        slice = books.page(first, SIZE, sort, ascending, titleContains);
    }

    public List<BookSummary> getRows() { return slice.content(); }
    public long getTotal() { return slice.total(); }
    public int getFrom() { return slice.total() == 0 ? 0 : first + 1; }
    public int getTo() { return (int) Math.min(slice.total(), first + SIZE); }
    public boolean isHasPrevious() { return first > 0; }
    public boolean isHasNext() { return first + SIZE < slice.total(); }
    public String getTitleContains() { return titleContains; }
    public void setTitleContains(String titleContains) { this.titleContains = titleContains; }
}

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="jakarta.faces.html"
      xmlns:f="jakarta.faces.core"
      xmlns:ui="jakarta.faces.facelets">
<ui:composition template="/WEB-INF/templates/layout.xhtml">
  <ui:define name="title">Catalogue</ui:define>
  <ui:define name="content">
    <h:form id="form">
      <h:inputText id="q" value="#{pager.titleContains}"/>
      <h:commandButton id="find" value="Search" action="#{pager.search}"/>
      <h:dataTable id="books" value="#{pager.rows}" var="book">
        <h:column>
          <f:facet name="header">
            <h:commandLink id="byTitle" value="Title" action="#{pager.sortBy('title')}"/>
          </f:facet>
          #{book.title}
        </h:column>
        <h:column>
          <f:facet name="header">
            <h:commandLink id="byAuthor" value="Author" action="#{pager.sortBy('authorName')}"/>
          </f:facet>
          #{book.authorName}
        </h:column>
        <h:column>
          <f:facet name="header">
            <h:commandLink id="byYear" value="Year" action="#{pager.sortBy('year')}"/>
          </f:facet>
          #{book.year}
        </h:column>
      </h:dataTable>
      <h:commandButton id="prev" value="Previous" action="#{pager.previous}" disabled="#{not pager.hasPrevious}"/>
      <h:outputText id="range" value="#{pager.from}-#{pager.to} of #{pager.total}"/>
      <h:commandButton id="next" value="Next" action="#{pager.next}" disabled="#{not pager.hasNext}"/>
    </h:form>
  </ui:define>
</ui:composition>
</html>

package org.example.bookshelf.web;

import java.util.List;
import java.util.Map;
import org.example.bookshelf.model.BookSummary;
import org.example.bookshelf.service.BookService;
import org.primefaces.model.FilterMeta;
import org.primefaces.model.LazyDataModel;
import org.primefaces.model.SortMeta;

/** Translates the table's page, sort and filter state into one count and one page query. */
public class BookLazyModel extends LazyDataModel<BookSummary> {

    private final transient BookService books;

    public BookLazyModel(BookService books) {
        this.books = books;
    }

    @Override
    public int count(Map<String, FilterMeta> filterBy) {
        return (int) books.count(filterText(filterBy));
    }

    @Override
    public List<BookSummary> load(int first, int pageSize, Map<String, SortMeta> sortBy, Map<String, FilterMeta> filterBy) {
        String key = "title";
        boolean ascending = true;
        if (!sortBy.isEmpty()) {
            SortMeta sort = sortBy.values().iterator().next();
            key = sort.getField();
            ascending = sort.getOrder().isAscending();
        }
        return books.findPage(first, pageSize, key, ascending, filterText(filterBy));
    }

    @Override
    public String getRowKey(BookSummary row) {
        return String.valueOf(row.id());
    }

    private static String filterText(Map<String, FilterMeta> filterBy) {
        FilterMeta meta = filterBy.get("title");
        return meta == null || meta.getFilterValue() == null ? null : String.valueOf(meta.getFilterValue());
    }
}

package org.example.bookshelf.web;

import jakarta.annotation.PostConstruct;
import jakarta.faces.view.ViewScoped;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import java.io.Serializable;
import org.example.bookshelf.model.BookSummary;
import org.example.bookshelf.service.BookService;
import org.primefaces.model.LazyDataModel;

@Named("pagedCatalogue")
@ViewScoped
public class PagedCatalogueBean implements Serializable {

    @Inject
    BookService books;

    private LazyDataModel<BookSummary> model;

    @PostConstruct
    void init() {
        model = new BookLazyModel(books);
    }

    public LazyDataModel<BookSummary> getModel() {
        return model;
    }
}

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="jakarta.faces.html"
      xmlns:f="jakarta.faces.core"
      xmlns:ui="jakarta.faces.facelets"
      xmlns:p="primefaces">
<ui:composition template="/WEB-INF/templates/layout.xhtml">
  <ui:define name="title">Paged catalogue</ui:define>
  <ui:define name="content">
    <h:form id="form">
      <p:dataTable id="books" value="#{pagedCatalogue.model}" var="book" lazy="true" rowKey="#{book.id}"
                   paginator="true" rows="5" rowsPerPageTemplate="5,10" sortMode="single" emptyMessage="No books match">
        <p:column headerText="Title" field="title" filterMatchMode="contains"/>
        <p:column headerText="Author" field="authorName"/>
        <p:column headerText="Year" field="year"/>
      </p:dataTable>
    </h:form>
  </ui:define>
</ui:composition>
</html>

package org.example.bookshelf.data;

import jakarta.data.Order;
import jakarta.data.page.CursoredPage;
import jakarta.data.page.Page;
import jakarta.data.page.PageRequest;
import jakarta.data.repository.Find;
import jakarta.data.repository.OrderBy;
import jakarta.data.repository.Query;
import jakarta.data.repository.Repository;
import jakarta.data.repository.Save;
import jakarta.transaction.Transactional;
import java.util.Optional;
import org.example.bookshelf.jpa.BookEntity;
import org.example.bookshelf.model.BookSummary;

@Transactional
@Repository
public interface Books {

    @Find
    Optional<BookEntity> byId(Long id);

    @Find
    @OrderBy("title")
    Page<BookEntity> availability(boolean available, PageRequest pageRequest, Order<BookEntity> order);

    @Query("select new org.example.bookshelf.model.BookSummary(b.id, b.title, b.author.name, b.year, b.available) from BookEntity b where lower(b.title) like :pattern order by b.title")
    Page<BookSummary> search(String pattern, PageRequest pageRequest);

    @Find
    @OrderBy("year")
    @OrderBy("id")
    CursoredPage<BookEntity> byYearCursor(boolean available, PageRequest pageRequest, Order<BookEntity> order);

    @Save
    BookEntity save(BookEntity book);
}

package org.example.bookshelf.web;

import jakarta.data.page.CursoredPage;
import jakarta.data.page.Page;
import jakarta.data.page.PageRequest;
import jakarta.enterprise.context.RequestScoped;
import jakarta.faces.context.FacesContext;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import org.example.bookshelf.data.Books;
import org.example.bookshelf.model.BookSummary;

@Named("dataLab")
@RequestScoped
public class DataLabBean {

    @Inject
    Books books;

    @Inject
    FacesContext facesContext;

    private String outcome;

    public void run() {
        int page = Integer.parseInt(facesContext.getExternalContext().getRequestParameterMap().getOrDefault("page", "1"));
        Page<BookSummary> found = books.search("%book%", PageRequest.ofPage(page).size(5));
        CursoredPage<org.example.bookshelf.jpa.BookEntity> c1 = books.byYearCursor(true, PageRequest.ofSize(4), jakarta.data.Order.by());
        CursoredPage<org.example.bookshelf.jpa.BookEntity> c2 = c1.hasNext() ? books.byYearCursor(true, c1.nextPageRequest(), jakarta.data.Order.by()) : c1;
        String lazy;
        try {
            lazy = books.byId(1L).get().getAuthor().getName();
        } catch (RuntimeException e) {
            lazy = e.getClass().getSimpleName() + ": " + e.getMessage();
        }
        outcome = "lazy author: " + lazy + " | " + "page=" + found.pageRequest().page() + " rows=" + found.numberOfElements() + " total=" + found.totalElements()
            + " totalPages=" + found.totalPages() + " first=" + found.content().get(0).title()
            + " | cursor1=" + c1.content().stream().map(b -> b.getTitle()).toList()
            + " cursor2=" + c2.content().stream().map(b -> b.getTitle()).toList();
    }

    public String getOutcome() { return outcome; }
}