Beginning hibernate 6 Java persistence from beginner to pro
Get started with Hibernate, an open source Java persistence layer and gain a clear introduction to the current standard for object-relational persistence in Java. This updated edition includes the new Hibernate 6.0 framework which covers new configuration, new object relational mapping changes, and...
| Otros Autores: | , , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
[Place of publication not identified] :
Apress
[2022]
|
| Edición: | Fifth edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009635712906719 |
Tabla de Contenidos:
- Intro
- Table of Contents
- About the Authors
- About the Technical Reviewer
- Acknowledgments
- Introduction
- Chapter 1: An Introduction to Hibernate 6
- Plain Old Java Objects (POJOs)
- Building a Project
- Hibernate As a Persistence Solution
- Summary
- Chapter 2: Integrating and Configuring Hibernate
- The Steps Needed to Integrate and Configure Hibernate
- Understanding Where Hibernate Fits into Your Java Application
- Deploying Hibernate
- Installing Maven
- Connection Pooling
- Using JNDI
- Summary
- Chapter 3: Building a Simple Application
- A Simple Application
- Relationships and Cardinality
- A First Attempt
- Writing Data
- Rounding Out the Data Model
- Reading Data
- Updating Data
- Persistence Contexts
- Removing Data
- A Note on Transactions
- The Full Test for Rankings
- Writing Our Sample Application
- Add a Ranking
- Update a Ranking
- Remove a Ranking
- Find Average Ranking for a Subject's Skill
- Find All Rankings for a Subject
- Find the Highest-Ranked Subject for a Skill
- Putting It All Together
- Summary
- Chapter 4: The Persistence LifeCycle
- Introducing the Lifecycle
- Entities, Classes, and Names
- Identifiers
- Entities and Associations
- Saving Entities
- Object Equality and Identity
- Loading Entities
- Merging Entities
- Refreshing Entities
- Updating Entities
- Deleting Entities
- Cascading Operations
- Lazy Loading, Proxies, and Collection Wrappers
- Querying Objects
- Summary
- Chapter 5: An Overview of Mapping
- Why Mapping Cannot Easily Be Automated
- Primary Keys
- Lazy Loading
- Associations
- The One-to-One Association
- The One-to-Many and Many-to-One Associations
- The Many-to-Many Association
- Applying Mappings to Associations
- Other Supported Features
- Specification of (Database) Column Types and Sizes.
- The Mapping of Inheritance Relationships to the Database
- Primary Key
- The Use of SQL Formula-Based Properties
- Mandatory and Unique Constraints
- Summary
- Chapter 6: Mapping with Annotations
- Creating Hibernate Mappings with Annotations
- The Drawbacks of Annotations
- The Benefits of Annotations
- Choosing Which Mapping Mechanism to Use
- JPA 2 Persistence Annotations
- Entity Beans with @Entity
- Primary Keys with @Id and @GeneratedValue
- Generating Primary Key Values with @SequenceGenerator
- Generating Primary Key Values with @TableGenerator
- Compound Primary Keys with @Id, @IdClass, or @EmbeddedId
- Database Table Mapping with @Table and @SecondaryTable
- Persisting Basic Types with @Basic
- Omitting Persistence with @Transient
- Mapping Properties and Fields with @Column
- Modeling Entity Relationships
- Mapping an Embedded (Component) One-to-One Association
- Mapping a Conventional One-to-One Association
- Mapping a Many-to-One or One-to-Many Association
- Mapping a Many-to-Many Association
- Cascading Operations
- Collection Ordering
- Inheritance
- Single Table
- Joined Table
- Table per Class
- Choosing Between Inheritance Types When Modeling Inheritance
- Other JPA 2 Persistence Annotations
- Temporal Data
- Element Collections
- Large Objects
- Mapped Superclasses
- Ordering Collections with @OrderColumn
- Named Queries (HQL or JPQL)
- Named Native Queries (SQL)
- Configuring the Annotated Classes
- Hibernate-Specific Persistence Annotations
- @Immutable
- Natural IDs
- Summary
- Chapter 7: JPA Integration and Lifecycle Events
- The Java Persistence API
- The Project Object Model
- Introducing Lombok
- The JPASessionUtil Class
- Testing JPASessionUtil
- Lifecycle Events
- External Entity Listeners
- Data Validation
- Summary
- Chapter 8: Using the Session
- Sessions.
- Transactions and Locking
- Transactions
- The ACID Tests
- Locking
- Deadlocks
- Caching
- Threads
- Summary
- Chapter 9: Searches and Queries
- Hibernate Query Language (HQL)
- Syntax Basics
- UPDATE
- DELETE
- INSERT
- SELECT
- Named Queries
- Logging and Commenting the Underlying SQL
- Logging the SQL
- Commenting the Generated SQL
- The from Clause and Aliases
- The select Clause and Projection
- Using Restrictions with HQL
- Using Named Parameters
- Paging Through the Result Set
- Obtaining a Unique Result
- Sorting Results with the order by Clause
- Associations and Joins
- Aggregate Methods
- Bulk Updates and Deletes with HQL
- Using Native SQL
- Summary
- Chapter 10: Filtering the Results of Searches
- When to Use Filters
- Getting Started
- Defining and Attaching Filters
- Filters with Annotations
- Filters with XML Mapping Documents
- Using Filters in Your Application
- A Basic Filtering Example
- Summary
- Chapter 11: Integration into the Web
- Setting the Stage
- The Plan
- The Application
- The Project Model
- The Data Model
- Building Our First Servlet Test
- Our First (Wrong) Servlet: Adding a User
- The AddUserServlet, Corrected
- Where DTOs Shine
- Rounding Out the Application
- Creating a Post
- A Better "Get Posts" Servlet
- Rounding Out the "Application"
- Summary
- Chapter 12: Integrating Hibernate
- Spring
- Spring Data with Spring Boot
- ActiveJ
- Quarkus
- Summary
- Chapter 13: Hibernate Envers
- What Does a "Version" Mean?
- Creating a Simple Project
- Looking for Revisions with Specific Data
- An Example Reverting Data
- Summary
- Index.
