JPA & Hibernate: Complete Course with Online Shop Example

• What is ORM

• What is JPA

• What is Hibernate

• ORM Frameworks

• JPA VS ORM VS Hibernate

• JPA Advantages

• Create a JPA project

• Entities in JPA

• Entity Annotation

• Table Annotation

• Column Annotation

• ID Annotation

• Generated Value Annotation

• GenerationType.TABLE

• GenerationType.SEQUENCE

• GenerationType.IDENTITY

• GenerationType.UUID

• GenerationType.AUTO

• Requirements for Entity Class

• Composite Primary Keys

• Temporal Annotation

• Non-persisted fields (Transient Annotation)

• Persist Enum types (Enumerated Annotation)

• Entity Manager Factory

• Entity Manager

• persistence.xml

• Transactions in JPA

• Transaction Types in JPA

• JTA VS RESOURCE_LOCAL

• Practical Exercise

• Insert JPA Entity

• Select JPA Entity

• Update JPA Entity

• Delete JPA Entity

• States of JPA Entity

• New (Transient) State

• Persistent (Managed) State

• Detached (Unmanaged) State

• Removed (Deleted) State

• Handling of JPA Entity Lifecycle events

• Entity Lifecycle Listener

• Why we need locking

• What is a Database Lock

• Physical Locks

• Logical Locks

• Locking in JPA

• Optimistic Locking

• Pessimistic Locking

• Optimistic VS Pessimistic locking

• @Version Annotation

• Explicit Lock Type

• LockModeType Enum

• Coding Demo

• Use case: When to use mapping in JPA

• Types of Relationships in Relational Databases

• Mapping Directions

• Types of Mapping in JPA

• @OneToOne

• @OneToMany & @ManyToOne

• @ManyToMany

• How to Cascade operations with Entities

• CascadeType Enum

• Eager and Lazy Fetch Types

• @JoinColumn

• @JoinTable

• Types of queries in JPA

• Query, TypedQuery, NamedQuery

• NativeQuery

• Criteria API

• What is a JPQL

• Key JPQL features

• Property to Show SQL queries sent to the DB

• Practical Exercises

• What is Caching

• Cache structure in JPA/Hibernate

• First-level cache

• Second-level cache

• Query-level cache

• Cache providers

• CacheConcurencyStrategies

• Ehcache

• Cache Eviction Policy

• Custom configuration of Ehcache

• StandardQueryCache

• UpdateTimestampsCache

• Persistence Strategies in Ehcache

• Practical examples

• What is N+1 problem

• Why it is important to avoid it

• N+1 problem solutions

• Entity Graph

• @NamedEntityGraph Annotation

• @NamedAttributeNode Annotation

• Connection Pool in JPA

• C3P0 for Hibernate connection pool

• Pagination in JPA

• LazyInitializationException

• PersistenceException

• Spring Data: Overview

• Spring Data Modules

• Spring Data JPA: Overview

• JPA Repositories

• Repository pattern

• Spring Data JPA Advantages & Disadvantages

• Configuration of the Spring Data JPA

• Creation of JPA Repository

• JPQL Queries in JPA Repository

• Native SQL Queries in JPA Repository

• Naming convention for methods in JPA Repository

• End-to-end live demo

During the exam task you are going to take template of the multimodule project - online shop, and integrate Spring Data JPA into the persistence module of the application.

• JDBC Overview

• Why we need Spring JDBC

• Problems of JDBC API

• Spring Data JDBC VS Spring JDBC

• JbdcTemplate

• NamedParameterJdbcTemplate

• SimpleJdbcInsert

• SimpleJdbcCall

• Spring JDBC packages overview

• Practical code examples

• Configuration of dependency for Spring JDBC

• Configuration of required beans for Spring JDBC

• JdbcTeamplate example

• NamedParameterJdbcTemplate example

• SimpleJdbcInsert example

• SimpleJdbcCall example

• Batch update with SqlParameterSourceUtils

• RowMapper

During the exam task you are going to take a template of the multimodule project - online shop, and integrate Spring JDBC into the persistence module of the application.

In this lab, you will design and implement a simple relational database for managing users and their orders.

You’ll start by creating the core tables, establish one-to-many relationships, and then write SQL queries to explore and analyze the data.

By the end of this lab, you’ll have practiced key relational database concepts: primary keys, foreign keys, joins, filtering, and aggregate functions.

This lab simulates a real-world business scenario where each user can have multiple orders, and we need to analyze their purchase activity efficiently.

• Create Database and Tables

  • Create a new database named user_orders_lab.

  • Create users and orders tables with proper primary and foreign keys.

• Insert Initial Data

  • Populate both tables with at least 3–4 users and 5–6 orders.

  • Ensure that at least one user has multiple orders.

• Display and Inspect Data

  • Run SELECT * queries to verify that data has been inserted correctly.

• Join Data Across Tables

  • Write a JOIN query to display each order along with the corresponding user name.

• Aggregation Analysis

  • Calculate total spending per user using SUM and GROUP BY.

  • Order the results by total amount descending.

• Advanced Querying

  • Find users with more than one order (HAVING COUNT > 1).

  • Identify the most expensive order using a subquery.

In this lab, you will analyze a dataset of users and their orders to uncover meaningful business insights using SQL aggregate functions and subqueries.

You’ll calculate totals, averages, and counts, identify top customers, and use nested SELECT statements to compare individual data points to group-wide metrics.

By the end of this lab, you’ll be confident in using COUNT, SUM, AVG, MIN, MAX, GROUP BY, HAVING, and subqueries — all essential tools for data-driven decision-making in real-world projects.

• Explore the Dataset: Display all records from both tables using SELECT *.

• Basic Aggregations: Use COUNT, AVG, MIN, MAX to get overall order statistics.

• User-Level Analysis: Calculate total and average spending per user using GROUP BY.

• Country-Level Report: Group by country to see total orders and revenue per region.

• Filtering with HAVING: Show only users whose total spending is above 500.

• Subqueries for Comparison: Find users whose average order value is greater than the overall average order value.

• Nested Subqueries: Find the largest order per country using a correlated subquery.

In this lab, you’ll work with a company database that includes employees, departments, and salaries.

You will learn how to filter and sort records using various SQL clauses (WHERE, LIKE, BETWEEN, IN, ORDER BY, LIMIT) and explore different types of joins (INNER, LEFT, RIGHT, CROSS) to connect related tables.

By the end of this lab, you’ll know how to query complex datasets effectively, extract relevant information, and analyze relationships between employees and their departments.

These are real-world skills used daily by data analysts, engineers, and backend developers working with relational databases.

• Filter by Salary and Hire Date: Display employees earning more than 80,000 who were hired before 2021.

• Pattern Matching with LIKE: Find employees whose last name starts with “W” or whose position contains the word “Engineer”.

• Filtering with IN and BETWEEN: Show employees from Engineering or Finance earning between 75,000 and 125,000.

• Sorting and Limiting Results: List the top 3 highest-paid employees.

• INNER JOIN Practice: Display all employees with their department names using INNER JOIN.

• LEFT and RIGHT JOIN Comparison: Compare LEFT JOIN and RIGHT JOIN results — notice the difference in unmatched records.

• CROSS JOIN Exploration: Generate all combinations of employees and departments, limited to 10 rows for readability.