Master Hibernate and JPA with Spring Boot in 100 Steps
Salepage : Master Hibernate and JPA with Spring Boot in 100 Steps
Archive : Master Hibernate and JPA with Spring Boot in 100 Steps Digital Download
Delivery : Digital Download Immediately
The Java Persistence API allows Java developers to bind java objects to relational data. You will learn about the JPA API, JPQL (Java Persistence query language), Java Persistence Criteria API, and how to conduct ORM (Object Relational Mapping) using JPA in this course.
Hibernate is the most widely used JPA implementation. It was the most common ORM framework choice before JPA, and it adds functionalities on top of JPA. In this course, we will utilize Hibernate to implement JPA.
Throughout this course
You will be introduced to the fundamentals of JPA and Hibernate, including Entities, Relationships, Inheritance Mappings, and Annotations.
You will learn how to query data with JPA and Hibernate utilizing JPQL, Criteria API, and Native Queries.
You will gain a thorough understanding of JPA and Hibernate relationships – one to one, many to one, and many to many.
Spring Boot Starters such as Spring Boot Starter Web, Starter Data Jpa, and Starter Test will be used.
You will study the fundamentals of improving your JPA application’s performance using Hibernate – Solve N+1 Queries Issue.
You will study the basics of caching – First Level Cache and Second Level Cache using EhCache
You will be familiar with the fundamentals of Spring Data JPA and Spring Data REST.
The following components of the course are detailed step by step:
JDBC to JPA Transition
Step 1: Create a project using JDBC, JPA, H2, and Web Dependencies.
Step 2: Open the H2 Console
Step 3: Make a Database Table in H2
Step 04: Enter data into the Person Table
Step05 – Use the Spring JDBC Query Method to find all people.
Step 06 – Using CommandLineRunner, run the findAll function.
Step 07: A Quick Review of JDBC vs. Spring JDBC
Step08 – What’s going on in the background? Understanding Autoconfiguration in Spring Boot
Implementing the findById Spring JDBC Query Method
Step 10: Use the deleteById Spring JDBC Update Method.
Step 11: Implementing Spring JDBC Update Methods for Insert and Update
Step 12: Develop a Custom Spring JDBC RowMapper
Step 13 – A brief overview of JPA
Step 14 – Person Entity Definition
Step 15: Use the findById JPA Repository Method.
Step 16: Implementing JPA Repository Insert and Update Methods
Step 17: Use the deleteById JPA Repository Method.
Step 18: Using JPQL Named Query to Implement findAll
In-Depth JPA/Hibernate
Step 1: Make a JPA project using H2 and Spring Boot.
Step 2: Make a JPA Entity Course
Step 3: Use JPA Entity Manager to create findById.
Step 04: Configure the program.
settings for enabling the H2 console and extra logging
Step 5: Create a unit test for the findById function.
Step06: Create a deleteByID method to delete an entity.
Step 07: Create a unit test for the deleteById function.
Step 8: Create a save method to update and insert an entity.
Step 9: Create a unit test for the save function.
Step 10 – Quick Review and Troubleshooting
Step 11 – Experimenting with Entity Manager
Step 12 – Entity Manager Methods – disconnect and clean
Step 13 – Refresh Entity Manager Methods
Step 14 – An Overview of Entity Manager
Step 15 – JPQL – Fundamentals
Step 16 – @Table JPA and Hibernate Annotations
Step 17 – @Column JPA and Hibernate Annotations
Step 18 – Annotations for JPA and Hibernate – @UpdateTimestamp and @CreationTimestamp
Step 19 – Annotations for JPA and Hibernate – @NamedQuery and @NamedQueries
Step 20 – Native Queries – Fundamentals
Step 21 – Overview of Entities and Relationships
Step 22 – Establishing Entities – Student, Passport, and Review
Step 23 – Establishing a One-to-One Relationship
Step 24 – OneToOne Mapping – Insert Passport Student
Step 25 – One-to-One Mapping – Locating a Student with a Passport and an Eager Fetch
Step26 – Lazy Fetch – OneToOne Mapping
Step 27 – Transaction vs. Session
Part 1 of Step28 – OneToOne Mapping – Bidirectional Relationship
Part 2 of Step 29 – OneToOne Mapping – Bidirectional Relationship
Step 30 – ManyToOne Mapping – Database Design
Step 31 – ManyToOne Mapping – Retrieving and Inserting Course Reviews
Step32 – ManyToOne Mapping – Insert Review Generalization
Step 33 – ManyToOne Mapping – Finishing
Table Design – Step 34 – ManyToMany Mapping
Step35 – ManyToMany Mapping – Adding Entity Annotations
Step 36 – ManyToMany Mapping – Troubleshooting two connect tables
Step37 – ManyToMany Mapping – Creating a Custom Join Table
Step 38: Insert Data and Write Join Query for ManyToMany Mapping
Step 39 – ManyToMany Mapping – Data Retrieval Using JPA Relationships
Step 40 – Insert Student and Course into ManyToMany Mapping
Step 41 – JPA Entity Relationships – A Summary
Step 42 – Overview of Inheritance Hierarchies and Mappings
Setting up entities in Step 43 – JPA Inheritance Hierarchies and Mappings
Step 44: JPA Inheritance Hierarchies and Mappings – Configuring a Repository
Step 45 – JPA Hierarchies and Mappings – Single Table
JPA Inheritance Hierarchies and Mappings – Table Per Class
Step47 – Joined JPA Inheritance Hierarchies and Mappings
JPA Inheritance Hierarchies and Mappings – Mapped Super Class Step 48
Step49 – JPA Inheritance Hierarchies and Mappings – How to Choose?
JPQL – Courses without Students – Step50
Step51 – JPQL – Courses with at least 2 students and sorted alphabetically
Step52 – JPQL – Courses Similar to 100 Steps
Step53: Using Joins in JPQL
Step54 – Query Criteria – Retrieve all courses
Step55 – Criteria Query – 100 Steps Courses
Step56 – Query Criteria – Courses with No Students
Step57 – Using Joins in Criteria Queries
Step 58 – Transaction Management Overview
Transaction Management – ACID Properties (Step59)
Step 60 – Recognize Dirty, Phanthom, and Non-Repeatable Reads
Step 61 – Recognize the 4 Isolation Levels
Step62 – Selecting an Isolation Level
Step 63 – Implementing Transaction Management – Three Decisions
Step64 – Spring Data JPA Overview
Step65: Use findById to test the Spring Data JPA Repository.
Spring Data JPA Repository – CRUD Methosd Step66
Step 67: Sorting with the Spring Data JPA Repository
Step 68 – Spring Data JPA Repository Pagination
Step 69 – Spring Data JPA Repository Custom Queries
Spring Data REST – Step 70
Step 71 – Caching Overview
Caching in Hibernate and JPA – First Level Cache
Step73 – Hibernate and JPA Caching – Second Level Cache Fundamentals with EhCache
Part 2 of Step74 – Hibernate and JPA Caching – Second Level Cache
Hibernate Tips – Hibernate Soft Deletes – @SQLDelete and @Where
Part 2 of Step76 – Hibernate Soft Deletes
JPA Entity Life Cycle Methods, Step 77
Using Embedded and Embeddable with JPA in Step78
Step 79: Using Enums in JPA
Step80 – JPA Tip – Use caution while implementing toString methods.
JPA Tip 81: When do you utilize JPA?
Step82 – Tuning Performance – Measure Before Tuning
Step 83 – Indexes for Performance Tuning
Step84 – Performance Optimization – Make Use of Appropriate Caching
Performance Tuning – Eager vs. Lazy Fetch
Step86 – Performance Optimization – Avoid N+1 Issues
Hibernate Hints & Tips
When does Hibernate deliver database updates?
When is @Transactional required in a unit test?
Is a transaction required for read-only methods?
Why is @DirtiesContext used in a Unit Test?
How does Spring Boot connect to a separate database?
How do you go about creating amazing JPA applications?
JPA Application Development Best Practices
Who is the intended audience?
You’d want to study the fundamentals of JPA and Hibernate.
You wish to learn how to create a web application’s data layer.
Requirements
You should be familiar with Java and Annotations.
We will assist you in installing Eclipse and getting started with all frameworks, Maven, and Embedded Tomcat.
Curriculum of the Course
Introduction
Start0000.0001—-Master-Hibernate-and-JPA-with-Spring-Boot—-Preview (3:00) (3:00)
Start0000.0002—-Master-Hibernate-and-JPA-with-Spring-Boot—-Course-Overview (3:04) (3:04)
Start0000.0003—-Master-Hibernate-and-JPA-with-Spring-Boot—-Git-Repository (2:30) (2:30)
Start0000.0004—-Master-Hibernate-and-JPA-with-Spring-Boot—-Installing-Basic-Tools (1:33) (1:33)
Start0000.0005—-Quick-introduction-to-JPA (7:32) (7:32)
10 Steps to Understanding Spring Boot
StartSection-Introduction—-Introduction-to-Spring-Boot-in-10-Steps (1:33) (1:33)
StartStep01-SpringBootGoalsAndImportantFeatures (6:11) (6:11)
StartStep02-DevelopingSpringApplicationsBeforeSpringBoot (3:46) (3:46)
StartStep03-UsingSpringInitializrToCreateASpringBootApplication (4:48) (4:48)
StartStep04-CreatingASimpleRESTController (5:03) (5:03)
StartStep05-WhatIsSpringBootAutoConfiguration? (9:07) StartStep06-SpringBootvsSpringvsSpringMVC (5:55) (5:55) StartStep07-SpringBootStarterProjects-StarterWebandStarterJPA (7:39) (7:39) StartStep08-OverviewOfSpringBootStarterProjects (4:01) (4:01) StartStep09-UsingSpringBootActuatorToMonitorYourApplications-20180316 (8:48) (8:48) StartStep10-IncreaseYourProductivityWithSpringBootDeveloperTools (4:12) (4:12)
Spring JDBC to JPA Transition
StartIntroduction-to-Journey-from-JDBC-To-JPA (1:30) (1:30)
StartStep-01—-Setting-up-a-project-with-JDBC,-JPA,-H2-and-Web-Dependencies (5:32) (5:32)
StartStep-02—-Launching-up-H2-Console-20180316 (5:01) (5:01)
StartStep-03—-Creating-a-Database-Table-in-H2 (3:54) (3:54)
StartStep-04—-Populate-data-into-Person-Table (5:21) (5:21)
StartStep-05—-Implement-findAll-persons-Spring-JDBC-Query-Method (6:15) (6:15)
StartStep-06—-Execute-the-findAll-method-using-CommandLineRunner (5:45) (5:45)
StartStep-07—-A-Quick-Review—-JDBC-vs-Spring-JDBC (2:41) (2:41)
StartStep-08—
Whats-in-the-background?
-Understanding-Spring-Boot-Autoconfiguration (5:06) (5:06)
StartStep-09—-Implementing-findById-Spring-JDBC-Query-Method (3:48) (3:48)
StartStep-10—-Implementing-deleteById-Spring-JDBC-Update-Method (3:08) (3:08)
StartStep-11—-Implementing-insert-and-update-Spring-JDBC-Update-Methods (8:39) (8:39)
StartStep-12—-Creating-a-custom-Spring-JDBC-RowMapper (4:58) (4:58)
StartStep-13—-Quick-introduction-to-JPA (5:54) (5:54)
StartStep-14—-Defining-Person-Entity (4:03) (4:03)
StartStep-15—-Implementing-findById-JPA-Repository-Method (8:06) (8:06)
StartStep-16—-Implementing-insert-and-update-JPA-Repository-Methods (3:51) (3:51)
StartStep-17—-Implementing-deleteById-JPA-Repository-Method (2:10) (2:10)
StartStep-18—-Implementing-findAll-using-JPQL-Named-Query (4:03) (4:03)
More from Categories :
Reviews
There are no reviews yet.