Introduction of Program

Introduction of Programming Language

Introduction of Java

Installation and Classpath setting

Important terminology

Character Set | Keyword | Identifiers

Data Types

Variable

Literals

Operator

Control Statement

Array

Introduction of OOPS

Class | Object | Class Loaders & Class Loading Concept

Instance & Static Variable

Block

Method

Constructor

Abstraction

Encapsulation

Inheritance

Polymorphism

Abstract Class

Interface

Inner Class

Introduction of Package

Package configuration

import

Jar files

Access Modifier

Introduction of java.lang package

java.lang.Object class

Garbage Collection

Cloning

java.lang.String class

java.lang.StringBuffer class

java.lang.StringBuilder class

java.lang.System class

java.lang.Runtime class

Wrapper Class

Introduction of Exception

Different types of Exceptions

Try-Catch & Finally block

throw & throws keyword.

Autoclosable Interface

Introduction of Multi-threading.

Thread Priority

User-Define Thread

Thread Life-Cycle

Dead lock

Synchronization

Inter-Thread Communication

Introduction of Collcetion Framework

List

Set

Map

Queue

Iterator, List-Iterator & Enumeration

Introduction of Generics

Generics Classes

Bounded Types

Generics Methods & Wild-Card characters

Introduction

Stream

Filtering

Storing Data records

Readers

Writers

Introduction

File Classes

Untility Methods and Constructor

Action Methods

Introduction of Serialization

Reading an object from a files

Custom Serialization

Externalizable

Serial Varsion UID

Introduction of Scanner Class

Utility Methods & Constructors.

Introduction of Java Annotation

Types of Annotation

Built-In Annotation

Lambda Expression

Functional Interface

Stream API

Default & Static Method in Interface

Method Reference

Optional Class

New Date & Time API

Sealed Class

Record

Introduction of JDBC

JDBC Drivers

JDBC Statements

Batch Updates

Result Set

Row Set

Introduction of Servlet

Introduction of Servlet

Web Server | Web Client | Web Container | Http & Https | TCP & IP | DNS

Web Server setup

Servlet API

Servlet Example using Web.xml

Servlet Example using Annotations

Servlet Life Cycle

Servlet Parameters

Request Dispatcher

Servlet Thread Models

HttpServletRequest & HttpServletResponse.

Session Management

Exploring HttpSession

Servlet Scopes

Servlet Filter & Filter Chaining

Listeners

Introduction of JSP

JSP Life-Cycle & JSP Life-Cycle Methods

JSP Implecit Objects

JSP Scripting formats

JSP Directives

JSP Standard Actions

JSP Scopes

JSP EL Expression

JSTL Tags

Custom Tags

Introduction of Hibernate

Difference between JDBC and Hibernate

Hibernate Features

First Example of Hibernate using hbm.xml file

First Example of Hibernate using annotations

Hibernate Inheritance Mapping

Table Per Class Mapping

Table Per Concrete Class mapping

Association Mapping

One-to-One Uni-directional Mapping

One-to-One Bi-directional Mapping

Many-to-Many Mapping

Version Mapping

Timestamp Mapping

Hibernate Example on DAO Pattern

Hibernate Query Language SQL | HQL | QBC | Native Query | Named Query

Polymorphic Query

Positional Parameters & Named Parameters

Simple Primary Key

Custom Primary Key

Composite Primary Key

Introduction of Transaction Management

ACID Property

Transaction Concurrency Problem & Solutions

Types of Transactions.

Hibernate Connection Management

JDBC Transaction

JTA Transaction

CMT Transaction

Hibernate Architecture

Exploring SessionFactory

Object States

Introduction of Hibernate Cache

Different types of Hibernate Cache

Hibernate Cache Architecture

About Spring 5.x Training

Spring 5.x Course Prerequisite

Spring 5.x Training Course Objective

Spring 5.x Training Course Duration

Spring 5.x Training Overview

Spring Introduction

Spring Core Module

Spring Core Module with Annotations

Spring Core Module with 100% Code/Java Config Approach.

Spring Boot Core

Spring JDBC/DAO

Spring AOP Module

Spring Transaction Management

Spring MVC

Spring Security

Spring ORM

Spring Data and Spring Data JPA

Spring Batch

Spring Mail

Introduction to Spring MicroServices

How to Explain Project Architectures

Spring Boot introduction

Spring boot - Bootstrapping

Spring boot - Tomcat Development

Spring boot - Build System

Spring boot - Code Structure

Spring boot - Spring beans and dependency injection

Spring boot - Runners

Spring boot - Application Properties

Spring boot - Logging

Spring boot - Building Restful Web Service

Spring boot - Exception Handling

Spring boot - Interceptor

Spring boot - Servlet Filter

Spring boot - Rest Template

Spring boot - File Handling

Spring boot - Service Components

Spring boot - Consuming Restful Web Services

Spring boot - Cors Support

Spring boot - Internationalization

Spring boot - Scheduling

Spring boot - Enabling Https

Spring boot - Eureka Server

Spring boot - Service Registration With Eureka

Spring boot - Cloud Configuration Server

Spring boot - Cloud Configuration Client

Spring boot - Actuator

Spring boot - Admin Server

Spring boot - Admin Client

Spring boot - Enable Swagger2

Spring boot - Creating Docker Image

Spring boot - Tracing Micro Service Logs

Spring boot - Flying Database

Spring boot - Web Socket

Spring boot - Batch Service

Spring boot - Spring for Apache Kafka

Spring boot - Database handling

Spring boot - Securing Web Application

Spring boot - OAuth2 with JWT

What is Spring Data JPA?

Advantages of Using Spring Data JPA

Overview of JPA (Java Persistence API)

How Spring Data Enhances JPA

Entities and Repositories

Relationships (One-to-One, One-to-Many, Many-to-One, Many-to-Many)

Entity Lifecycle and States (Transient, Persistent, Detached, Removed)

Project Setup with Spring Boot

Configuring DataSource and JPA Properties

Maven/Gradle Dependencies

Defining application.properties / application.yml

Repository Interfaces Overview

• CrudRepository
• PagingAndSortingRepository
• JpaRepository

Custom Repository Methods

Query Methods Derived from Method Names

Entity Mapping with Annotations

• @Entity, @Table, @Column
• @Id, @GeneratedValue
• @Embedded and @Embeddable

Primary Key Strategies

Embedded and Composite Keys

Mapping Relationships with @OneToOne, @OneToMany, @ManyToOne, @ManyToMany

Cascading Operations

Fetch Types: EAGER vs LAZY Loading

Join Tables and MappedBy

JPQL (Java Persistence Query Language)

Native Queries

Named Queries

@Query Annotation for Custom Queries

Projections and DTOs

Specifications and Criteria API

Pagination with Pageable

Sorting with Sort

Combining Pagination and Sorting

@Transactional Annotation

Transaction Propagation and Isolation Levels

Exception Translation in Spring Data JPA

Enabling JPA Auditing

Using @CreatedDate, @LastModifiedDate

Optimistic Locking with @Version

Repository Design Patterns

Avoiding N+1 Select Problems

Caching Strategies

Using DTOs for API Responses

Spring Data REST Integration

Query by Example (QBE)

Multi-Tenancy with Spring Data JPA

Integration with Spring Security

JPA and Microservices Design

Handling Data Consistency

Distributed Transactions

Common Pitfalls

Logging SQL Queries

LazyInitializationException and How to Fix It

Official Spring Data JPA Documentation

Useful Tools and Libraries

What is Spring MVC?

What is Spring Boot?

Why Testing is Important in Spring Applications?

Types of Testing in Spring Ecosystem

Unit Testing vs Integration Testing

Mocking Dependencies

Overview of Spring Test Context Framework

Introduction to JUnit and Mockito

Using MockMvc

Testing Request Mappings

Testing Response Status and JSON

Mocking Services and Repositories

Using Mockito for Service Layer

Verifying Service Logic

Using @DataJpaTest

Testing with H2 In-Memory Database

Testing @ControllerAdvice

Validating Error Responses

@SpringBootTest Overview

Loading ApplicationContext

Testing Embedded Server

Using TestRestTemplate

Testing JSON Responses

Testing Security Configurations

Using @DataJpaTest with H2

Using Testcontainers for Integration Tests

Using @TestConfiguration

Testing @ConfigurationProperties

Mocking External APIs with WireMock

Using Rest Assured for API Testing

Testing Asynchronous Code

Testing Kafka Consumers/Producers in Spring Boot

Mockito

AssertJ

Hamcrest Matchers

Spring Test Utils

JUnit 5 Extensions in Spring Boot

Test Pyramid (Unit, Integration, End-to-End)

Keeping Tests Fast and Isolated

Data Setup and Cleanup (Flyway/Liquibase)

Avoiding Flaky Tests

Testing Microservices with Spring Boot

Testing WebSockets and Messaging

Contract Testing with Spring Cloud Contract

Testcontainers in Spring Boot 3.x

Native Testing with Spring Boot and GraalVM

Cloud Testing Strategies

What are Microservices?

Monolithic vs Microservices Architecture

Key Characteristics of Microservices

Advantages & Disadvantages

Components of Microservices

API Gateway

Service Registry and Discovery

Database per Service Pattern

Communication (Synchronous vs Asynchronous)

Single Responsibility Principle

Decentralized Data Management

Domain-Driven Design (DDD)

Event-Driven Architecture

Scalability and Resilience Patterns

Choosing Technology Stack (Spring Boot, Node.js, etc.)

RESTful APIs and gRPC

Service-to-Service Communication (REST, Message Queues)

Data Management Strategies

Shared Database vs Database per Service

Saga Pattern

CQRS (Command Query Responsibility Segregation)

Authentication and Authorization (OAuth2, JWT)

API Gateway Security

Securing Inter-service Communication

Rate Limiting & Throttling

Containerization (Docker)

Orchestration (Kubernetes)

CI/CD Pipelines

Blue-Green Deployment

Canary Deployment

Spring Boot & Spring Cloud

Netflix OSS (Eureka, Hystrix, Zuul)

Docker & Kubernetes

Istio Service Mesh

Monitoring Tools (Prometheus, Grafana, ELK stack)

Centralized Logging

Distributed Tracing (Zipkin, Jaeger)

Health Checks

Metrics and Alerts

Circuit Breaker Pattern

Retry Pattern

Bulkhead Pattern

Fallback Mechanisms

Unit Testing

Contract Testing (Pact)

Integration Testing

End-to-End Testing

Chaos Testing

Netflix

Amazon

Uber

Serverless Microservices

Micro Frontends

AI-driven Microservices Management

What is Apache Kafka?

History and Evolution of Kafka

Why Kafka? (Use Cases & Benefits)

Kafka vs Traditional Message Brokers

Kafka Core Concepts

Producers

Consumers

Brokers

Topics

Partitions

Offsets

Kafka Cluster Architecture

ZooKeeper Role in Kafka

Kafka Data Flow

Topics and Partitions

Brokers and Clusters

Producers and Consumers

Consumer Groups

Kafka Connect

Kafka Streams

Kafka REST Proxy

Setting up Kafka (Single Node & Cluster)

Installing ZooKeeper

Configuring Kafka Broker

CLI Tools for Kafka

Writing a Kafka Producer

Writing a Kafka Consumer

Message Serialization & Deserialization

Keyed vs Non-Keyed Messages

Message Storage

Replication Mechanism

Leader and Follower Roles

ISR (In-Sync Replicas)

Log Segmentation

Scaling Kafka Clusters

Monitoring Kafka (JMX, Prometheus, Grafana)

Kafka Security

Authentication (SSL, SASL)

Authorization (ACLs)

Encryption (SSL)

Kafka for Event-Driven Microservices

Kafka vs REST APIs

Designing Event-Driven Architectures

Saga Pattern with Kafka

Using Kafka with Spring Boot

Kafka Streams API

Kafka Connect API

Exactly Once Semantics

Partitioning Strategies

Rebalancing and Consumer Lag

Unit Testing Kafka Producers and Consumers

Embedded Kafka for Integration Tests

Fault Tolerance Testing

Kafka Connectors (Source & Sink)

Confluent Platform Overview

KSQL (Kafka SQL)

Schema Registry

Kafka at LinkedIn, Netflix, Uber

Kafka in IoT, Financial Systems, and Big Data Pipelines

Kafka vs Pulsar vs RabbitMQ vs NATS

Cloud-native Kafka (MSK, Confluent Cloud)

Serverless Kafka

What is CI/CD?

Importance of CI/CD in Modern Development

Benefits of CI/CD

Continuous Integration (CI)

Continuous Delivery (CD)

Continuous Deployment

DevOps and CI/CD Relationship

Key Terminologies (Build, Test, Deploy, Pipeline, etc.)

What is a CI/CD Pipeline?

Components of a CI/CD Pipeline

Pipeline Stages Overview

Source Stage (Version Control)

Build Stage

Test Stage (Unit, Integration, Functional Testing)

Deploy Stage (Staging & Production)

Monitor & Feedback Stage

Jenkins

GitLab CI/CD

CircleCI

Travis CI

Azure DevOps

AWS CodePipeline

Docker & Kubernetes in CI/CD

What is Pipeline as Code?

YAML Configuration Examples

Benefits of Declarative Pipelines

Example: A Typical Workflow

Sample CI/CD Pipeline Diagram

Commit Early, Commit Often

Automated Testing

Rollbacks and Roll-forwards

Security in CI/CD (DevSecOps)

Monitoring & Alerting

Common Pitfalls

Overcoming Pipeline Bottlenecks

Scaling CI/CD for Large Teams

CI/CD in Netflix

CI/CD in Amazon

CI/CD in a Microservices Architecture