Master Hibernate and JPA with Spring Boot in 100 Steps

 

Master Hibernate and JPA with Spring Boot in 100 Steps

 

Salepage : Master Hibernate and JPA with Spring Boot in 100 Steps

Arichive : Master Hibernate and JPA with Spring Boot in 100 Steps

The Java Persistence API provides Java developers with an api for mapping java objects to relational data. In this course, you will learn about the JPA API, JPQL (Java Persistence query language), Java Persistence Criteria API and how you can perform ORM (Object Relational Mapping) with JPA.

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.

During this course

You will learn the basics of JPA and Hibernate – Entities, Relationships, Inheritance Mappings and Annotations

You will understand approaches to querying data using JPA and Hibernate – JPQL, Criteria API and Native Queries

You will understand JPA and Hibernate Relationships in depth – One to One, Many to One and Many to Many

You will use a variety of Spring Boot Starters – Spring Boot Starter Web, Starter Data Jpa, Starter Test

You will learn the basic of performance tuning your JPA application with Hibernate – Solve N+1 Queries Issue.

You will learn the basics of caching – First Level Cache and Second Level Cache with EhCache

You will understand the basics of Spring Data JPA and Spring Data REST

Below are the step by step details of the important sections of the course:

Journey from JDBC To JPA

Step01 – Setting up a project with JDBC, JPA, H2 and Web Dependencies

Step02 – Launching up H2 Console

Step03 – Creating a Database Table in H2

Step04 – Populate data into Person Table

Step05 – Implement findAll persons Spring JDBC Query Method

Step06 – Execute the findAll method using CommandLineRunner

Step07 – A Quick Review – JDBC vs Spring JDBC

Step08 – Whats in the background? Understanding Spring Boot Autoconfiguration

Step09 – Implementing findById Spring JDBC Query Method

Step10 – Implementing deleteById Spring JDBC Update Method

Step11 – Implementing insert and update Spring JDBC Update Methods

Step12 – Creating a custom Spring JDBC RowMapper

Step13 – Quick introduction to JPA

Step14 – Defining Person Entity

Step15 – Implementing findById JPA Repository Method

Step16 – Implementing insert and update JPA Repository Methods

Step17 – Implementing deleteById JPA Repository Method

Step18 – Implementing findAll using JPQL Named Query

JPA/Hibernate in Depth

Step01 – Create a JPA Project with H2 and Spring Boot

Step02 – Create JPA Entity Course

Step03 – Create findById using JPA Entity Manager

Step04 – Configuring application.properties to enable H2 console and additional logging

Step05 – Writing Unit Test for findById method

Step06 – Writing a deleteByID method to delete an Entity

Step07 – Writing Unit Test for deleteById method

Step08 – Writing a save method to update and insert an Entity

Step09 – Writing Unit Test for save method

Step10 – Quick Review and Debugging Tips

Step11 – Playing with Entity Manager

Step12 – Entity Manager Methods – clear and detach

Step13 – Entity Manager Methods – refresh

Step14 – A Quick Review of Entity Manager

Step15 – JPQL – Basics

Step16 – JPA and Hibernate Annotations – @Table

Step17 – JPA and Hibernate Annotations – @Column

Step18 – JPA and Hibernate Annotations – @UpdateTimestamp and @CreationTimestamp

Step19 – JPA and Hibernate Annotations – @NamedQuery and @NamedQueries

Step20 – Native Queries – Basics

Step21 – Entities and Relationships – An overview

Step22 – Defining Entities – Student, Passport and Review

Step23 – Introduction to One to One Relationship

Step24 – OneToOne Mapping – Insert Student with Passport

Step25 – OneToOne Mapping – Retrieving Student with Passport and Eager Fetch

Step26 – OneToOne Mapping – Lazy Fetch

Step27 – Session vs Transaction

Step28 – OneToOne Mapping – Bidirectional Relationship – Part 1

Step29 – OneToOne Mapping – Bidirectional Relationship – Part 2

Step30 – ManyToOne Mapping – Designing the database

Step31 – ManyToOne Mapping – Retrieving and inserting Reviews for Course

Step32 – ManyToOne Mapping – Generalizing Insert Reviews

Step33 – ManyToOne Mapping – Wrapping up

Step34 – ManyToMany Mapping – Table Design

Step35 – ManyToMany Mapping – Adding Annotations on Entities

Step36 – ManyToMany Mapping – Fixing two join tables problem

Step37 – ManyToMany Mapping – Customizing the Join Table

Step38 – ManyToMany Mapping – Insert Data and Write Join Query

Step39 – ManyToMany Mapping – Retrieve Data using JPA Relationships

Step40 – ManyToMany Mapping – Insert Student and Course

Step41 – Relationships between JPA Entities – A summary

Step42 – Introduction to Inheritance Hierarchies and Mappings

Step43 – JPA Inheritance Hierarchies and Mappings – Setting up entities

Step44 – JPA Inheritance Hierarchies and Mappings – Setting up a Repository

Step45 – JPA Inheritance Hierarchies and Mappings – Single Table

Step46 – JPA Inheritance Hierarchies and Mappings – Table Per Class

Step47 – JPA Inheritance Hierarchies and Mappings – Joined

Step48 – JPA Inheritance Hierarchies and Mappings – Mapped Super Class

Step49 – JPA Inheritance Hierarchies and Mappings – How to Choose?

Step50 – JPQL – Courses without Students

Step51 – JPQL – Courses with atleast 2 Students and order by

Step52 – JPQL – Courses like 100 Steps

Step53 – JPQL – Using Joins

Step54 – Criteria Query – Retrieving all courses

Step55 – Criteria Query – Courses like 100 Steps

Step56 – Criteria Query – Courses without Students

Step57 – Criteria Query – Using Joins

Step58 – Introduction to Transaction Management

Step59 – Transaction Management – ACID Properties

Step60 – Understanding Dirty, Phanthom and Non Repeatable Reads

Step61 – Understand 4 Isolation Levels

Step62 – Choosing between Isolation Levels

Step63 – Implementing Transaction Management – 3 Things to Decide

Step64 – Introduction to Spring Data JPA

Step65 – Testing the Spring Data JPA Repository with findById.

Step66 – Spring Data JPA Repository – CRUD Methosd

Step67 – Sorting using Spring Data JPA Repository

Step68 – Pagination using Spring Data JPA Repository

Step69 – Custom Queries using Spring Data JPA Repository

Step70 – Spring Data REST

Step71 – Introduction to Caching

Step72 – Hibernate and JPA Caching – First Level Cache

Step73 – Hibernate and JPA Caching – Basics of Second Level Cache with EhCache

Step74 – Hibernate and JPA Caching – Second Level Cache Part 2

Step75 – Hibernate Tips – Hibernate Soft Deletes – @SQLDelete and @Where

Step76 – Hibernate Soft Deletes – Part 2

Step77 – JPA Entity Life Cycle Methods

Step78 – Using Embedded and Embeddable with JPA

Step79 – Using Enums with JPA

Step80 – JPA Tip – Be cautious with toString method implementations

Step81 – JPA Tip – When do you use JPA?

Step82 – Performance Tuning – Measure before Tuning

Step83 – Performance Tuning – Indexes

Step84 – Performance Tuning – Use Appropriate Caching

Step85 – Performance Tuning – Eager vs Lazy Fetch

Step86 – Performance Tuning – Avoid N+1 Problems

Hibernate Tips & Tricks

When does Hibernate send updates to the database?

When do we need @Transactional in an Unit Test?

Do read only methods need a transaction?

Why do we use @DirtiesContext in an Unit Test?

How to connect to a different database with Spring Boot?

How do you approach designing great applications with JPA?

Good Practices for developing JPA Applications

Who is the target audience?

You want to learn the basics of JPA and Hibernate

You want to understand how to build data layer of a web application

Requirements

You should have working knowledge of Java and Annotations.

We will help you install Eclipse and get up and running with all frameworks, Maven and Embedded Tomcat.

Course Curriculum

Introduction

 Start0000.0001—Master-Hibernate-and-JPA-with-Spring-Boot—Preview (3:00)

 Start0000.0002—Master-Hibernate-and-JPA-with-Spring-Boot—Course-Overview (3:04)

 Start0000.0003—Master-Hibernate-and-JPA-with-Spring-Boot—Git-Repository (2:30)

 Start0000.0004—Master-Hibernate-and-JPA-with-Spring-Boot—Installing-Basic-Tools (1:33)

 Start0000.0005—Quick-introduction-to-JPA (7:32)

Introduction to Spring Boot in 10 Steps

 StartSection-Introduction—Introduction-to-Spring-Boot-in-10-Steps (1:33)

 StartStep01-SpringBootGoalsAndImportantFeatures (6:11)

 StartStep02-DevelopingSpringApplicationsBeforeSpringBoot (3:46)

 StartStep03-UsingSpringInitializrToCreateASpringBootApplication (4:48)

 StartStep04-CreatingASimpleRESTController (5:03)

 StartStep05-WhatIsSpringBootAutoConfiguration? (9:07)

 StartStep06-SpringBootvsSpringvsSpringMVC (5:55)

 StartStep07-SpringBootStarterProjects-StarterWebandStarterJPA (7:39)

 StartStep08-OverviewOfSpringBootStarterProjects (4:01)

 StartStep09-UsingSpringBootActuatorToMonitorYourApplications-20180316 (8:48)

 StartStep10-IncreaseYourProductivityWithSpringBootDeveloperTools (4:12)

Journey From Spring JDBC to JPA

 StartIntroduction-to-Journey-from-JDBC-To-JPA (1:30)

 StartStep-01—Setting-up-a-project-with-JDBC,-JPA,-H2-and-Web-Dependencies (5:32)

 StartStep-02—Launching-up-H2-Console-20180316 (5:01)

 StartStep-03—Creating-a-Database-Table-in-H2 (3:54)

 StartStep-04—Populate-data-into-Person-Table (5:21)

 StartStep-05—Implement-findAll-persons-Spring-JDBC-Query-Method (6:15)

 StartStep-06—Execute-the-findAll-method-using-CommandLineRunner (5:45)

 StartStep-07—A-Quick-Review—JDBC-vs-Spring-JDBC (2:41)

 StartStep-08—Whats-in-the-background?-Understanding-Spring-Boot-Autoconfiguration (5:06)

 StartStep-09—Implementing-findById-Spring-JDBC-Query-Method (3:48)

 StartStep-10—Implementing-deleteById-Spring-JDBC-Update-Method (3:08)

 StartStep-11—Implementing-insert-and-update-Spring-JDBC-Update-Methods (8:39)

 StartStep-12—Creating-a-custom-Spring-JDBC-RowMapper (4:58)

 StartStep-13—Quick-introduction-to-JPA (5:54)

 StartStep-14—Defining-Person-Entity (4:03)

 StartStep-15—Implementing-findById-JPA-Repository-Method (8:06)

 StartStep-16—Implementing-insert-and-update-JPA-Repository-Methods (3:51)

 StartStep-17—Implementing-deleteById-JPA-Repository-Method (2:10)

 StartStep-18—Implementing-findAll-using-JPQL-Named-Query (4:03)