->
Udemy - Master Hibernate and JPA with Spring Boot in 100 Steps
Udemy - Master Hibernate and JPA with Spring Boot in 100 Steps

Hibernate is the most popular Java ORM framework.  Almost every Real World Project today uses JPA and Hibernate in combination with Spring Boot.


Description

Hibernate is the most popular Java ORMframework. Almost every Real World Project today uses JPA and Hibernate in combination with Spring Boot.

Do you want to Learn JPA & Hibernate and use them in combination with Spring Boot? Do you want to Learn about Entities, Relationships, Entity Manager, JPQL, Native Queries, Inheritance Hierarchies, Criteria API, Transaction Management, Caching and Performance Tuning with JPA &Hibernate in combination with Spring Data JPAand Spring Data REST?

******* Some Amazing Reviews From Our Learners *******

★★★★★ I really loved this course. The instructor explains features of JPA and Hibernate clearly and also very deeply. Especially I liked explanation of the transaction management what I didn't seen in other courses.By the way this course helped me to develop the persistence layer of a commercial application for my customer.

★★★★★ Absolute brilliant course, I was struggling using books but this course helped me understand using code to demonstrate how Hibernate and JPA work. Each video builds on the next and is at a pace that does not overwhelm you. I thoroughly recommend this course if you need to improve your Hibernate and JPA knowledge.

★★★★★ It is really state of the art and how spring boot and hibernate are used nowadays! This course was very helpful in my new job, since in the project we use spring boot and hibernate. Thank you!

★★★★★ This course exceeded my expectations, I thought I knew about hibernate but I discovered I didn't, I really recommend this course.

★★★★★ Thanks Ranga for the wonderful course on Hibernate and JPA with Spring Boot! It's a long course and well worth it. Keep up the great work!

******* Course Overview *******

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.

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 Hibernate, JPA API, JPQL (Java Persistence query language), Java Persistence Criteria API and how you can perform ORM (Object Relational Mapping) with JPA and Hibernate.

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

******* What You Can Expect from Every in28Minutes Course *******

in28Minutes created 20 Best Selling Courses providing Amazing Learning Experiences to 250,000 Learners across the world.

Each of these courses come with

✔ Amazing Hands-on Step By Step Learning Experiences

✔ Real Project Experiences using the Best Tools and Frameworks

✔ Awesome Troubleshooting Guides with 200+ FAQs Answered

✔ Friendly Support in the Q&A section

✔ Free Udemy Certificate of Completion on Completion of Course

~~~ Here are a Few Reviews on The in28Minutes Way ~~~

★★★★★ Excellent, fabulous. The way he has prepared the material and the way he teaches is really awesome. What an effort .. Thanks a million

★★★★★ A lot of preparation work has taken place from the teacher and this is visible throughout the course.

★★★★★ This guy is fantastic. Really. Wonderful teaching skills, and goes well out of his way to make sure that everything he is doing is fully understood. This is the kind of tutorial that gets me excited to work with a framework that I may otherwise not be.

★★★★★ The best part of it is the hands-on approach which the author maintained throughout the course as he had promised at the beginning of the lecture. He explains the concepts really well and also makes sure that there is not a single line of code you type without understanding what it really does.

★★★★★ I also appreciate the mind and hands approach of teaching something and then having the student apply it. It makes everything a lot clearer for the student and uncovers issues that we will face in our project early.

★★★★★ Amazing course. Explained super difficult concepts (that I have spent hours on the internet finding a good explanation) in under 5 minutes.

Start Learning Now. Hit the Enroll Button!

******* Step By Step Details *******

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 approachdesigning great applications with JPA?

    • Good Practices for developing JPA Applications

    Start Learning Now. Hit the Enroll Button!

    Bu kurs kimler için uygun:
    • You want to learn the basics of JPA and Hibernate
    • You want to understand how to build data layer of a web application

    Course content

    • Introduction
      • Master Hibernate and JPA with Spring Boot - Preview
      • Congratulations
      • One Thing You Should Do
      • 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
      • Fastest Approach to Solve All Your Exceptions
      • Step 4 : Creating a Simple REST Controller
      • Step 5 : What is Spring Boot Auto Configuration?
      • Step 6 : Spring Boot vs Spring vs 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 vs Spring JDBC
      • Step 08 - Whats 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 findById method
      • Step 06 - Writing a deleteByID method to delete an Entity
      • Step 07 - Writing Unit Test for deleteById method
      • Step 08 - Writing a save method to update and insert an Entity
      • Step 09 - Writing Unit Test for 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 & @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
    • Let's 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 an Unit Test?
      • FAQ 3 - Do read only methods need a transaction?
      • FAQ 4 - Why do we use @DirtiesContext in an 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 atleast 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 & 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 & JPA
      • Step 71 - Introduction to Caching
      • 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 & 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 & 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 vs Lazy Fetch
      • Step 86 - Performance Tuning - Avoid N+1 Problems
    • Few more FAQ
      • 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
      • Bonus Lecture
      • 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?


     TO MAC USERS: If RAR password doesn't work, use this archive program: 

    RAR Expander 0.8.5 Beta 4  and extract password protected files without error.


     TO WIN USERS: If RAR password doesn't work, use this archive program: 

    Latest Winrar  and extract password protected files without error.


     osheemex   |  

    Information
    Members of Guests cannot leave comments.




    rss