liveBookmanning.com

What you will learn in Java Persistence with Spring Data and Hibernate epub

by Catalin Tudose

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• HibernateHibernate is an open-source Java object-relational mapping framework that implements the Jakarta Persistence API and provides additional persistence features.
• object-relational mapperObject-relational mapping (ORM) is the technique of representing and synchronizing object-oriented domain models with relational database structures.
• database transactionA transaction is a database unit of work whose operations are handled as a coherent atomic interaction.
• entityA business entity is an object representing a significant concept or state in an application's business domain.
• versioningEntity versioning associates persistent data with a version value that changes when it is updated, enabling concurrent modifications to be detected.
• pessimistic concurrency controlPessimistic locking, or pessimistic concurrency control, prevents conflicting concurrent access by acquiring database locks before or during work.
• detached stateA detached entity is an entity instance that is no longer associated with a persistence context but retains its persistent identity and state.
• one-to-many relationshipA many-to-one association is an association in which multiple instances on one side may reference a single instance on the other side.
• dirty checkingDirty checking is the persistence-engine process of detecting changes made to managed objects so they can be synchronized with the database.
• @EntityThe JPA annotation that declares a Java class as a persistent entity type.
• JDBCJDBC is the standard Java API for connecting to relational databases and executing SQL statements.
• embeddable typeThe @Embeddable annotation declares that a Java class defines a JPA embeddable type whose state can be mapped into an owning persistent class.
• repeatable read isolation levelRepeatable read is a transaction isolation level under which repeated reads of the same data return a consistent value within a transaction, preventing unrepeatable reads while generally allowing phantom reads.
• persistence contextA persistence context is a managed set of entity instances whose state is tracked by a JPA persistence provider without necessarily being synchronized with a transaction.
• object-relational impedance mismatchObject/relational paradigm mismatch is the structural and behavioral incompatibility between object-oriented application models and relational database models.
• Spring Data JPASpring Data JPA is a Spring Data module that adds repository and query-generation support on top of JPA implementations.
• JPAThe Jakarta Persistence API (JPA) is the standard Java specification for mapping objects to relational database data and managing their persistence.
• converterA custom type converter is application-defined conversion logic that translates values between a domain type and a persistence representation.
• Spring Data JDBCSpring Data JDBC is a Spring Data module that provides database access through JDBC with reduced persistence boilerplate.
• domain modelA domain model is an object-oriented representation of application-domain concepts, their state, and their relationships.
• lockingLocking is a concurrency-control technique that restricts access to data while a transaction holds a lock on it.
• EntityManagerEntityManager is the JPA API interface for managing the lifecycle and persistence operations of entity instances.
• cascade operationCascade is a JPA association-mapping configuration that propagates selected entity lifecycle operations or state changes to associated entities.
• join tableA join table is a relational table that stores key-based links between rows of associated entity tables, commonly for a many-to-many association.
• type adapterA type adapter is a component that translates a domain value type to and from a persistence representation while integrating with persistence-provider behavior.
• cachingCaching is the retention of data in a faster-access storage layer so subsequent reads can reuse it.
• LockModeTypeA lock mode is a JPA setting that specifies the locking behavior requested for an entity or query operation.
• lost update anomalyA lost update occurs when one concurrent transaction overwrites another transaction's committed modification without detecting the conflict.
• eager loadingEager loading is a persistence technique that retrieves associated data together with the owning entity rather than deferring access.
• @Column annotationThe JPA @Column annotation specifies how a persistent property or field maps to a relational database column.
• SQLSQL is a standardized language for defining, manipulating, querying, and controlling data in relational database systems.
• value objectA developer-defined value type is an application-defined class whose instances are identified by their values rather than independent persistent identity.
• bidirectional relationshipA bidirectional association is a relationship navigable between its participating objects or classes in both directions.
• optimistic concurrency controlOptimistic concurrency control detects conflicting updates by checking that data has not changed since it was read, typically through version information.
• flushA flush is the persistence operation that synchronizes pending in-memory entity changes with the database before an operation that may depend on those changes.
• fetch planA fetch plan is a specification of which entity associations and collections are retrieved, and when they are retrieved, during an operation.
• equality by valueThe equals method is the Java object method that determines whether one object should be considered equal to another.
• Spring DataSpring Data is a family of Spring projects that provides consistent data-access abstractions across relational and nonrelational persistence technologies.
• mapping metadataMapping metadata is configuration that describes how application classes and properties correspond to a relational database schema.
• plain old java objectA POJO is an ordinary Java object that does not depend on framework-specific base classes, interfaces, or runtime mechanisms for its basic behavior.
• automatic version checkingAutomatic version checking, or automatic versioning, tracks entity versions and compares the previously read version with the database version during updates or deletions to detect concurrent modification.
• composite keyA key formed from multiple attributes or columns that jointly identify a persistent entity or relational row.
• Spring BootSpring Boot is a framework for building Spring applications with convention-based configuration, auto-configuration, and deployable application support.
• @ElementCollection@ElementCollection is a Jakarta Persistence annotation that maps a collection of basic or embeddable value types belonging to an entity.
• primary keyA primary key is a database column or set of columns whose values uniquely identify a row.
• forced version incrementA forced version increment deliberately advances an entity version so concurrent operations involving that entity become detectable conflicts.
• manual version checkingManual version checking explicitly requests version-aware reads or lock modes to verify that data remains unchanged during a unit of work.
• OptimisticLockExceptionOptimisticLockException is the JPA exception indicating that an optimistic concurrency check detected a conflicting update or deletion.
• race conditionA race condition is a correctness problem in which the outcome depends on the timing or interleaving of concurrent operations.
• @Version@Version is the JPA annotation that identifies an entity property used for optimistic concurrency version checking.
• data access objectThe data access object pattern separates an abstract data-access interface from the implementation details of communicating with a database.
• persistpersist is the EntityManager operation that makes an entity instance persistent and can cancel a pending removal before synchronization.
• MapMap is a Java collection interface representing key-value associations in which each key maps to at most one value.
• phantom readA phantom read is a concurrency anomaly in which repeated query executions within a transaction return different sets of rows because another transaction inserted or deleted matching data.
• orphan removalOrphan removal is a JPA association-mapping option that automatically removes a child entity when it is no longer associated with its parent.
• SQL dialectA database-system-specific variation of SQL syntax, semantics, or supported features.
• entity stateThe lifecycle state in which an entity instance is associated with a persistence context and tracked for persistence synchronization.
• transitive persistenceTransitive persistence is the propagation of an entity-persistence operation to associated entities in the object graph.
• JPA implementationA JPA provider is a software implementation of the Jakarta Persistence API that supplies persistence behavior for entity classes.
• transient stateA transient entity is a newly created entity instance that is not yet associated with persistent storage and has no database identifier.
• hashCode methodThe hashCode method is the Java object method that returns an integer hash value used by hash-based collections.
• JpaRepositoryJpaRepository is the Spring Data JPA repository interface that provides standard persistence operations and query-method support for JPA entities.
• database sequenceA database sequence is a database object that produces successive identifier values independently of row insertion.
• data conversionJava-to-SQL type conversion is the transformation between Java property values and SQL-compatible database values.
• single-table inheritance strategyA single-table inheritance strategy stores an entire class hierarchy in one table, typically distinguishing subtype rows with a discriminator and allowing nullable subtype columns.
• concurrencyConcurrency is the execution or management of multiple activities whose operations may overlap in time.
• identityGenerationType.IDENTITY is the JPA identifier-generation option that obtains the identifier generated by an identity or auto-increment column during insertion.
• optimistic lockingOptimistic locking detects conflicting concurrent modifications by checking an entity version or equivalent state rather than acquiring exclusive locks in advance.
• object persistenceObject persistence is the preservation and later reconstruction of individual objects across application-process lifetimes.
• serializable isolation levelSerializable isolation is the strictest transaction isolation level and makes concurrent transactions behave as if executed serially.
• java.util.Datejava.util.Date is the legacy Java class representing a date and time as a millisecond-based value.
• query methodA query method is a repository method whose name specifies a data-retrieval query through Spring Data's method-name parsing conventions.
• table-per-class inheritance strategyTable-per-concrete-class mapping stores the persistent state of each non-abstract class in a separate relational table.
• Spring InitializrSpring Initializr is a web service that generates preconfigured Spring project skeletons from selected project metadata and dependencies.
• query builderA query builder is a mechanism that constructs database queries from structured declarations or repository method definitions.
• binary large objectA binary large object is binary data stored as a single large database value, commonly for multimedia content.
• character large objectA character large object is large character data stored separately from ordinary column storage and referenced by the table.
• Hibernate type systemThe Hibernate type system is the framework subsystem that selects and performs mappings between Java property types and SQL or vendor-specific database types.
• java.sql temporal typesThe java.sql temporal types are JDBC date, time, and timestamp classes corresponding to SQL temporal types.
• java.timeThe Java time API is the standard Java API for representing dates, times, date-times, and time-zone offsets.
• JDBC LOB classesJDBC LOB classes represent database character or binary large objects and provide access to their contents on demand.
• @Lob annotationThe JPA @Lob annotation maps a persistent property to a database large object value such as a BLOB or CLOB.
• collection mappingThe specification of how an object collection property corresponds to relational database structures and persistence behavior.
• relational database management systemA relational database management system (RDBMS) stores and manages structured data in related tables and provides relational query and transaction processing.
• identityObject identity is the property by which two object references are the same when they refer to the same object instance.
• filterA dynamic filter is a named, optionally parameterized Hibernate restriction that can be enabled at runtime to limit rows or entity instances returned from database operations.
• relational modelThe relational data model represents information as relations consisting of tuples and attributes with defined integrity constraints.
• polymorphic queryA polymorphic query retrieves instances of multiple entity classes matching the queried superclass or interface type.
• LazyInitializationExceptionLazyInitializationException is a Hibernate exception raised when unloaded persistent state is accessed after the persistence context needed to load it is unavailable.
• cascading deleteCascading deletion is the propagation of an entity removal operation to associated entities.
• on delete cascadeON DELETE CASCADE is a relational foreign-key action that automatically deletes referencing rows when the referenced row is deleted.
• JPQLJPQL is the JPA query language that expresses queries in terms of persistent entity classes and their properties.
• Transactional annotationThe Spring Transactional annotation declares that method or class execution participates in transaction management.
• @transientThe JPA Transient annotation marks a persistent-class field or property that must not be stored in persistent data.
• dirty readA dirty read is a concurrency anomaly in which a transaction reads changes made by another transaction before those changes are committed.
• nonrepeatable readAn unrepeatable read is a transaction anomaly in which a repeated read of the same data returns a different value because another transaction committed a modification.
• read committed isolation levelRead committed isolation is a transaction isolation level that prevents dirty reads and lost updates while allowing unrepeatable and phantom reads.
• read uncommittedRead uncommitted isolation is a transaction isolation level that allows transactions to read rows affected by uncommitted writes while restricting conflicting writes.
• proxyA proxy is a substitute object that represents another object and defers or controls access to that object's state or behavior.
• QuerydslThe Querydsl API is the public Java programming interface for declaring and executing type-safe queries.
• joined inheritance strategyA joined inheritance strategy maps each class in an inheritance hierarchy to its own relational table, linking subclass rows to superclass rows through shared primary and foreign keys.
• field accessField access is a persistence mapping strategy in which a framework reads and writes an object's persistent member fields directly.
• JavaBean Validation APIBean Validation is a Java specification for declaring and evaluating constraints on object properties and method parameters.
• many-to-many relationshipA many-to-many association is an association in which multiple instances on each side may be related to multiple instances on the other side.
• enhanced-sequenceenhanced-sequence is a Hibernate identifier-generation strategy that uses a database sequence when available and otherwise emulates one with a table.
• GenerationType.AUTOA JPA identifier-generation strategy in which the persistence provider selects an appropriate strategy for the configured database.
• not-null constraintA NOT NULL constraint is a database rule requiring a column to contain a value rather than SQL NULL.
• deadlockA deadlock is a cyclic waiting condition in which concurrent transactions each hold locks needed by another and none can proceed.
• fetch strategyA fetch strategy is a persistence configuration that determines when and how associated data is retrieved from the database.
• @JoinColumn@JoinColumn is a Jakarta Persistence annotation that specifies the relational column used to join an entity association.
• unique identifierAn entity property whose value identifies its corresponding persistent database record.
• PersistenceUtilPersistenceUtil is a JPA utility class that provides standardized static methods for inspecting the loading state of entities and persistent properties.
• getReferencegetReference is a JPA EntityManager operation that returns a reference to an entity, commonly without immediately retrieving its database state.
• attributeAn annotation is declarative metadata attached to a program element to provide configuration or other information to tools and frameworks.
• implicit polymorphismImplicit polymorphism is Hibernate behavior that supports polymorphic queries across mapped classes sharing a common interface or type without requiring a mapped inheritance hierarchy.
• composition relationshipComposition is an object-model relationship in which the lifecycle of a contained part is fully dependent on the lifecycle of its containing whole.
• data integrityData integrity is the preservation of correctness and consistency of data and its enforced relationships.
• mapped superclass@MappedSuperclass is a Jakarta Persistence annotation that marks a class whose persistent properties are inherited by mapped subclasses without making the superclass itself an entity.
• transparent persistenceTransparent persistence is persistence in which application code can work with domain objects without explicitly performing their storage and retrieval operations.
• MongoDBMongoDB is a document-oriented database management system that stores data in flexible, JSON-like documents.
• Spring Data repositoryA repository interface is a programming interface that defines data-access operations for a persistent domain type without prescribing their implementation.
• joinA join is an SQL relational operation that combines rows from multiple tables according to a matching or other join condition.
• ordered setSortedSet is the Java collection interface for a set whose elements are ordered according to a specified comparator or their natural ordering.
• Hibernate OGMHibernate OGM is a Hibernate module that provides JPA-based object or grid mapping to nonrelational data stores.
• accessor methodA setter method is an accessor method that assigns a value to an object property.
• default constructorA no-arg constructor is a constructor that accepts no parameters and can create an instance without supplied arguments.
• mergemerge is a JPA EntityManager operation that copies the state of a detached or new entity instance into a managed instance in a persistence context.
• org.hibernate.Interceptororg.hibernate.Interceptor is a Hibernate API contract for intercepting and reacting to persistence operations with application-defined behavior.
• auditabilityAn audit log, or audit trail, is a chronological record of data changes that supports historical review and accountability.
• @QueryThe @Query annotation is a Spring Data repository-method annotation that declares a query to execute instead of deriving one from the method name.
• mappedBymappedBy is a Jakarta Persistence association-mapping attribute that names the property owning the relational mapping on the other side of a bidirectional association.
• shared primary key valueA shared primary key one-to-one association is a relationship in which the dependent entity uses the referenced entity's primary-key value as its own identifier.
• inheritance strategyAn inheritance-mapping strategy specifies how an object-oriented class hierarchy is represented in relational tables.
• @Id@Id is the JPA annotation that marks a persistent property or field as an entity identifier.
• Spring Data CommonsSpring Data Commons is the shared Spring Data library containing common infrastructure, metadata abstractions, and repository interfaces.
• one-to-one relationshipA one-to-one association is an association in which each entity instance is related to at most one instance of the other entity type.
• shared lockA shared lock, or shared read lock, permits compatible reads by multiple transactions while preventing conflicting writes.
• key generatorA configurable mechanism that produces identifier values for database primary keys.
• discriminator columnA discriminator is a stored value that identifies the concrete subtype represented by a row in a single-table inheritance mapping.
• TransactionalTestExecutionListenerTransactionalTestExecutionListener is a Spring TestContext listener that manages transaction-related actions around test execution, including executing tests within transactions and rolling them back.
• surrogate keyA surrogate key is an application-meaningless primary key whose purpose is to identify stored data internally.
• foreign keyA foreign key constraint enforces a referential relationship between values in one table and a candidate or primary key in another table.
• persistent collectionPersistentCollection is the Hibernate interface for collection implementations that integrate collection state with persistence management.
• handlerAn event handler is a component that receives an event and performs processing in response to it.
• fetch profileA fetch profile is a Hibernate-defined loading configuration that selectively overrides association and collection fetching for a unit of work.
• unique constraintA database constraint that requires each non-null value or combination of values in specified columns to be unique.
• EntityManager#refresh()EntityManager#refresh() reloads an entity's state from the database, overwriting its current managed in-memory state and optionally applying a lock mode.
• @Access annotationThe JPA @Access annotation selects or overrides whether persistent properties are accessed through fields or property accessor methods.
• pre-insert identifier generatorA pre-insert identifier generator assigns an entity identifier before the entity's SQL INSERT is executed.
• @manytoone@ManyToOne is a Jakarta Persistence annotation that maps an association from multiple source entities to one target entity.
• Spring TestContext FrameworkThe Spring TestContext Framework is a Spring testing framework that provides context management and integration-testing support independently of a particular testing framework.
• @PersistenceContext@PersistenceContext is the JPA annotation that injects an EntityManager associated with a persistence context into a managed component.
• CrudRepositoryCrudRepository is a Spring Data repository interface providing generic create, read, update, and delete operations for an entity and its identifier type.
• Cartesian productA relational operation that forms every possible pairing of rows from two relations, potentially producing redundant combinations when multiple collections are joined.
• data layerThe persistence layer is the architectural layer responsible for loading and storing domain-model state in durable storage.
• bagA persistent unordered collection that permits duplicate element values and does not assign a collection index to them.
• Hibernate EnversHibernate Envers is a Hibernate module for auditing persistent data and retaining historical versions of entity state.
• @OneToOne@OneToOne is a Jakarta Persistence annotation that declares an entity-valued property as a one-to-one association.
• associationAn association is a relationship connecting two model elements and allowing navigation between them.
• @Projection@Projection is a Spring Data REST annotation that declares a named projection for selected entity properties and expressions.
• EnableTransactionManagement annotationAnnotation-driven transaction management is a configuration technique that enables transaction interception based on annotations placed on application components.
• FetchType.EAGERFetchType.EAGER is a Jakarta Persistence fetch option specifying that an associated value is retrieved with its owning entity.
• lifecycle dependencyA lifecycle dependency is a dependency in which the existence or removal of one object governs the existence or removal of another object.
• extended persistence contextAn extended persistence context is a persistence context that remains associated across multiple request/response cycles or system transactions.
• business keyA business key is a property or combination of properties that uniquely identifies a domain instance according to meaningful business data.
• database identifier equalityDatabase identifier equality is an equality strategy that determines object equality solely from a persistent database identifier.
• UserTypeUserType is a Hibernate interface for defining custom mappings between a Java value and JDBC column values, including caching and dirty-checking behavior.
• collection tableA collection table is a relational table that stores the elements of a persistent collection together with a key referencing its owning entity.
• NoSQL databaseA NoSQL database is a nonrelational database system designed around data models and access patterns other than the traditional relational table model.
• Spring Data RESTSpring Data REST is a Spring Data project that exposes repository-backed data through RESTful resources.
• N + 1 query problemThe n+1 selects problem is a data-access performance anti-pattern in which one query retrieves a root object and an additional query retrieves each associated object or collection element.
• @GeneratedValueThe JPA @GeneratedValue annotation specifies that a persistence provider should generate an entity identifier value according to a configured generation strategy.
• @GenericGenerator@GenericGenerator is a Hibernate annotation for configuring custom identifier generator strategies and their parameters.
• removed stateA removed state is an entity-instance state in which a persistence provider has scheduled the instance's database representation for deletion.
• multi-tier applicationA layered architecture organizes an application into separate layers with distinct responsibilities and controlled dependencies.
• JavaBeansThe JavaBean specification defines conventions for Java component properties, including the naming of getter and setter methods.
• SessionFactorySessionFactory is Hibernate's thread-safe factory for creating Session instances and managing Hibernate persistence resources.
• JPA @OrderBy annotationThe JPA @OrderBy annotation specifies ordering of elements in a persistent collection using entity properties or basic-element values.
• embedded componentAn embedded entity is a value-like persistent object whose fields are stored in the same database table as its owning entity rather than in a separate table.
• FOR UPDATE clauseFOR UPDATE is an SQL locking clause that requests exclusive row locks for rows selected by a query.
• lock timeoutA lock timeout is a configured duration after which a DBMS stops waiting to acquire an unavailable lock.
• PESSIMISTIC_READPESSIMISTIC_READ is a JPA lock mode that acquires a lock guaranteeing repeatable reads without necessarily preventing all concurrent reads.
• PESSIMISTIC_WRITEPESSIMISTIC_WRITE is a JPA lock mode that acquires an exclusive lock, guarantees repeatable reads, and serializes conflicting data access.
• natural keyA natural key is a primary key derived from meaningful attributes of the represented entity or domain data.
• CompositeUserTypeCompositeUserType is a Hibernate interface for mapping a composite value type with individually queryable properties.
• native Hibernate converter APIThe native Hibernate converter API is Hibernate's implementation-specific extension mechanism for customizing type conversion and persistence behavior at a low level.
• type definitionA type definition is reusable Hibernate mapping metadata that binds a custom type adapter to a name and its parameters.
• EntityGraph API@EntityGraph is a JPA annotation that declares an entity graph on an entity or query-related repository element.
• unsynchronized persistence contextAn unsynchronized persistence context is a persistence context that is not automatically joined to an active transaction and therefore does not automatically flush changes.
• AttributeConverterAttributeConverter is the JPA interface for defining conversions between an entity attribute type and a database column type.
• @Convert annotationThe @Convert annotation declares a JPA converter for a persistent attribute or a nested attribute path.
• metamodel apiThe JPA programming interface for inspecting persistent metadata at runtime without compile-time-generated metamodel classes.
• @OrderColumn@OrderColumn is a Jakarta Persistence annotation that maps the persistent order of list elements to a database column.
• runtime-generated subclassA runtime-generated subclass is a subclass created during program execution to represent or extend an entity type dynamically.
• runtime proxy generationRuntime proxy generation is the creation of proxy classes during program execution to intercept or defer access to entity state.
• naming standardA naming convention is a prescribed pattern for naming database objects or other artifacts consistently.
• ResultSetResultSet is the JDBC interface representing the tabular data returned by a database query and providing access to its rows and columns.
• constraintA database constraint is a rule enforced by a database to restrict valid schema or data states.
• sorting algorithmSorting is the ordering of query results according to one or more attributes.
• shared referenceA shared reference is a situation in which multiple object instances can reference the same referenced object instance.
• @dirtiescontext@DirtiesContext is a Spring testing annotation that marks an application context as modified so it can be discarded and recreated for subsequent tests.
• Spring beanA Spring bean is an object instantiated, configured, and managed by the Spring application context.
• HAS-A relationshipAggregation is an object-model relationship in which one object groups or contains another object as a constituent part.
• delimited identifierA delimited identifier is an SQL identifier enclosed by the database system's identifier delimiters to permit otherwise special names or preserve case.
• entity nameAn entity name is the query-language name by which a persistent entity class is referenced in JPA queries.
• identifier quotingIdentifier quoting is the technique of delimiting database identifiers so reserved words, unusual characters, whitespace, or letter case can be preserved.
• keywordAn SQL keyword that has a predefined syntactic or semantic meaning and therefore may be invalid as an unquoted identifier.
• PhysicalNamingStrategyPhysicalNamingStrategy is a Hibernate interface for transforming logical database artifact names into their physical names.
• table annotationA table annotation is a JPA annotation that specifies relational-table mapping details for an entity class.
• q-typeA Q-type is a generated Querydsl metamodel class that represents an entity and exposes typed representations of its queryable properties.
• auto-commit modeAuto-commit mode is a database connection mode in which each individual SQL statement executes as its own transaction.
• polymorphic associationA polymorphic association is an object association whose target may be an instance of any of several subtypes.
• multi-version concurrency controlMulti-version concurrency control (MVCC) is a concurrency-control technique that maintains multiple data versions so transactions can read consistent snapshots with reduced blocking.
• property accessProperty access is a persistence mapping strategy in which a framework reads and writes persistent state through getter and setter methods.
• revision numberA revision number is a sequential identifier assigned to an audited change set, with higher numbers representing more recent revisions.
• Spring Data JDBC Column annotationThe Spring Data JDBC Column annotation maps a domain property to a relational database column.
• Spring Data JDBC Table annotationThe Spring Data JDBC Table annotation maps a domain class to a relational database table.
• Session#replicate()Session#replicate() is a Hibernate operation that copies an entity's state to persistent storage using its existing identifier and a selected replication mode.
• discriminator valueA discriminator value is the literal value assigned to an entity subtype in an inheritance mapping.
• @DiscriminatorFormula@DiscriminatorFormula is a Hibernate annotation that derives an entity subtype discriminator from an SQL expression instead of a stored discriminator column.
• ConstraintViolationExceptionConstraintViolationException is an exception reporting one or more failed Bean Validation constraints during persistence operations.
• snapshotA state snapshot is a stored copy of an entity's state used to detect changes made to the managed instance.
• validation-modevalidation-mode is a JPA persistence configuration element that controls whether a provider automatically performs Bean Validation.
• query by exampleQuery by Example is a query-construction technique that derives predicates from an example object and matching rules instead of requiring a query language expression.
• repository annotationThe Spring Repository annotation identifies a component as a data-access repository and enables translation of persistence exceptions into Spring's unchecked data-access exceptions.
• GenerationType enumThe GenerationType enum defines standardized JPA strategies for generating entity identifier values.
• named identifier generatorA named identifier generator is a separately named configuration that defines how entity identifier values are generated.
• Spring Data MongoDBSpring Data MongoDB is a Spring Data module that provides repository-oriented access to MongoDB document data.
• first-level cacheThe first-level persistence context cache is the session-scoped cache of entity instances managed by a Hibernate persistence context.
• union subclass mappingA union-based mapping represents polymorphic access to concrete-class tables by combining their rows with SQL UNION operations.
• automated persistenceAutomated persistence is a persistence solution that handles low-level database interaction and persistence mechanics on behalf of application code.
• project object modelpom.xml is the Maven Project Object Model file that declares a project's metadata, dependencies, and build configuration.
• MongoDB documentA MongoDB document is a BSON record consisting of field-value pairs that represents a stored data object.
• SpringSpring is a Java application-development framework that provides infrastructure abstractions for tasks such as dependency injection, data access, and transaction management.
• ternary relationshipA ternary relationship is a relationship that simultaneously connects instances of three participating entity or object types.
• criteria queryA criteria query is a programmatically constructed JPA query whose selections and restrictions are represented through a type-safe criteria API rather than string-based query text.
• findfind is a JPA EntityManager operation that retrieves an entity by its type and identifier, returning null when no matching entity exists.
• lifecycle callback methodA lifecycle callback method is an entity-related method invoked automatically when a persistent instance reaches a specified lifecycle event.
• sorted collectionA sorted collection is a collection whose elements are maintained or presented according to an ordering relation.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.