Master Hibernate and JPA with Spring Boot in 100 Steps
4.6 (39 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
2,989 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Master Hibernate and JPA with Spring Boot in 100 Steps to your Wishlist.

Add to Wishlist

Master Hibernate and JPA with Spring Boot in 100 Steps

Learn fundamentals of Java Persistence API (JPA) and Hibernate framework using Spring and Spring Boot
Best Seller
4.6 (39 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
2,989 students enrolled
Last updated 9/2017
English
Price: $200
30-Day Money-Back Guarantee
Includes:
  • 13 hours on-demand video
  • 1 Article
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • 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
View Curriculum
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.
Description

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

  1. Step01 - Setting up a project with JDBC, JPA, H2 and Web Dependencies
  2. Step02 - Launching up H2 Console
  3. Step03 - Creating a Database Table in H2
  4. Step04 - Populate data into Person Table
  5. Step05 - Implement findAll persons Spring JDBC Query Method
  6. Step06 - Execute the findAll method using CommandLineRunner
  7. Step07 - A Quick Review - JDBC vs Spring JDBC
  8. Step08 - Whats in the background? Understanding Spring Boot Autoconfiguration
  9. Step09 - Implementing findById Spring JDBC Query Method
  10. Step10 - Implementing deleteById Spring JDBC Update Method
  11. Step11 - Implementing insert and update Spring JDBC Update Methods
  12. Step12 - Creating a custom Spring JDBC RowMapper
  13. Step13 - Quick introduction to JPA
  14. Step14 - Defining Person Entity
  15. Step15 - Implementing findById JPA Repository Method
  16. Step16 - Implementing insert and update JPA Repository Methods
  17. Step17 - Implementing deleteById JPA Repository Method
  18. Step18 - Implementing findAll using JPQL Named Query

JPA/Hibernate in Depth

  1. Step01 - Create a JPA Project with H2 and Spring Boot
  2. Step02 - Create JPA Entity Course
  3. Step03 - Create findById using JPA Entity Manager
  4. Step04 - Configuring application.properties to enable H2 console and additional logging
  5. Step05 - Writing Unit Test for findById method
  6. Step06 - Writing a deleteByID method to delete an Entity
  7. Step07 - Writing Unit Test for deleteById method
  8. Step08 - Writing a save method to update and insert an Entity
  9. Step09 - Writing Unit Test for save method
  10. Step10 - Quick Review and Debugging Tips
  11. Step11 - Playing with Entity Manager
  12. Step12 - Entity Manager Methods - clear and detach
  13. Step13 - Entity Manager Methods - refresh
  14. Step14 - A Quick Review of Entity Manager
  15. Step15 - JPQL - Basics
  16. Step16 - JPA and Hibernate Annotations - @Table
  17. Step17 - JPA and Hibernate Annotations - @Column
  18. Step18 - JPA and Hibernate Annotations - @UpdateTimestamp and @CreationTimestamp
  19. Step19 - JPA and Hibernate Annotations - @NamedQuery and @NamedQueries
  20. Step20 - Native Queries - Basics
  21. Step21 - Entities and Relationships - An overview
  22. Step22 - Defining Entities - Student, Passport and Review
  23. Step23 - Introduction to One to One Relationship
  24. Step24 - OneToOne Mapping - Insert Student with Passport
  25. Step25 - OneToOne Mapping - Retrieving Student with Passport and Eager Fetch
  26. Step26 - OneToOne Mapping - Lazy Fetch
  27. Step27 - Session vs Transaction
  28. Step28 - OneToOne Mapping - Bidirectional Relationship - Part 1
  29. Step29 - OneToOne Mapping - Bidirectional Relationship - Part 2
  30. Step30 - ManyToOne Mapping - Designing the database
  31. Step31 - ManyToOne Mapping - Retrieving and inserting Reviews for Course
  32. Step32 - ManyToOne Mapping - Generalizing Insert Reviews
  33. Step33 - ManyToOne Mapping - Wrapping up
  34. Step34 - ManyToMany Mapping - Table Design
  35. Step35 - ManyToMany Mapping - Adding Annotations on Entities
  36. Step36 - ManyToMany Mapping - Fixing two join tables problem
  37. Step37 - ManyToMany Mapping - Customizing the Join Table
  38. Step38 - ManyToMany Mapping - Insert Data and Write Join Query
  39. Step39 - ManyToMany Mapping - Retrieve Data using JPA Relationships
  40. Step40 - ManyToMany Mapping - Insert Student and Course
  41. Step41 - Relationships between JPA Entities - A summary
  42. Step42 - Introduction to Inheritance Hierarchies and Mappings
  43. Step43 - JPA Inheritance Hierarchies and Mappings - Setting up entities
  44. Step44 - JPA Inheritance Hierarchies and Mappings - Setting up a Repository
  45. Step45 - JPA Inheritance Hierarchies and Mappings - Single Table
  46. Step46 - JPA Inheritance Hierarchies and Mappings - Table Per Class
  47. Step47 - JPA Inheritance Hierarchies and Mappings - Joined
  48. Step48 - JPA Inheritance Hierarchies and Mappings - Mapped Super Class
  49. Step49 - JPA Inheritance Hierarchies and Mappings - How to Choose?
  50. Step50 - JPQL - Courses without Students
  51. Step51 - JPQL - Courses with atleast 2 Students and order by
  52. Step52 - JPQL - Courses like 100 Steps
  53. Step53 - JPQL - Using Joins
  54. Step54 - Criteria Query - Retrieving all courses
  55. Step55 - Criteria Query - Courses like 100 Steps
  56. Step56 - Criteria Query - Courses without Students
  57. Step57 - Criteria Query - Using Joins
  58. Step58 - Introduction to Transaction Management
  59. Step59 - Transaction Management - ACID Properties
  60. Step60 - Understanding Dirty, Phanthom and Non Repeatable Reads
  61. Step61 - Understand 4 Isolation Levels
  62. Step62 - Choosing between Isolation Levels
  63. Step63 - Implementing Transaction Management - 3 Things to Decide
  64. Step64 - Introduction to Spring Data JPA
  65. Step65 - Testing the Spring Data JPA Repository with findById.
  66. Step66 - Spring Data JPA Repository - CRUD Methosd
  67. Step67 - Sorting using Spring Data JPA Repository
  68. Step68 - Pagination using Spring Data JPA Repository 
  69. Step69 - Custom Queries using Spring Data JPA Repository 
  70. Step70 - Spring Data REST
  71. Step71 - Introduction to Caching
  72. Step72 - Hibernate and JPA Caching - First Level Cache
  73. Step73 - Hibernate and JPA Caching - Basics of Second Level Cache with EhCache
  74. Step74 - Hibernate and JPA Caching - Second Level Cache Part 2
  75. Step75 - Hibernate Tips - Hibernate Soft Deletes - @SQLDelete and @Where
  76. Step76 - Hibernate Soft Deletes - Part 2
  77. Step77 - JPA Entity Life Cycle Methods
  78. Step78 - Using Embedded and Embeddable with JPA
  79. Step79 - Using Enums with JPA
  80. Step80 - JPA Tip - Be cautious with toString method implementations
  81. Step81 - JPA Tip - When do you use JPA?
  82. Step82 - Performance Tuning - Measure before Tuning
  83. Step83 - Performance Tuning - Indexes
  84. Step84 - Performance Tuning - Use Appropriate Caching
  85. Step85 - Performance Tuning - Eager vs Lazy Fetch
  86. 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
Compare to Other JPA Courses
Curriculum For This Course
150 Lectures
13:00:36
+
Introduction to Spring Boot in 10 Steps
11 Lectures 01:00:53
Introduction to Spring Boot in 10 Steps
01:33

Step 1 : Introduction to Spring Boot - Goals and Important Features
06:11

Step 2 : Developing Spring Applications before Spring Boot
03:46

Step 3 : Using Spring Initializr to create a Spring Boot Application
04:48

Step 4 : Creating a Simple REST Controller
05:03

Step 5 : What is Spring Boot Auto Configuration?
09:07


Step 7 : Spring Boot Starter Projects - Starter Web and Starter JPA
07:39

Step 8 : Overview of different Spring Boot Starter Projects
04:01

Step 9 : Spring Boot Actuator
08:38

Step 10 : Spring Boot Developer Tools
04:12
+
Journey From Spring JDBC to JPA
19 Lectures 01:29:49
Introduction to Journey from JDBC To JPA
01:30

Step 01 - Setting up a project with JDBC, JPA, H2 and Web Dependencies
05:32

Step 02 - Launching up H2 Console
05:05

Step 03 - Creating a Database Table in H2
03:54

Step 04 - Populate data into Person Table
05:21

Step 05 - Implement findAll persons Spring JDBC Query Method
06:15

Step 06 - Execute the findAll method using CommandLineRunner
05:45

Step 07 - A Quick Review - JDBC vs Spring JDBC
02:41

Step 08 - Whats in the background? Understanding Spring Boot Autoconfiguration
05:06

Step 09 - Implementing findById Spring JDBC Query Method
03:48

Step 10 - Implementing deleteById Spring JDBC Update Method
03:08

Step 11 - Implementing insert and update Spring JDBC Update Methods
08:39

Step 12 - Creating a custom Spring JDBC RowMapper
04:58

Step 13 - Quick introduction to JPA
05:54

Step 14 - Defining Person Entity
04:03

Step 15 - Implementing findById JPA Repository Method
08:06

Step 16 - Implementing insert and update JPA Repository Methods
03:51

Step 17 - Implementing deleteById JPA Repository Method
02:10

Step 18 - Implementing findAll using JPQL Named Query
04:03
+
Introduction to JUnit in 5 Steps
6 Lectures 23:48
Introduction to JUnit in 5 Steps
01:08

Step 1 : What is JUnit and Unit Testing?
03:55

Step 2 : First JUnit Project and Green Bar
04:44

Step 3 : First Code and First Unit Test
05:07

Step 4 : Other assert methods
03:46

Step 5 : Important annotations
05:08
+
JPA and Hibernate in Depth
21 Lectures 02:03:05
Introduction to JPA and Hibernate in Depth
01:43

Step 01 - Create a JPA Project with H2 and Spring Boot
04:43

Step 02 - Create JPA Entity Course
04:04

Step 03 - Create findById using JPA Entity Manager
08:24

Step 04 - Configuring application.properties to enable H2 console and logging
07:08

Step 05 - Writing Unit Test for findById method
10:46

Step 06 - Writing a deleteByID method to delete an Entity
05:41

Step 07 - Writing Unit Test for deleteById method
04:33

Step 08 - Writing a save method to update and insert an Entity
03:23

Step 09 - Writing Unit Test for save method
05:51

Step 10 - Quick Review and Debugging Tips
07:16


Step 12 - Entity Manager Methods - clear and detach
05:32

Step 13 - Entity Manager Methods - refresh
06:31

Step 14 - A Quick Review of Entity Manager
02:10

Step 15 - JPQL - Basics
07:57

Step 16 - JPA and Hibernate Annotations - @Table
04:35

Step 17 - JPA and Hibernate Annotations - @Column
05:48

Step 18 - JPA and Hibernate Annotations - @UpdateTimestamp & @CreationTimestamp
07:08

Step 19 - JPA and Hibernate Annotations - @NamedQuery and @NamedQueries
04:21

Step 20 - Native Queries - Basics
08:15
+
Establishing Relationships with JPA and Hibernate - OneToOne
9 Lectures 01:02:01
Step 21 - Entities and Relationships - An overview
06:21

Step 22 - Defining Entities - Student, Passport and Review
09:30

Step 23 - Introduction to One to One Relationship
07:22

Step 24 - OneToOne Mapping - Insert Student with Passport
08:46

Step 25 - OneToOne Mapping - Retrieving Student with Passport and Eager Fetch
04:33

Step 26 - OneToOne Mapping - Lazy Fetch
04:50

Step 27 - Transaction, Entity Manager and Persistence Context
10:12

Step 28 - OneToOne Mapping - Bidirectional Relationship - Part 1
06:35

Step 29 - OneToOne Mapping - Bidirectional Relationship - Part 2
03:52
+
Let's review with a few FAQs about Hibernate and JPA
4 Lectures 17:07
FAQ 1 - When does Hibernate send updates to the database?
06:13

FAQ 2 - When do we need @Transactional in an Unit Test?
03:10

FAQ 3 - Do read only methods need a transaction?
04:58

FAQ 4 - Why do we use @DirtiesContext in an Unit Test?
02:46
+
Establishing Relationships with JPA and Hibernate - OneToMany and ManyToMany
13 Lectures 01:15:52
Step 30 - ManyToOne Mapping - Designing the database
04:34

Step 30 - Part 2 - ManyToOne Mapping - Implementing the Mapping
06:52

Step 31 - ManyToOne Mapping - Retrieving and inserting Reviews for Course
08:09

Step 32 - ManyToOne Mapping - Generalizing Insert Reviews
06:09

Step 33 - ManyToOne Mapping - Wrapping up
09:28

Step 34 - ManyToMany Mapping - Table Design
02:59

Step 35 - ManyToMany Mapping - Adding Annotations on Entities
04:44

Step 36 - ManyToMany Mapping - Fixing two join tables problem
03:27

Step 37 - ManyToMany Mapping - Customizing the Join Table
05:02

Step 38 - ManyToMany Mapping - Insert Data and Write Join Query
04:41

Step 39 - ManyToMany Mapping - Retrieve Data using JPA Relationships
07:11

Step 40 - ManyToMany Mapping - Insert Student and Course
08:38

Step 41 - Relationships between JPA Entities - A summary
03:58
+
Inheritance Hierarchies with JPA and Hibernate
8 Lectures 34:49
Step 42 - Introduction to Inheritance Hierarchies and Mappings
02:34

Step 43 - JPA Inheritance Hierarchies and Mappings - Setting up entities
04:13

Step 44 - JPA Inheritance Hierarchies and Mappings - Setting up a Repository
05:12

Step 45 - JPA Inheritance Hierarchies and Mappings - Single Table
05:31

Step 46 - JPA Inheritance Hierarchies and Mappings - Table Per Class
03:35

Step 47 - JPA Inheritance Hierarchies and Mappings - Joined
03:53

Step 48 - JPA Inheritance Hierarchies and Mappings - Mapped Super Class
05:14

Step 49 - JPA Inheritance Hierarchies and Mappings - How to Choose?
04:37
+
Queries with Entities using JPQL
4 Lectures 24:34
Step 50 - JPQL - Courses without Students
05:54

Step 51 - JPQL - Courses with atleast 2 Students and order by
03:57

Step 52 - JPQL - Courses like 100 Steps
04:22

Step 53 - JPQL - Using Joins
10:21
9 More Sections
About the Instructor
in28Minutes Official
4.3 Average rating
14,282 Reviews
88,113 Students
14 Courses
Popular Spring Framework Instructor - 80,000+ Students

About Me

I'm Ranga Karanam, an Architect with 15 Years of Java programming and design  with major banking clients across the world. 

We started in28Minutes with the aim to create Hands-on Courses with Real World Projects. Step-By-Step series of Courses is one of our creations.

About in28Minutes

We use Problem-Solution based Step-By-Step Hands-on Approach With Practical, Real World Application Examples.

While our primary expertise is on Development, Design & Architecture of Java & Related Frameworks (Spring, Spring Boot, Spring MVC, Struts, Hibernate) we are expanding into the front-end world (Bootstrap, JQuery, Angular JS).

Our Beliefs

Best Courses are interactive and fun.

Foundations for building high quality applications are best laid down while learning.

Our Approach

We love open source and therefore, All our code is open source too and available on Github.

We use 80-20 Rule. We discuss 20% things used 80% of time in depth. We touch upon other things briefly equipping you with enough knowledge to find out more on your own.

Problem Solution based Step by Step Hands-on Learning.