Add Hibernate 7 batches 2-6, batch 7, and batch 8: mapping styles, JPA annotations, natural IDs, @Immutable, stored procedures, in-memory test databases, JNDI mocking, proxies, associations, temporal mapping, named queries, HQL, Criteria API, EntityManager bootstrapping, Ehcache 3 L2 cache configuration, HikariCP connection pooling, Hibernate Validator CDI integration, aggregate functions, sorting, pagination, interceptors, and Hibernate Search 8 (Hibernate 7.4.5.Final + Spring Boot 4.1.1 + JDK 25)

src/main/java/com/ankurm/hibernatedemo/association/AssocAuthor.java

@@ -0,0 +1,53 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.NamedEntityGraph;
+import jakarta.persistence.NamedAttributeNode;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Plain (non-batched) author used for the N+1 / fetch-join / entity-graph comparison in
+ * docs/12-association-mappings.md, chapter "Counting the N+1". No {@code @BatchSize} here on
+ * purpose — {@link BatchAuthor} is the batched twin used for the fourth number.
+ */
+@Entity
+@Table(name = "assoc_author")
+@NamedEntityGraph(name = "AssocAuthor.books", attributeNodes = @NamedAttributeNode("books"))
+public class AssocAuthor {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String name;
+
+    @OneToMany(mappedBy = "author", cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
+    private List<AssocBook> books = new ArrayList<>();
+
+    protected AssocAuthor() {
+    }
+
+    public AssocAuthor(String name) {
+        this.name = name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<AssocBook> getBooks() {
+        return books;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/AssocBook.java

@@ -0,0 +1,50 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+/** Owning side (holds the FK) of {@link AssocAuthor#getBooks()}. Docs: 12-association-mappings.md. */
+@Entity
+@Table(name = "assoc_book")
+public class AssocBook {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String title;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "author_id")
+    private AssocAuthor author;
+
+    protected AssocBook() {
+    }
+
+    public AssocBook(String title, AssocAuthor author) {
+        this.title = title;
+        this.author = author;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public AssocAuthor getAuthor() {
+        return author;
+    }
+
+    public void setAuthor(AssocAuthor author) {
+        this.author = author;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/BagAuthorList.java

@@ -0,0 +1,53 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Deliberately has TWO {@code List} (bag) collections so that fetch-joining both in one JPQL
+ * query reproduces {@code org.hibernate.loader.MultipleBagFetchException}. Docs: 12-association-mappings.md,
+ * chapter "MultipleBagFetchException".
+ */
+@Entity
+@Table(name = "bag_author_list")
+public class BagAuthorList {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String name;
+
+    @OneToMany(mappedBy = "author", cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
+    private List<BagBookL> books = new ArrayList<>();
+
+    @OneToMany(mappedBy = "author", cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
+    private List<BagAwardL> awards = new ArrayList<>();
+
+    protected BagAuthorList() {
+    }
+
+    public BagAuthorList(String name) {
+        this.name = name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public List<BagBookL> getBooks() {
+        return books;
+    }
+
+    public List<BagAwardL> getAwards() {
+        return awards;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/BagAuthorSet.java

@@ -0,0 +1,53 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Same shape as {@link BagAuthorList} but with {@code Set} collections — fetch-joining
+ * both does NOT throw {@code MultipleBagFetchException} (that is Fix #1), but it does reproduce
+ * the cartesian-product row explosion: one SQL row per (book, award) pair per author.
+ */
+@Entity
+@Table(name = "bag_author_set")
+public class BagAuthorSet {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String name;
+
+    @OneToMany(mappedBy = "author", cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
+    private Set<BagBookS> books = new HashSet<>();
+
+    @OneToMany(mappedBy = "author", cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
+    private Set<BagAwardS> awards = new HashSet<>();
+
+    protected BagAuthorSet() {
+    }
+
+    public BagAuthorSet(String name) {
+        this.name = name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public Set<BagBookS> getBooks() {
+        return books;
+    }
+
+    public Set<BagAwardS> getAwards() {
+        return awards;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/BagAwardL.java

@@ -0,0 +1,37 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "bag_award_l")
+public class BagAwardL {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String name;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "author_id")
+    private BagAuthorList author;
+
+    protected BagAwardL() {
+    }
+
+    public BagAwardL(String name, BagAuthorList author) {
+        this.name = name;
+        this.author = author;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/BagAwardS.java

@@ -0,0 +1,37 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "bag_award_s")
+public class BagAwardS {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String name;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "author_id")
+    private BagAuthorSet author;
+
+    protected BagAwardS() {
+    }
+
+    public BagAwardS(String name, BagAuthorSet author) {
+        this.name = name;
+        this.author = author;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/BagBookL.java

@@ -0,0 +1,37 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "bag_book_l")
+public class BagBookL {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String title;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "author_id")
+    private BagAuthorList author;
+
+    protected BagBookL() {
+    }
+
+    public BagBookL(String title, BagAuthorList author) {
+        this.title = title;
+        this.author = author;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/BagBookS.java

@@ -0,0 +1,37 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "bag_book_s")
+public class BagBookS {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String title;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "author_id")
+    private BagAuthorSet author;
+
+    protected BagBookS() {
+    }
+
+    public BagBookS(String title, BagAuthorSet author) {
+        this.title = title;
+        this.author = author;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/BatchAuthor.java

@@ -0,0 +1,47 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import java.util.ArrayList;
+import java.util.List;
+import org.hibernate.annotations.BatchSize;
+
+/**
+ * Same shape as {@link AssocAuthor} but the {@code books} collection carries
+ * {@code @BatchSize(size = 10)} — the fourth number in the N+1 comparison table.
+ */
+@Entity
+@Table(name = "batch_author")
+public class BatchAuthor {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String name;
+
+    @BatchSize(size = 10)
+    @OneToMany(mappedBy = "author", cascade = CascadeType.PERSIST, fetch = FetchType.LAZY)
+    private List<BatchBook> books = new ArrayList<>();
+
+    protected BatchAuthor() {
+    }
+
+    public BatchAuthor(String name) {
+        this.name = name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public List<BatchBook> getBooks() {
+        return books;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/BatchBook.java

@@ -0,0 +1,37 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "batch_book")
+public class BatchBook {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String title;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "author_id")
+    private BatchAuthor author;
+
+    protected BatchBook() {
+    }
+
+    public BatchBook(String title, BatchAuthor author) {
+        this.title = title;
+        this.author = author;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/CascadeAuthor.java

@@ -0,0 +1,55 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * {@code cascade = ALL, orphanRemoval = true}: the "developer did not expect this" cascade
+ * trap. Docs: 12-association-mappings.md, chapter "Cascade and orphanRemoval".
+ */
+@Entity
+@Table(name = "cascade_author")
+public class CascadeAuthor {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String name;
+
+    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY)
+    private List<CascadeBook> books = new ArrayList<>();
+
+    protected CascadeAuthor() {
+    }
+
+    public CascadeAuthor(String name) {
+        this.name = name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public List<CascadeBook> getBooks() {
+        return books;
+    }
+
+    /**
+     * The bug: a developer "resets" the list by assigning a brand new collection instead of
+     * mutating the existing one (a common pattern when mapping from a DTO). With
+     * {@code orphanRemoval = true}, Hibernate sees every previously-owned book missing from the
+     * new collection and deletes all of them on flush.
+     */
+    public void replaceBooksWithNewList(List<CascadeBook> newBooks) {
+        this.books = new ArrayList<>(newBooks);
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/CascadeBook.java

@@ -0,0 +1,41 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "cascade_book")
+public class CascadeBook {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String title;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "author_id")
+    private CascadeAuthor author;
+
+    protected CascadeBook() {
+    }
+
+    public CascadeBook(String title, CascadeAuthor author) {
+        this.title = title;
+        this.author = author;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/LazyProfile.java

@@ -0,0 +1,38 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+
+/** Owning side (holds {@code user_id} FK) of {@link LazyUser#getProfile()}. */
+@Entity
+@Table(name = "lazy_profile")
+public class LazyProfile {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String bio;
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id")
+    private LazyUser user;
+
+    protected LazyProfile() {
+    }
+
+    public LazyProfile(String bio, LazyUser user) {
+        this.bio = bio;
+        this.user = user;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/LazyUser.java

@@ -0,0 +1,50 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+
+/**
+ * Non-owning ("mappedBy") side of an optional {@code @OneToOne}. Docs: 12-association-mappings.md,
+ * chapter "The @OneToOne lazy trap". Even though {@link #profile} is declared
+ * {@code FetchType.LAZY}, Hibernate cannot build a proxy for it here without bytecode
+ * enhancement: it does not hold the foreign key, so it cannot know whether a profile row
+ * exists without querying. The result is an eager extra SELECT on every load of LazyUser.
+ */
+@Entity
+@Table(name = "lazy_user")
+public class LazyUser {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String username;
+
+    @OneToOne(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL, optional = true)
+    private LazyProfile profile;
+
+    protected LazyUser() {
+    }
+
+    public LazyUser(String username) {
+        this.username = username;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public LazyProfile getProfile() {
+        return profile;
+    }
+
+    public void setProfile(LazyProfile profile) {
+        this.profile = profile;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/MiProfile.java

@@ -0,0 +1,36 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.MapsId;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+
+/** Owning side using {@code @MapsId}: its {@code @Id} IS the {@code user_id} FK value. */
+@Entity
+@Table(name = "mi_profile")
+public class MiProfile {
+
+    @Id
+    private Long id;
+
+    private String bio;
+
+    @MapsId
+    @OneToOne
+    @JoinColumn(name = "id")
+    private MiUser user;
+
+    protected MiProfile() {
+    }
+
+    public MiProfile(String bio, MiUser user) {
+        this.bio = bio;
+        this.user = user;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/MiUser.java

@@ -0,0 +1,35 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+
+/**
+ * The @MapsId fix: this entity carries NO inverse {@code @OneToOne} field at all. A profile is
+ * looked up on demand with {@code session.find(MiProfile.class, userId)} because it shares the
+ * same primary key value as the user (see {@link MiProfile}), so there is nothing to proxy and
+ * nothing forces an eager join when loading a user.
+ */
+@Entity
+@Table(name = "mi_user")
+public class MiUser {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String username;
+
+    protected MiUser() {
+    }
+
+    public MiUser(String username) {
+        this.username = username;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/NoOrphanAuthor.java

@@ -0,0 +1,47 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * {@code cascade = {PERSIST, MERGE}}, no {@code orphanRemoval}. Used for two things:
+ * (1) removing a child from the in-memory collection and flushing does nothing to the row
+ * (docs: "orphanRemoval off"), and (2) mutating only this inverse side (the collection) without
+ * touching {@link NoOrphanBook#setAuthor} never writes the FK (docs: "owning side").
+ */
+@Entity
+@Table(name = "no_orphan_author")
+public class NoOrphanAuthor {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String name;
+
+    @OneToMany(mappedBy = "author", cascade = {CascadeType.PERSIST, CascadeType.MERGE}, fetch = FetchType.LAZY)
+    private List<NoOrphanBook> books = new ArrayList<>();
+
+    protected NoOrphanAuthor() {
+    }
+
+    public NoOrphanAuthor(String name) {
+        this.name = name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public List<NoOrphanBook> getBooks() {
+        return books;
+    }
+}

src/main/java/com/ankurm/hibernatedemo/association/NoOrphanBook.java

@@ -0,0 +1,45 @@
+package com.ankurm.hibernatedemo.association;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "no_orphan_book")
+public class NoOrphanBook {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String title;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "author_id")
+    private NoOrphanAuthor author;
+
+    protected NoOrphanBook() {
+    }
+
+    public NoOrphanBook(String title, NoOrphanAuthor author) {
+        this.title = title;
+        this.author = author;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public NoOrphanAuthor getAuthor() {
+        return author;
+    }
+
+    public void setAuthor(NoOrphanAuthor author) {
+        this.author = author;
+    }
+}