Sr no Main Topic

1 Introduction, Installation & Setup

2 A First Look

3 Coding Best Practices & IntelliJ Overview

4 Class and Object Basics

5 More on Classes and Objects

6 Flow of Control

7 Strings, Arrays, BigDecimal and Dates/Times

8 Packages and Modules

 9 Composition and Inheritance

10 Interfaces

11 Java Beans

12 Working with Enums

13 Exceptions

14 Collections & Generics

15 Java Coding Best Practices

Subtopic
Java Environment
Installing JDK and IntelliJ CE IDE
Java Program Development
Java Source File Structure
Language and Platform Features
Program Life Cycle
The Java SE Development Kit (JDK), JRE, JVM

A Simple Java Class

Java’s “Hello World” Program
The Java Shell

Java Coding Best Practices

Understanding IntelliJ Editor
Plugins in IntelliJ
Handling Code Quality with SonarQube plugin

The Object Model and Object-Oriented Programming

Classes, References, and Instantiation
Adding Data to a Class Definition
Adding Methods (Behavior)

Accessing data, the "this" variable

Encapsulation and Access Control, public and private Access
Constructors and Initialization
static Members of a Class
Type Inference (Java 10+)
Scopes, Blocks, References to Objects

Branching: if, if-else, switch

Iteration: while, do-while, for, break, continue

String, StringBuffer, StringBuilder

Arrays, Arrays of Reference Types
Working with BigDecimals
LocalDate/LocalTime (Java 8+)

Package Overview - Using Packages to Organize Code

Import statements
Creating Packages, package Statement, Required Directory Structure
Java 9 Module Overview
Defining Modules, Requires, and Exports
Module Path and Classpath - Differences and Coexistence
Using Composition to Deal With Complexity
Composition/HAS-A, Delegation
Using Inheritance and Polymorphism to share commonality
IS-A, extends, Inheriting Features, Overriding Methods, Using Polymorphism
Method Overriding, @Override
Constructor Chaining
Abstract Classes

Using Interfaces to Define Types

Interfaces and Abstract Classes
Default Methods and static Methods (Java 8)
Functional Interfaces

Writing Java Beans

Getters & Setters
toString, hashCode and equals method

What are Enums

Creating Enums and using them
Typesafe Enums

Exceptions and the Exception Hierarchy

Exceptions vs Errors
Try, catch, finally
Handling Exceptions
Program Flow with Exceptions
Using throws
Creating & throwing custom Exceptions

Collections Overview
The Collections Framework and its API
Collections and Java Generics
Generics and Type-Safe Collections
Diamond Operator
Lists, Sets, and Maps
Interfaces and Contracts
Iteration and Autoboxing
Utility Classes - Collections and Arrays
Using ArrayList, HashSet, and HashMap
for-each Loop
Processing Items With an Iterator
Sorting with Collections

https://www.oracle.com/java/technologies/javase/codeconventions-introduction.html
https://www.oracle.com/technetwork/java/codeconventions-150003.pdf
Sr No Main Topic

1 Inner Classes

2 Java API Techniques

3 File Handling

4 Localisation and Resource Bundles

5 Multithreading Techniques

6 Logging

7 Garbage Collection
8 Lambda Expressions & Functional Interfaces

9 Method References

10 Stream API

Stream Processing

11 Collectors
Sub Topic
Overview and Motivation
Stronger Encapsulation, Rules and Caveats
Defining and Using Inner Classes
Member-Level, Method-Local, Anonymous Classes
Static Nested Classes
Nested Classes, Nested Interfaces, Nested Enums

The Console class

The String Builder class
Formatting techniques
Regular expressions

Working with files

Text files
Binary files
Serialization
XML files
Java properties files

Locales
Resource bundles
Locale-specific formatting and parsing

Java synchronization language features

Designing thread-safe classes
Recommendations for synchronizing resource access
Using concurrent collections
Using synchronizers and locks
Thread pooling techniques
Using the executor framework
Using pooling effectively

Overview
Popular Logging Frameworks(Log4J)
Writing Log Messages
Creating Loggers and Writing Log Messages
Log Levels & best practices

Essential concepts
Understanding object lifetimes
Generational collectors
Heap organization
Garbage collection options
Garbage collection monitoring and tuning(memory analyzer tool)
Overview
Functional Interfaces and Lambdas
Target Context
Using Lambda Expressions
Syntax, Lambda Compatibility
Variable Capture
Type Inference

Three Types of Method References

Refactoring Lambdas into Method References

Overview
Streams vs. Collections
Anatomy of a Stream

Intermediate Operations and Stream Pipeline

Java 8 Functional Interfaces: Predicate, Comparator, Function, Consumer, Supplier

Filtering, Sorting, Mapping

Terminal Operations

Partitioning and Grouping

Reducing and Summarizing
Downstream Reductions
Optional Class
Optional.Empty
Optional.Of
Sr No Main Topic

1 Introduction to Apache Kafka

2 Kafka Command Line

3 Kafka Producer API

4 Kafka Connect and Spark Streaming

5 Kafka Consumers: Reading Data from Kafka

Sub Topic
What Kafka is and why it was created
The Kafka Architecture
The main components of Kafka
Use cases for Kafka

The contents of Kafka’s /bin directory

How to start and stop Kafka
How to create new topics
How to use Kafka command line tools to produce and consume messages

The Kafka producer client

Kafka Producer configuration settings and what they do
How to create a Kafka producer using the Java API and send messages both synchronously and
asynchronously

Kafka Connect and how to use a pre-built connector

components of Kafka Connect
How to use Kafka and Spark Streaming together

Kafka Consumer Concepts

Creating a Kafka Consumer
Subscribing to Topics
The Poll Loop
Configuring Consumers
Commits and Offsets
Rebalance Listeners
Consuming Records with Specific Offsets
But How Do We Exit?
Deserializers
Standalone Consumer: Why and How to Use a Consumer Without a Group
SR No Main Topic

1 Introduction to Docker

2 Installation & Setup

3 Docker Containers

4 Docker Image

5 Docker Volumes
Subtopic
Evolution of Containerization
VM vs Containers
Why Docker? Why now?
What is docker and Who is it for
Docker - Advantages & Caveats
Docker Ecosystem & Architecture

Docker Editions
Docker Versions and updates
Docker for Mac
Docker for windows 10 pro
Docker for windows 8.1
Install Docker on linux

Checking Docker install and configuration

List running container
Overriding default command
Container lifecycle
Restarting stopped containers
Removing stopped containers
Remove all containers
Remove running containers
Stopping Containers

What are Docker images

Exploring Docker Hub
Concept of Docker image layers
Image tagging and pushing to Docker hub
Building Images - Dockerfile Basics
Extending Docker Official Image
Building Images - Create custom Docker Image

Container Lifetime and persistent Data

Persistent data with volumes
Persistent Data with bind mounts
CONTENT
Introduction
Why Angular?
User Experience similar to a Desktop Application
Productivity and Tooling
Performance
Community
Full-featured Framework
Platform for Targeting Native Mobile not just Web Browsers
What is Angular?
Central Features of the Angular Framework
Appropriate Use Cases
Building Blocks of an Angular Application
Basic Architecture of an Angular Application
Installing and Using Angular
Anatomy of an Angular Application
Running the Application
Building and Deploying the Application
Working with Angular CLI
Angular CLI
Anatomy of the project(NPM, package.json, angular.json, tslint.json to be covered)
Debugging Angular apps
Working with Augury
8 Main Building Blocks of Angular (Birds Eye View of Angular)
Modules
Components
Templates
Metadata
Data binding
Directives
Services
Dependency injection
Angular Modules
Why Modules?
How to create Modules?
Built in Modules
Root Module
Feature Module
Components
What is a Component?
An Example Component
Creating a Component Using Angular CLI
The Component Class
The @Component Decorator
Registering a Component to Its Module
Component Template
Example: HelloComponent Template
Example: The HelloComponent Class
Using a Component
Run the Application
Component Hierarchy
The Application Root Component
The Bootstrap File
Component Lifecycle Hooks
Example Lifecycle Hooks
CSS Styles
Component Templates
Templates
Template Location
The Mustache {{ }} Syntax
Setting DOM Element Properties
Event Binding
Expression Event Handler
Prevent Default Handling
Attribute Directives
Apply Styles by Changing CSS Classes
Example: ngClass

Structural Directives
Conditionally Execute Template
Example: ngIf
Looping Using ngFor
ngFor Local Variables
Manipulating the Collection
Example - Deleting an Item
Item Tracking with ngFor
Swapping Elements with ngSwitch
Template Reference Variable
Inter Component Communication
Communication Basics
The Data Flow Architecture
Preparing the Child to Receive Data
Send Data from Parent
More About Setting Properties
Firing Event from a Component
@Output() Example - Child Component
@Output() Example - Parent Component
Full Two Way Binding
Setting up Two Way Data Binding in Parent
Pipes and Data Formatting
What are Pipes?
Built-In Pipes
Using Pipes in HTML Template
Chaining Pipes
The number Pipe
Currency Pipe
Template Driven Forms
Importing Forms Module
Basic Approach
Setting Up a Form
Getting User Input
Omitting ngForm Attribute
Initialize the Form
Two Way Data Binding
Form Validation
Angular Validators
Displaying Validation State Using Classes
Additional Input Types
Checkboxes
Select (Drop Down) Fields
Rendering Options for Select (Drop Down)
Date fields
Radio Buttons
Services and Dependency Injection
What is a Service?
Creating a Basic Service
The Service Class
What is Dependency Injection?
Injecting a Service Instance
Injectors
Injector Hierarchy
The Root Injector
Registering a Service with a Component's Injector
Where to Register a Service?
Dependency Injection in Other Artifacts
Providing an Alternate Implementation
Dependency Injection and @Host
Dependency Injection and @Optional
HttpClient
The Angular HTTP Client
Using The HTTP Client - Overview
Importing HttpClientModule
Simple Example
Service Using HttpClient
ES6 Import Statements
Making a GET Request
What does an Observable Object do?
Using the Service in a Component
The PeopleService Client Component
Error Handling
Customizing Error Object with .catch()
Making a POST Request
Making a PUT Request
Making a DELETE Request
The Angular Component Router
The Component Router
View Navigation
The Angular Router API
Creating a Router Enabled Application
Hosting the Routed Components
Navigation Using Links and Buttons
Programmatic Navigation
Passing Route Parameters
Navigating with Route Parameters
Obtaining the Route Parameter Values
Retrieving the Route Parameter Synchronously
Retrieving a Route Parameter Asynchronously
CONTENT
Introduction to Microservices
What are Microservices?
Monolith vs Microservice based architecture? Pros and Cons of microservice archiecture
Domain driven design. How to identify microservices?
Distributed transactions, Eventual consistency
Data handling in case of microservices. Synchronisation issues and how to address them
Decentralized Governance, Scalability, Fault Tolerance
Cloud Computing
Spring Cloud
Externalizing Configuration - Spring Cloud Config
The Spring Cloud Configuration Server
Why Configuration Management is Important
Configuration Management Challenges in Microservices
Separation of Configuration from Code
Configuration Service
How the Configuration Service Works
Broadcasting Configuration Changes - Spring Cloud Bus
Introduction to Spring Cloud Bus
Implementing Spring Cloud Bus
Service Discovery with Netflix Eureka
Service Discovery in Microservices
Load Balancing in Microservices
Netflix Eureka
Eureka Architecture
Communications in Eureka
Scale Services - Load-Balancing with Netflix Ribbon
Load Balancing in Microservices
Netflix Ribbon
Server-side load balance
Client-side Load Balance
Architecture
Fault Tolerance with Netflix Hystrix
Netflix Hystrix
Design Principles
Cascading Failures
Bulkhead Pattern
Circuit Breaker Pattern
Gateway/ Edge Components with Netflix Zuul
API gateway significance with respect to microservice based architecture
Zuul is the Gatekeeper
Request Handling
Filters
Communication between Microservices
Microservices communication Http, gRPC, event based
Introduction to Feign
Configuring Feign
Access services using Feign REST client
SPRING BOOT
CONTENT
Introduction
Spring Boot Overview
maven, gradle and Spring
What is Spring Boot and What It Does
Need of Spring Boot
Difference between Spring & Spring Boot
Spring Boot Structure
Spring POMs with Boot Parents
Dependency management using Spring Boot starters
Creating a simple Boot application using Spring
Initializr web-site
Spring Boot Features
Auto Configuration
Working with Properties - YAML and .properties
Component Scan
Devtools
Embeded Servers
Profiling
Versioning
Exception handling
RESTful Services with SpringBoot
REST Overview, URI Templates
REST and Spring MVC
Spring support for REST
@RequestMapping/@PathVariable, @RequestBody, @ResponseBody
URI Templates and @PathVariable
Controllers with @RestController
Understand status codes
Generating JSON
JSON Overview
JSON Representations for Resources
Message Converters
Generating XML
JAXB and Jackson Message Converters for XML
JAXB / @XmlRootElement
Content Negotiation
Java Clients for RESTful Services
Client Requirements and Spring's RestTemplate
getForObject() / getForEntity()
Other RestTemplate Methods
Accessing Headers / exchange()
Common REST Patterns
GET: Read
POST: Create
PUT: Update
DELETE: Delete
Programming on server side, and client side
Handle errors/ Exceptions is REST
Spring Boot Database Support
Basic Auto-configuration - Datasource and Pooling
Configuration Properties
Spring Boot's JPA Support - spring-boot-starter-data-jpa
Spring Boot Data (with Data-JPA in Detail)
Working with Databases
Working with embedded database - H2
Working with NoSQL database - MongoDB
Spring and Spring Data with JPA
Overview and Architecture
Configuring Spring Data JPA
Repositories and JPA Repositories
Using CrudRepository/JpaRepository