Java and Spring Boot for Backend Development: REST API and Security Fundamentals
Master Java and Spring Boot to build robust, secure REST APIs for backend development, equipping you with essential skills for a successful career.
...
Share
Introduction to Java and Object-Oriented Programming
Unit 1: Getting Started with Java
Welcome to Java!
Installing the JDK
Choosing Your IDE
Hello, World!
Anatomy of Java Code
Unit 2: Java Fundamentals: Data Types and Operators
Primitive Data Types
Variables in Java
Operators: Arithmetic
Operators: Relational
Type Conversion
Unit 3: Control Flow Statements
If Statements
Switch Statements
For Loops
While and Do-While Loops
Break and Continue
Advanced Java Concepts
Unit 1: Advanced Data Structures
Intro to Lists
Working with ArrayLists
Linked Lists Explained
Intro to Sets
HashSets in Detail
Unit 2: More Data Structures and Generics
TreeSets and Ordering
Intro to Maps
HashMaps Explained
TreeMaps and Ordering
Generics: Type Safety
Unit 3: Exception Handling and I/O Streams
Exception Handling Intro
Try-Catch Deep Dive
File I/O: Reading Files
File I/O: Writing Files
Lambda Expressions
Introduction to Spring Boot
Unit 1: Spring Boot Fundamentals
Why Spring Boot?
Spring Initializr: Overview
Setting Up Initializr
IDE Integration
Initializr CLI
Unit 2: Project Structure and Dependencies
Project Structure
Maven vs. Gradle
Maven Deep Dive
Gradle Deep Dive
Dependency Resolution
Unit 3: Configuration and Properties
Configuring Spring Boot
Properties Files
YAML Files
Profiles
External Properties
Building RESTful APIs with Spring Boot
Unit 1: REST API Fundamentals
REST API Principles
HTTP Methods Deep Dive
HTTP Status Codes
Resources and URIs
Unit 2: Spring Boot Controllers
Creating a Controller
Request Mappings
Handling Request Params
Handling Request Bodies
Returning Responses
Unit 3: Advanced API Techniques
Path Variables
Custom Status Codes
Content Negotiation
API Versioning
Error Handling
Data Persistence with Spring Data JPA
Unit 1: Introduction to ORM and JPA Entities
What is ORM?
JPA: The Java Standard
Setting Up JPA
Defining JPA Entities
Primary Keys with @Id
Unit 2: Spring Data JPA Repositories
Intro to Repositories
Creating a Repository
Saving Data
Reading Data
Deleting Data
Unit 3: Advanced JPA Operations
Updating Data
Custom Queries
@Query Annotation
Native Queries
Query Methods
Database Relationships and Advanced JPA
Unit 1: Understanding Entity Relationships
Intro to Relationships
One-to-One
One-to-Many
Many-to-Many
Join Tables
Unit 2: Advanced Relationship Mapping
Cascade Types
Orphan Removal
Eager vs Lazy Loading
Default Loading Strategy
When to Eager Load
Unit 3: Advanced JPA Features
Auditing Intro
Auditing Annotations
Versioning
Transactions Intro
Declarative Transactions
Dependency Injection and Inversion of Control
Unit 1: Understanding DI and IoC
What are DI and IoC?
Traditional vs. IoC
DI: A Simple Analogy
IoC Containers Explained
Benefits of DI and IoC
Unit 2: Spring's Core Container
Spring's Core Container
BeanFactory vs. Context
Configuring Beans
Bean Scopes
Bean Lifecycle
Unit 3: Configuring and Injecting Dependencies
XML Configuration
Annotation-Based Config
Java-Based Configuration
Constructor Injection
Setter and Field Injection
Advanced Spring Boot Configuration
Unit 1: Externalizing Configuration
Config: Properties Files
YAML Configuration
Env Vars for Config
Properties vs. YAML vs. Env
Unit 2: Custom Configuration Properties
Creating Custom Props
Validating Custom Props
Nested Custom Props
Unit 3: Spring Profiles
Intro to Spring Profiles
Profile-Specific Beans
Activating Profiles
Testing with Profiles
Unit 4: Logging with Logback and SLF4J
Intro to Logging
Log Levels
Custom Log Patterns
Logging to Files
Introduction to Spring Security
Unit 1: Security Fundamentals
Why Security Matters?
AuthN vs. AuthZ
Intro to Spring Security
Spring Security Filters
Setting up Security
Unit 2: Securing Endpoints
Securing Endpoints
PermitAll and DenyAll
Authenticated vs. Anonymous
hasRole() and hasAuthority()
Expression-Based Access
Unit 3: Basic Authentication
In-Memory Users
UserDetailsService
PasswordEncoder
Custom Login Page
Logout
Authentication and Authorization
Unit 1: Authentication Fundamentals
AuthN and AuthZ
Spring Security Overview
Adding Spring Security
In-Memory Authentication
Customizing Login Page
Unit 2: Database Authentication
UserDetailsService
Configuring the Database
Implementing UserDetails
Custom UserDetailsService
Wiring Up AuthN
Unit 3: Authorization and Access Control
Roles and Permissions
Securing Endpoints
Expression-Based Access
Custom Access Control
AuthZ Best Practices
Securing REST APIs with JWT
Unit 1: JWT Fundamentals
Intro to JWT
JWT Header Explained
JWT Payload Explained
JWT Signature Explained
JWT Use Cases
Unit 2: JWT with Spring Security
Spring Security Setup
JWT Filter
Authentication Entry Point
User Details Service
JWT Provider
Unit 3: JWT Generation and Statelessness
Generating JWT
Stateless Authentication
Protecting Endpoints
Token Expiration
Refresh Tokens
Testing Spring Boot Applications
Unit 1: Introduction to Testing
Why Testing Matters
Testing Terminology
Setting Up Your Project
Unit 2: Unit Testing with JUnit and Mockito
JUnit Basics
Mockito: Mocking Dependencies
Testing Services
Testing Repositories
Unit 3: Integration Testing
Integration Testing Intro
Testing Controllers
Testing Data Flow
Unit 4: Advanced Testing Techniques
MockMvc Deep Dive
Testing REST APIs
Testcontainers Intro
TDD Intro
Advanced Testing Techniques
Unit 1: Deep Dive into MockMvc
MockMvc: The Basics
POST Requests with MockMvc
MockMvc: Request Params
MockMvc: Response Assertions
MockMvc: Exception Handling
Unit 2: Testing Spring Data JPA Repositories
JPA Repos: Setup
JPA Repos: CRUD Tests
JPA Repos: Custom Queries
JPA Repos: Data Integrity
Unit 3: Testcontainers for Isolated Testing
Testcontainers: Intro
Testcontainers: Databases
Testcontainers: Mocking
Testcontainers: Cleanup
Testcontainers: Best Practices
Unit 4: TDD and Maintainable Tests
TDD: Red-Green-Refactor
Writing Maintainable Tests
Test Smells
API Documentation with Swagger/OpenAPI
Unit 1: Introduction to API Documentation and Swagger/OpenAPI
Why Document Your APIs?
Swagger/OpenAPI Intro
Choosing Your Tools
Unit 2: Integrating Swagger/OpenAPI into Spring Boot
Add Dependencies
Basic Configuration
Verify Integration
Unit 3: Generating API Documentation Automatically
Annotations Overview
Describing Endpoints
Parameter Annotations
Response Annotations
Unit 4: Customizing and Using Swagger UI
Customizing API Info
Grouping Operations
Exploring Swagger UI
Download OpenAPI Spec
Security Definitions
Deployment and Monitoring
Unit 1: Packaging and Preparing for Deployment
Deployment Overview
Executable JARs
Building a WAR File
Configuring the JVM
Unit 2: Cloud Deployment
Cloud Deployment Options
Deploying to Heroku
Deploying to AWS
Containerization with Docker
Docker Compose
Unit 3: Monitoring and Logging
Spring Boot Actuator
Health Indicators
Metrics and Monitoring
Logging Basics
Centralized Logging
Error Handling
Microservices with Spring Cloud (Introduction)
Unit 1: Microservices Fundamentals
What are Microservices?
Microservices Principles
Communication Patterns
Decomposing the Monolith
Unit 2: Introduction to Spring Cloud
Spring Cloud Overview
Spring Cloud Project Setup
Service Discovery Intro
Unit 3: Service Discovery with Eureka
Setting up Eureka Server
Registering with Eureka
Eureka Client Deep Dive
Unit 4: API Gateway with Spring Cloud Gateway
API Gateway Concepts
Gateway Setup
Gateway Route Configuration
Gateway and Eureka
Unit 5: Distributed Configuration
Config Server Intro
Config Server Setup
Config Client Setup