A comprehensive demonstration project showcasing Java Persistence API (JPA) and Hibernate features, patterns, and best practices. This repository serves as both a learning resource and a reference implementation for JPA/Hibernate in Spring Boot applications.

• Overview
• Features
• Project Structure
• Prerequisites
• Getting Started
• Key Concepts
• JPA Annotations Reference
• Optimization Techniques
• Tools and Technologies
• Additional Resources

Java Persistence API (JPA) is a specification for managing relational data in Java applications. It simplifies database operations and abstracts away much of the complexity involved in handling data persistence. This project demonstrates various JPA concepts, from basic entity mapping to advanced features like caching and performance optimization.

• Entity Mapping: Basic and complex entity definitions with various annotations
• Relationships: Examples of One-to-One, One-to-Many, Many-to-Many relationships
• Inheritance Mapping: Different strategies (SINGLE_TABLE, TABLE_PER_CLASS, JOINED)
• Composite Keys: Using @EmbeddedId and @IdClass
• Custom Queries: JPQL, Criteria API, and Native SQL examples
• Projections: Interface-based and class-based projections (DTOs)
• Caching: Second-level cache and query cache with Ehcache
• Validation: Bean validation with Jakarta Validation API
• Transactions: Transaction management and entity lifecycle
• Performance Optimization: Techniques to resolve N+1 problems, batch processing
• Auditing: Entity lifecycle event listeners
• Custom Types: AttributeConverters and custom type mappings

The project is organized into domain-specific packages, each demonstrating different JPA concepts:

• book, author, article: Publishing domain with relationships
• user, person: User management with various mapping techniques
• movies, cinema: Entertainment domain with complex relationships
• vehicle, transport: Transportation domain with inheritance mapping
• patient, address: Healthcare domain with embedded entities
• product, order: E-commerce domain with composite keys
• circle, figure, square: Geometric shapes with inheritance mapping
• And many more examples...

Each domain package typically contains:

• Entity classes
• DTOs (Data Transfer Objects)
• Service interfaces and implementations
• Repository interfaces

• Java 22 or later
• MySQL 8.0 or later
• Gradle 8.0 or later
• IDE (IntelliJ IDEA, Eclipse, or VS Code)

git clone https://github.com/yourusername/jpa-hibernate.git
cd jpa-hibernate

Create a MySQL database named jpa:

CREATE DATABASE jpa;
CREATE USER 'admin'@'localhost' IDENTIFIED BY 'admin';
GRANT ALL PRIVILEGES ON jpa.* TO 'admin'@'localhost';
FLUSH PRIVILEGES;

The default configuration in application.properties should work if you've set up the database as described above. If you need to customize it, modify:

spring.datasource.url=jdbc:mysql://localhost:3306/jpa
spring.datasource.username=admin
spring.datasource.password=admin

./gradlew bootRun

The application will start on port 8080 with context path /api/v1/jpa.

Throughout this project, you'll encounter several important JPA concepts:

• @OneToOne: One-to-one relationships between entities
• @OneToMany/@ManyToOne: One-to-many/Many-to-one bidirectional relationships
• @ManyToMany: Many-to-many relationships with join tables

• Lazy vs. Eager Loading: Controlling when related entities are loaded
• Entity Graphs: Customizing fetch plans for specific use cases

• Single Table: All classes in a hierarchy mapped to one table
• Joined Table: Each class mapped to its own table with joins
• Table Per Class: Each concrete class mapped to a separate table

• First-level Cache: Session-level caching (always enabled)
• Second-level Cache: SessionFactory-level caching for entities
• Query Cache: Caching query results

• @Entity: Marks a class as an entity
• @Table: Specifies the primary table for the entity
• @Id: Marks a field as the primary key
• @GeneratedValue: Configures the way of increment of the specified column
• @Column: Specifies column mapping for a field
• @Transient: Marks a field to be excluded from persistence

• @OneToOne: One-to-one relationship
• @OneToMany: One-to-many relationship
• @ManyToOne: Many-to-one relationship
• @ManyToMany: Many-to-many relationship
• @JoinColumn: Specifies a foreign key column
• @JoinTable: Specifies a join table for a relationship

• @Inheritance: Specifies the inheritance strategy
• @MappedSuperclass: Base class for entities
• @DiscriminatorColumn: Specifies the discriminator column for SINGLE_TABLE strategy
• @DiscriminatorValue: Specifies the discriminator value for an entity

• @Embeddable: Marks a class as embeddable
• @Embedded: Marks a field as an embedded object
• @AttributeOverride: Overrides attributes of an embedded field

• @SecondaryTable: Maps entity to an additional table
• @ElementCollection: Maps a collection of basic or embeddable types
• @MapKey: Specifies the map key for a Map collection
• @OrderBy: Specifies the ordering of a collection
• @Formula: Defines a read-only calculated property

• @EntityGraph: Defines graph of entities to be fetched in a single query
• @BatchSize: Specifies the size of batches for lazy loading
• @Fetch(FetchMode.SUBSELECT): Uses subselects for collection fetching

• @Cacheable: Marks an entity as cacheable
• @Cache: Configures the caching strategy for an entity

• @DynamicInsert/@DynamicUpdate: Generates SQL with only the changed columns
• Query Hints: Optimizes query execution

• Java 22: Core programming language
• Spring Boot 3.3.3: Application framework
• Hibernate 6.x: JPA implementation
• MySQL: Database
• Ehcache: Caching provider
• Flyway: Database migration
• Lombok: Reduces boilerplate code
• Jakarta Validation API: Bean validation

• JPA Specification
• Hibernate Documentation
• Spring Data JPA Documentation
• Canva Slide
• Medium JPA Guide

This project is designed to be both a learning resource and a reference implementation. Feel free to explore the code, run the examples, and use it as a template for your own JPA/Hibernate projects.