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 :