Categories

There are currently no items in your shopping cart.

User Panel

Forgot your password?.

Master Hibernate and JPA with Spring Boot in 100 Steps

Video Introducing this tutorial

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

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

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

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

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

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

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?

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

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?

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

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

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

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

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

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?

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

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

Congratulations:
Congratulations

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?