Java Backend Engineer: Spring Boot, REST APIs, Microservices, and Hibernate
Master the skills to build robust and scalable Java backend applications with Spring Boot, REST APIs, Microservices, and Hibernate.
...
Share
Introduction to Spring Boot
Unit 1: Spring Boot Fundamentals
What is Spring Boot?
Spring vs. Spring Boot
Spring Boot's Key Features
Spring Initializr
Project Structure
Unit 2: Setting Up Your Environment
Install Java
Pick an IDE
Install Build Tool
Import Project
Unit 3: Your First Spring Boot App
The Main Class
Add a Controller
Run the Application
Configuration Files
Logging
Building RESTful APIs with Spring Boot
Unit 1: REST API Fundamentals
Intro to REST APIs
HTTP Methods Deep Dive
REST API Best Practices
Intro to Spring Boot
Unit 2: Building REST Controllers
Your First Controller
Request Parameters
Path Variables
Request Body Handling
Response Entities
Unit 3: Data Binding and Validation
Data Binding Basics
Bean Validation Intro
Validation Annotations
Handling Validation Errors
Custom Validation
Global Exception Handling
Data Persistence with Spring Data JPA
Unit 1: Introduction to Spring Data JPA
What is Spring Data JPA?
Setting Up Your Project
Configuring a Data Source
JPA Repositories
Your First Repository
Unit 2: Defining Entities
What is a JPA Entity?
Entity Annotations
Column Mapping
Creating a Simple Entity
Entity Relationships
Unit 3: Basic CRUD Operations
Saving Data
Retrieving Data
Updating Data
Deleting Data
Finding All Data
Hibernate Fundamentals
Unit 1: Introduction to Hibernate
What is Hibernate?
Hibernate Architecture
Hibernate vs. JPA
Unit 2: Configuring Hibernate with Spring Boot
Add Dependencies
Datasource Configuration
Hibernate Properties
Enable JPA Repositories
Unit 3: Mapping Entities to Database Tables
Entity Basics
Primary Key Mapping
Column Mapping
Transient Fields
Basic Data Types
Lombok Integration
Advanced REST API Development
Unit 1: API Versioning Strategies
Versioning Overview
URI Versioning
Header Versioning
Media Type Versioning
Choosing a Strategy
Unit 2: Complex Request/Response Handling
Request Body Handling
Response Body Structuring
File Uploads
File Downloads
Content Negotiation
Unit 3: Exception Handling
Exception Handling Intro
Global Exception Handler
Custom Exceptions
Validation Exceptions
Logging Exceptions
Database Relationships with JPA and Hibernate
Unit 1: Understanding Entity Relationships
Intro to Relationships
One-to-One
One-to-Many
Many-to-Many
Bi-directional Relationships
Unit 2: Cascading and Lazy Loading
Intro to Cascading
Cascade PERSIST & MERGE
Cascade REMOVE & ALL
Intro to Lazy Loading
Fixing LazyInitialization
Unit 3: Complex Queries with JPA and Hibernate
Intro to JPQL
JPQL Joins
Criteria API
Native SQL Queries
Dynamic Queries
Modern Java 8 Features in Spring Boot
Unit 1: Lambdas in Spring Boot
Lambda Expressions Intro
Lambdas with Parameters
Lambdas in Spring Beans
Method References
Functional Interfaces
Unit 2: Streams API in Spring Boot
Streams API Intro
Intermediate Operations
Terminal Operations
Collect API
Parallel Streams
Unit 3: Optionals in Spring Boot
Optionals: The Basics
Handling Empty Optionals
Mapping Optionals
Optionals in Repositories
Optionals in Controllers
Securing REST APIs with Spring Security
Unit 1: Spring Security Fundamentals
Intro to Spring Security
Setting Up Security
Securing Endpoints
Diving into Password Hashing
Customizing Login
Unit 2: User Roles and Permissions
Roles and Permissions
Configuring User Roles
Expression-Based Access
Custom Access Decision
Unit 3: Advanced Authentication Mechanisms
Form Login Deep Dive
JWT Intro
JWT Implementation
OAuth 2.0 Overview
OAuth 2.0 Implementation
Securing Microservices
OAuth 2.0 and JWT Authentication
Unit 1: OAuth 2.0 Fundamentals
OAuth 2.0: What & Why?
OAuth 2.0 Actors
Grant Types Overview
Authorization Code Flow
Implicit Grant Flow
Unit 2: JWT Fundamentals
JWT: What & Why?
JWT Structure: Header
JWT Structure: Payload
JWT Structure: Signature
JWT vs. Session Cookies
Unit 3: OAuth 2.0 and JWT in Spring Boot
Spring Security Setup
Resource Server Config
Authorization Server Setup
Generating JWTs
Validating JWTs
Introduction to Microservices Architecture
Unit 1: Microservices Fundamentals
What are Microservices?
Benefits of Microservices
Microservices Challenges
Decomposition Strategies
Communication Patterns
Unit 2: Building a Simple Microservices Application
Project Setup
Service 1: Product Catalog
Service 2: Order Service
Inter-service REST Calls
Testing Microservices
Unit 3: Advanced Microservices Concepts
Service Discovery Intro
API Gateway Intro
Config Management Intro
Monitoring and Logging
Scaling Microservices
Inter-service Communication with REST
Unit 1: Fundamentals of REST Communication
Intro to REST for Micro
RESTful API Design
REST Client Options
Making Your First Call
Serialization/Deserialization
Unit 2: Service Discovery and Load Balancing
Service Discovery Intro
Eureka, Let's Go!
Consul: Another Option
Load Balancing Basics
Ribbon's Role
Unit 3: Managing Dependencies and Advanced Topics
Circuit Breakers
Retries for Resilience
Timeouts are Critical
API Versioning
Correlation IDs
Message Queues with RabbitMQ/Kafka
Unit 1: Message Queue Fundamentals
Intro to Message Queues
Message Queue Components
RabbitMQ vs. Kafka
Unit 2: RabbitMQ Implementation
RabbitMQ Setup
RabbitMQ with Spring Boot
Publishing Messages
Consuming Messages
Message Persistence
Unit 3: Kafka Implementation
Kafka Setup
Kafka with Spring Boot
Producing Messages
Consuming Messages
Kafka Message Delivery
Unit 4: Advanced Concepts
Message Queue Patterns
Error Handling
Service Discovery with Eureka/Consul
Unit 1: Service Discovery Fundamentals
What is Service Discovery?
Eureka vs. Consul
Setting Up Eureka Server
Eureka Client Basics
Service Discovery in Action
Unit 2: Advanced Eureka Configuration
Eureka Metadata
Eureka Health Checks
Eureka Zones and Regions
Eureka Security
Eureka Best Practices
Unit 3: Consul for Service Discovery
Consul Setup
Consul Agent
Consul Discovery
Consul KV Store
Consul Connect
API Gateways with Spring Cloud Gateway
Unit 1: Introduction to API Gateways
What is an API Gateway?
Why Use an API Gateway?
Spring Cloud Gateway Intro
Unit 2: Setting Up Spring Cloud Gateway
Project Setup
Basic Route Configuration
Route Predicates
Gateway Filters
Unit 3: Advanced Routing and Filtering
Rewrite Paths
Adding Request Headers
Modifying the Response
Circuit Breaker Pattern
Unit 4: Cross-Cutting Concerns
Authentication
Authorization
Rate Limiting
Centralized Logging
Error Handling, Logging, and Monitoring
Unit 1: Centralized Logging with Spring Boot
Logging Intro
SLF4J: Logging Facade
Logback Configuration
Logging to a File
Centralized Logging
Unit 2: Metrics Collection with Prometheus
Intro to Prometheus
Micrometer: Metrics Facade
Prometheus Integration
Custom Metrics
Spring Actuator Metrics
Unit 3: Metrics Visualization with Grafana
Grafana Intro
Data Source Setup
Building Dashboards
Visualizing Metrics
Alerting
Testing Spring Boot Applications
Unit 1: Unit Testing Fundamentals
Testing: Why Bother?
JUnit Intro
Assert This!
Mocking with Mockito
Verify Behavior
Unit 2: Spring Boot Unit Testing
Testing Components
Context Loads?
Testing Configuration
Data Juggling
Unit 3: Integration Testing REST APIs
REST Template Time
Testing API Endpoints
JSON Assertions
MockMvc Intro
Unit 4: End-to-End Testing
E2E Testing
Testing Microservices
Testcontainers
