Learn the fundamentals of the Java persistence API (JPA) and the Hibernate framework using Spring and Spring Boot
About This Video
In Detail
Hibernate is the most popular implementation of JPA. It was the most popular ORM framework option before JPA emerged and it provides additional features …
Learn the fundamentals of the Java persistence API (JPA) and the Hibernate framework using Spring and Spring Boot
About This Video
In Detail
Hibernate is the most popular implementation of JPA. It was the most popular ORM framework option before JPA emerged and it provides additional features on top of JPA. We will use Hibernate as the JPA implementation in this course.
The Java Persistence API provides Java developers with an API to map Java objects to relational data. In this course, you will learn about Hibernate, JPA API, JPQL (Java Persistence query language), Java Persistence Criteria API, and how you can perform ORM (Object Relational Mapping) with JPA and Hibernate.
In this course, you will learn the basics of JPA and Hibernate such as entities, relationships, inheritance mappings, and annotations. Understand approaches to querying data using JPA and Hibernate (JPQL, Criteria API, and Native Queries). Understand JPA and Hibernate Relationships in-depth such as one to one, many to one, and many to many.
Use a variety of Spring Boot Starters such as Spring Boot Starter Web, Starter Data JPA, and Starter Test. Learn the basics of performance tuning your JPA application with Hibernate - Solve N+1 Queries Issue. Learn the basics of caching such as first-level cache and second-level cache with EhCache. Understand the basics of Spring Data JPA and Spring Data REST.
By the end of this course, you will become a master in Hibernate and JPA with Spring Boot.
Who this book is for
This course is for anyone who wants to learn the basics of JPA and Hibernate and understand how to build the data layer of a web application.
Chapter 1 : Introduction
Master Hibernate and JPA with Spring Boot
Master Hibernate and JPA with Spring Boot - Course Overview
Master Hibernate and JPA with Spring Boot - Git Repository
Master Hibernate and JPA with Spring Boot - Installing Basic Tools
Quick Introduction to JPA
Chapter 2 : Introduction to Spring Boot in 10 Steps
Introduction to Spring Boot in 10 Steps
Step 1: Introduction to Spring Boot - Goals and Important Features
Step 2: Developing Spring Applications before Spring Boot
Step 3: Using Spring Initializr to Create a Spring Boot Application
Step 4: Creating a Simple REST Controller
Step 5: What is Spring Boot Auto Configuration?
Step 6: Spring Boot Versus Spring Versus Spring MVC
Step 7: Spring Boot Starter Projects - Starter Web and Starter JPA
Step 8: Overview of Different Spring Boot Starter Projects
Step 9: Spring Boot Actuator
Step 10: Spring Boot Developer Tools
Chapter 3 : Journey From Spring JDBC to JPA
Introduction to Journey from JDBC To JPA
Step 01 - Setting Up a Project with JDBC, JPA, H2, and Web Dependencies
Step 02 - Launching Up H2 Console
Step 03 - Creating a Database Table in H2
Step 04 - Populate Data into Person Table
Step 05 - Implement findAll persons Spring JDBC Query Method
Step 06 - Execute the findAll Method using CommandLineRunner
Step 07 - A Quick Review - JDBC Versus Spring JDBC
Step 08 – What’s in the background? Understanding Spring Boot Autoconfiguration
Step 09 - Implementing findByID Spring JDBC Query Method
Step 10 - Implementing deleteByID Spring JDBC Update Method
Step 11 - Implementing Insert and Update Spring JDBC Update Methods
Step 12 - Creating a Custom Spring JDBC RowMapper
Step 13 - Quick Introduction to JPA
Step 14 - Defining Person Entity
Step 15 - Implementing findByID JPA Repository Method
Step 16 - Implementing Insert and Update JPA Repository Methods
Step 17 - Implementing deleteByID JPA Repository Method
Step 18 - Implementing findAll Using JPQL Named Query
Chapter 4 : Introduction to JUnit in 5 Steps
Introduction to JUnit in 5 Steps
Step 1: What is JUnit and Unit Testing?
Step 2: First JUnit Project and Green Bar
Step 3: First Code and First Unit Test
Step 4: Other Assert Methods
Step 5: Important Annotations
Chapter 5 : JPA and Hibernate in Depth
Introduction to JPA and Hibernate in Depth
Step 01 - Create a JPA Project with H2 and Spring Boot
Step 02 - Create JPA Entity Course
Step 03 - Create findByID Using JPA Entity Manager
Step 04 - Configuring Application Properties to Enable H2 Console and Logging
Step 05 - Writing Unit Test for the findByID Method
Step 06 - Writing a deleteByID Method to Delete an Entity
Step 07 - Writing Unit Test for the deleteByID Method
Step 08 - Writing a Save Method to Update and Insert an Entity
Step 09 - Writing Unit Test for the save Method
Step 10 - Quick Review and Debugging Tips
Step 11 - Playing with Entity Manager
Step 12 - Entity Manager Methods - clear and detach
Step 13 - Entity Manager Methods – refresh
Step 14 - A Quick Review of Entity Manager
Step 15 - JPQL – Basics
Step 16 - JPA and Hibernate Annotations - @Table
Step 17 - JPA and Hibernate Annotations - @Column
Step 18 - JPA and Hibernate Annotations - @UpdateTimestamp and @CreationTimestamp
Step 19 - JPA and Hibernate Annotations - @NamedQuery and @NamedQueries
Step 20 - Native Queries – Basics
Chapter 6 : Establishing Relationships with JPA and Hibernate – OneToOne
Step 21 - Entities and Relationships - an Overview
Step 22 - Defining Entities - Student, Passport, and Review
Step 23 - Introduction to One to One Relationship
Step 24 - OneToOne Mapping - Insert Student with Passport
Step 25 - OneToOne Mapping - Retrieving Student with Passport and Eager Fetch
Step 26 - OneToOne Mapping - Lazy Fetch
Step 27 - Transaction, Entity Manager, and Persistence Context
Step 28 - OneToOne Mapping - Bidirectional Relationship - Part 1
Step 29 - OneToOne Mapping - Bidirectional Relationship - Part 2
Chapter 7 : Review with a Few FAQs about Hibernate and JPA
FAQ 1 - When does Hibernate send updates to the database?
FAQ 2 - When do We Need @Transactional in a Unit Test?
FAQ 3 – Do Read Only Methods Need a Transaction?
FAQ 4 - Why do We Use @DirtiesContext in a Unit Test?
Chapter 8 : Establishing Relationships with JPA and Hibernate - OneToMany and ManyToMany
Step 30 - ManyToOne Mapping - Designing the Database
Step 30 - Part 2 - ManyToOne Mapping - Implementing the Mapping
Step 31 - ManyToOne Mapping - Retrieving and Inserting Reviews for Course
Step 32 - ManyToOne Mapping - Generalizing Insert Reviews
Step 33 - ManyToOne Mapping - Wrapping Up
Step 34 - ManyToMany Mapping - Table Design
Step 35 - ManyToMany Mapping - Adding Annotations on Entities
Step 36 - ManyToMany Mapping - Fixing Two Join Tables Problem
Step 37 - ManyToMany Mapping - Customizing the Join Table
Step 38 - ManyToMany Mapping - Insert Data and Write Join Query
Step 39 - ManyToMany Mapping - Retrieve Data Using JPA Relationships
Step 40 - ManyToMany Mapping - Insert Student and Course
Step 41 - Relationships between JPA Entities - a Summary
Chapter 9 : Inheritance Hierarchies with JPA and Hibernate
Step 42 - Introduction to Inheritance Hierarchies and Mappings
Step 43 - JPA Inheritance Hierarchies and Mappings - Setting Up Entities
Step 44 - JPA Inheritance Hierarchies and Mappings - Setting Up a Repository
Step 45 - JPA Inheritance Hierarchies and Mappings - Single Table
Step 46 - JPA Inheritance Hierarchies and Mappings - Table Per Class
Step 47 - JPA Inheritance Hierarchies and Mappings – Joined
Step 48 - JPA Inheritance Hierarchies and Mappings - Mapped Super Class
Step 49 - JPA Inheritance Hierarchies and Mappings - How to Choose?
Chapter 10 : Queries with Entities using JPQL
Step 50 - JPQL - Courses Without Students
Step 51 - JPQL - Courses with 2 Students and order by
Step 52 - JPQL - Courses Like 100 Steps
Step 53 - JPQL - Using Joins
Chapter 11 : Queries using Java API - Criteria Queries
Step 54 - Criteria Query - Retrieving All Courses
Step 55 - Criteria Query - Courses Like 100 Steps
Step 56 - Criteria Query - Courses Without Students
Step 57 - Criteria Query - Using Joins
Chapter 12 : Transaction Management
Step 58 - Introduction to Transaction Management
Step 59 - Transaction Management - ACID Properties
Step 60 - Understanding Dirty, Phanthom, and Non-Repeatable Reads
Step 61 - Understand 4 Isolation Levels
Step 62 - Choosing Between Isolation Levels
Step 63 - Implementing Transaction Management - 3 Things to Decide
Chapter 13 : Spring Data JPA and Spring Data REST
Step 64 - Introduction to Spring Data JPA
Step 65 - Testing the Spring Data JPA Repository with findByID.
Step 66 - Spring Data JPA Repository - CRUD Methods
Step 67 - Sorting Using Spring Data JPA Repository
Step 68 - Pagination Using Spring Data JPA Repository
Step 69 - Custom Queries Using Spring Data JPA Repository
Step 70 - Spring Data REST
Chapter 14 : Caching with Hibernate and JPA
Step 71 - Introduction to Caching and the Various Levels of Caching in Hibernate and JPA
Step 72 - Hibernate and JPA Caching – First-Level Cache
Step 73 - Hibernate and JPA Caching - Basics of Second-Level Cache with EhCache
Step 74 - Hibernate and JPA Caching – Second-Level Cache Part 2
Chapter 15 : Hibernate and JPA Tips
Step 75 - Hibernate Tips - Hibernate Soft Deletes - @SQLDelete and @Where
Step 76 - Hibernate Soft Deletes - Part 2
Step 77 - JPA Entity Life Cycle Methods
Step 78 - Using Embedded and Embeddable with JPA
Step 79 - Using Enums with JPA
Step 80 - JPA Tip - Be Cautious with toString Method Implementations
Step 81 - JPA Tip - When do You Use JPA?
Chapter 16 : Performance Tuning Tips with Hibernate and JPA
Step 82 - Performance Tuning - Measure Before Tuning
Step 83 - Performance Tuning – Indexes
Step 84 - Performance Tuning - Use Appropriate Caching
Step 85 - Performance Tuning - Eager Versus Lazy Fetch
Step 86 - Performance Tuning - Avoid N+1 Problems
Chapter 17 : A Few More FAQs
FAQ 5 - How to Connect to a Different Database with Spring Boot?
FAQ 6 - Approach to Design Great Applications with JPA?
FAQ 7 - Good Practices for Developing JPA Applications
Chapter 18 : Congratulations
Congratulations
Chapter 19 : Appendix - Introduction to Spring Framework in 10 Steps
Introduction to Spring Framework in 10 Steps
Step 1 - Setting up a Spring Project Using htttp://start.spring.io
Step 2 - Understanding Tight Coupling Using the Binary Search Algorithm Example
Step 3 - Making the Binary Search Algorithm Example Loosely Coupled
Step 4 - Using Spring to Manage Dependencies - @Component, @Autowired
Step 5 - What is Happening in the Background?
Step 6 - Dynamic auto wiring and Troubleshooting - @Primary
Step 7 - Constructor and Setter Injection
Step 8 - Spring Modules
Step 9 - Spring Projects
Step 10 - Why is Spring Popular?