English | MP4 | AVC 1920×1080 | AAC 44KHz 2ch | 76 Lessons (5h 54m) | 958 MB
Master dependency injection and database integration with Spring Boot and Spring Data JPA
Spring Boot is the go-to framework for modern Java development. Whether you’re building web applications, microservices, or enterprise applications, Spring Boot simplifies the process by handling configuration, dependency management, and embedded servers—allowing you to build and deploy applications quickly.
Mastering Spring Boot isn’t just about writing better code—it’s also a great career move. Companies are actively hiring Spring Boot developers, with salaries ranging from $164K to $306K per year and a median of $219K, according to Glassdoor.
This course is the first part of a series designed to take you from zero to mastering Spring Boot. In this part, we focus on the fundamentals, ensuring you have a rock-solid understanding before moving on to building web applications and APIs in Part 2.
This isn’t just another Spring Boot course—it’s a clear, concise, and no-nonsense course that gets straight to the point. Every lesson is carefully structured to build on what you’ve learned, with real-world examples, best practices, and tips that most courses don’t cover.
If you’re looking for a well-organized, practical, and fluff-free Spring Boot course that gives you the skills to build real applications, this is the course for you!
What You’ll Learn
- Understand how Spring Boot manages objects and dependencies.
- Connect your application to a relational database.
- Manage application configuration using application.properties and YAML files.
- Use Spring Data repositories to interact with the database.
- Database-first vs. model-first workflows and when to use each approach.
- How Hibernate tracks entities and how transactions ensure data consistency.
- Optimize fetching strategies with eager and lazy loading to improve performance.
- Write custom queries with @Query, JPQL, and native SQL.
- Use projections to fetch only the necessary fields, reducing data load.
- Build dynamic queries with Query by Example, Criteria API, and Specifications API.
- Implement sorting and pagination to efficiently handle large datasets.
- Use Lombok to reduce boilerplate code and simplify entity classes.
- Leverage productivity tools to quickly generate entities, repositories, and queries.
- Apply best practices to structure your application and optimize performance.
Table of Contents
1 Welcome
2 Prerequisites
3 Course Structure
4 Source Code
5 Introduction
6 Introduction to Spring Boot
7 Setting up the Development Environment
8 Creating a Spring Boot Project
9 Understanding the Project Structure
10 Dependency Management
11 Building Your First Spring Controller
12 Running Spring Boot Applications
13 Debugging Spring Boot Applications
14 Automatic Restarts with Spring Boot DevTools
15 Configuring Application Properties
16 Introduction
17 What is Dependency Injection?
18 Constructor Injection
19 Setter Injection
20 The Spring IoC Container
21 Configuring Beans Using Annotations
22 Controlling Bean Selection
23 Exerise- Implementing a Notification Service
24 Externalizing Configuration
25 Configuring Beans Using Code
26 Lazy Initialization
27 Bean Scopes
28 Bean Lifecycle Hooks
29 Exercise- Implementing a User Registration Service
30 Introduction
31 JDBC, JPA, Spring Data JPA
32 Setting Up MySQL
33 Setting Up Spring Data JPA
34 Designing the Application Model
35 Creating the Database
36 Creating Database Tables
37 Database Migrations with Flyway
38 Chaning the Database Schema
39 Running Migrations Using Maven
40 Exercise- Creating the Profiles, and Tags Tables
41 Creating the Domain Model
42 Defining Entities
43 Simplifying Code with Lombok
44 Exercise- Defining the Address, Profile and Tag Entities
45 Defining One-To-Many Relationships
46 Defining Many-to-Many Relationships
47 Defining One-to-One Relationships
48 Exercise- Creating the Category and Product Entities
49 Generating Entities Using JPA Buddy
50 Model First with JPA Buddy
51 Exercise- Creating the Wishlist Table
52 Generating Database Tables with Hibernate
53 Creating Repositories
54 Defining Repositories
55 Using Repositories
56 Understanding Entity States
57 Managing Transactions
58 Fetching Strategies- Eager and Lazy Loading
59 Exercise- Understanding Fetching Strategies
60 Persisting Related Entities
61 Deleting Related Entities
62 Exercise- Managing Products and Wishlists
63 Writing Custom Queries
64 Derived Query Methods
65 Writing Custom Queries Using @Query
66 Fetching Partial Data with Projections
67 Efficiently Loading Entities with @EntityGraph
68 Avoiding the N+1 Problem
69 Calling Stored Procedures
70 Exercise- Writing Custom Queries
71 Writing Dynamic Queries
72 Query by Example
73 Dynamic Queries Using Criteria API
74 Composable Queries Using Specifications API
75 Sorting and Pagination
76 What’s Next
Resolve the captcha to access the links!