Index

JEE Full Stack 2.0 with React JS - (8 weeks) ....................................................................................... 2

JEE Full Stack 2.0 with React JS .......................................................................................................... 2
Agile SCRUM.......................................................................................................................................... 2
Core Java 8 .............................................................................................................................................. 3
Introduction to Design Pattern .............................................................................................................. 8
DevOps/ CI CD concepts (GitHub/Nexus, CI Jenkins, Sonar) .......................................................... 9
Database Using PostgreSQL ................................................................................................................ 10
JPA Using PostgreSQL ........................................................................................................................ 11
Spring 5.0............................................................................................................................................... 12
HTML 5, CSS 3 with Bootstrap, Javascript ES6 ............................................................................... 14
• Asynchronous Programming in ES6 ........................................................................................... 17
React JS ................................................................................................................................................. 17

Company Confidential
 JEE FULL STACK 2.0 WITH REACT JS - (8 WEEKS)

JEE Full Stack 2.0 with React JS variant provides exposure to the entire spectrum of Java technologies
starting from Core Java to Spring. It focuses on Web Application development using React JS and Spring
Technology. The following table lists the course structure.

Sr. No. Course Duration Immersive approach Remarks

Discover (Induction) --

1 Soft Skills Foundation – Part 1 1

Core Java 8 + Database & PostGreSQL
Project kick off-Individual project use
2 with DevOps (Git, Sonarqube, Gradle, 12.5 cases has to be implemented
Jenkin)
3 Core Java 8 Test 0.5 Coding and MCQ Test
4 Soft Skills Foundation – Part 2 1
5 JPA with Hibernate with PostgreSQL 2
Spring 5.0 (Core + MVC + REST + Wireframe diagram to be created
6 6
Data JPA + Data REST) for case study
7 Soft Skills Foundation – Part 3 1
Sprint 1 + JPA and Spring MCQ Sprint 1- Backend
8 5
Test implementation using Spring
8 Sprint 2 Evaluation 1 REST and Spring Data JPA
10 Soft Skills Foundation – Part 4 1
HTML 5, CSS 3 with bootstrap 4,
11 4
JavaScript ES6
12 React JS (Jasmine Node as Server) 6

13 Sprint 2 +React JS + MCQ Test 4

Sprint 2 - Front end implementation
using React
14 Sprint 2 Evaluation 1

15 L1 Preparation 1

16 L1 Test 1

Total Training Duration 48

JEE Full Stack 2.0 with React JS

Agile SCRUM

Company Confidential
Execution:

• Week 1 – Participants to complete Agile coursera course to understand Agile methodology

before Project Kick off to understand and use daily scrum meeting, Project Backlog, Sprint
Backlog, Sprint review.
• Week 1 Project Kick off – Expectation setting by BU Mentor
o Sprint Planning , Group formed , Case study shared . (BU Support )Declarations and
• Week 2 - Requirement review ,Understanding and Design artifacts , Use case , class ,
sequence diagram to prepared
• Week 4 - Artifacts Reviewed and Functional requirement design through interfaces , Test
Cases.
• Sprint 1 implementation with code reviews of L&D and BU trainer
o Test case reviews
o Code reviews
o Performance monitoring during the sprint implementation and sharing the feedback
o Sprint - 1 Evaluation 30mins/participant

• Sprint 2 implementation with code reviews of L&D and BU trainer

o Test case reviews
o Code reviews
o Performance monitoring during the sprint implementation and sharing the feedback
o Sprint - 2 Evaluation 30min/participant

Core Java 8
Program Duration: 10.5 days

Contents:
• Declarations and Access Control
o Identifiers & JavaBeans
o Legal Identifiers
o Sun's Java Code Conventions
o JavaBeans Standards
o Declare Classes
o Source File Declaration Rules
o Class Declarations and Modifiers
o Concrete Subclass
o Declaring an Interface
o Declaring Interface Constants
o Declare Class Members
o Access Modifiers
o Nonaccess Member Modifiers
o Constructor Declarations
o Variable Declarations
o Declaring Enums

• Object Orientation

Company Confidential
 o Encapsulation
o Inheritance, Is-A, Has-A
o Polymorphism
o Overridden Methods
o Overloaded Methods
o Reference Variable Casting
o Implementing an Interface
o Legal Return Types
o Return Type Declarations
o Returning a Value
o Constructors and Instantiation
o Default Constructor
o Overloaded Constructors
o Statics
o Static Variables and Methods
o Coupling and Cohesion

• Assignments
o Stack and Heap—Quick Review
o Literals, Assignments, and Variables
o Literal Values for All Primitive Types
o Assignment Operators
o Casting Primitives
o Using a Variable or Array Element That Is Uninitialized and Unassigned
o Local (Stack, Automatic) Primitives and Objects
o Passing Variables into Methods
o Passing Object Reference Variables
o Does Java Use Pass-By-Value Semantics?
o Passing Primitive Variables
o Array Declaration, Construction, and Initialization
o Declaring an Array
o Constructing an Array
o Initializing an Array
o Initialization Blocks
o Using Wrapper Classes and Boxing
o An Overview of the Wrapper Classes
o Creating Wrapper Objects
o Using Wrapper Conversion Utilities
o Autoboxing
o Overloading
o Garbage Collection
o Overview of Memory Management and Garbage Collection
o Overview of Java's Garbage Collector
o Writing Code That Explicitly Makes Objects Eligible for Garbage Collection

• Operators
o Java Operators
o Assignment Operators

Company Confidential
 o Relational Operators
o instanceof Comparison
o Arithmetic Operators
o Conditional Operator
o Logical Operators

• Flow Control, Exceptions

o if and switch Statements
o if-else Branching
o switch Statements
o Loops and Iterators
o Using while Loops
o Using do Loops
o Using for Loops
o Using break and continue
o Unlabeled Statements
o Labeled Statements
o Handling Exceptions
o Catching an Exception Using try and catch
o Using finally
o Propagating Uncaught Exceptions
o Defining Exceptions
o Exception Hierarchy
o Handling an Entire Class Hierarchy of Exceptions
o Exception Matching
o Exception Declaration and the Public Interface
o Rethrowing the Same Exception
o Common Exceptions and Errors

• Gradle Fundamentals
o Introduction
o Folder Structure
o Install and Setup Gradle on Windows

o Dependencies in Build Scripts

o Gradle Wrapper
o Lifecycle Tasks: The Base Plug In
o Using Project Info and the check command
o Creating Variables and external properties
o Creating a Build Scan
o Dependencies

• TDD with Junit 5

o Types of Tests
o Why Unit Tests Are Important
o What's JUnit?
o JUnit 5 Architecture

Company Confidential
 o IDEs and Build Tool Support
o Setting up JUnit with Maven
o Lifecycle Methods
o Test Hierarchies
o Assertions
o Disabling Tests
o Assumptions
o Test Interfaces and Default Methods
o Repeating Tests
o Dynamic Tests
o Parameterized Tests
o Argument Sources
o Argument Conversion
o What Is TDD?
o History of TDD
o Why Practice TDD?
o Types of Testing
o Testing Frameworks and Tools
o Testing Concepts
o Insights from Testing
o Mocking Concepts
o Mockito Overview
o Mockito Demo
o Creating Mock Instances
o Stubbing Method Calls

• Strings, I/O, Formatting, and Parsing

o String, StringBuilder, and StringBuffer
o The String Class
o Important Facts About Strings and Memory
o Important Methods in the String Class
o The StringBuffer and StringBuilder Classes
o Important Methods in the StringBuffer and StringBuilder Classes
o File Navigation and I/O
o Types of Streams
o The Byte-stream I/O hierarchy
o Character Stream Hierarchy
o RandomAccessFile class
o The java.io.Console Class
o Serialization
o Dates, Numbers, and Currency
o Working with Dates, Numbers, and Currencies
o Parsing, Tokenizing, and Formatting
o Locating Data via Pattern Matching
o Tokenizing

• Generics and Collections

o Overriding hashCode() and equals()

Company Confidential
 o Overriding equals()
o Overriding hashCode()
o Collections
o So What Do You Do with a Collection?
o List Interface
o Set Interface
o Map Interface
o Queue Interface
o Using the Collections Framework
o ArrayList Basics
o Autoboxing with Collections
o Sorting Collections and Arrays
o Navigating (Searching) TreeSets and TreeMaps
o Other Navigation Methods
o Backed Collections
o Generic Types
o Generics and Legacy Code
o Mixing Generic and Non-generic Collections
o Polymorphism and Generics

• Threads
o Defining, Instantiating, and Starting Threads
o Defining a Thread
o Instantiating a Thread
o Starting a Thread
o Thread States and Transitions
o Thread States
o Preventing Thread Execution
o Sleeping
o Thread Priorities and yield( )
o Synchronizing Code
o Synchronization and Locks
o Thread Deadlock
o Thread Interaction
o Using notifyAll( ) When Many Threads May Be Waiting

• Concurrent Patterns in Java

o Introducing Executors, What Is Wrong with the Runnable Pattern?
o Defining the Executor Pattern: A New Pattern to Launch Threads
o Defining the Executor Service Pattern, a First Simple Example
o Comparing the Runnable and the Executor Service Patterns
o Understanding the Waiting Queue of the Executor Service
o Wrapping-up the Executor Service Pattern
o From Runnable to Callable: What Is Wrong with Runnables?
o Defining a New Model for Tasks That Return Objects
o Introducing the Callable Interface to Model Tasks
o Introducing the Future Object to Transmit Objects Between Threads

Company Confidential
 o Wrapping-up Callables and Futures, Handling Exceptions

• Concurrent Collections
o Implementing Concurrency at the API Level
o Hierarchy of Collection and Map, Concurrent Interfaces
o What Does It Mean for an Interface to Be Concurrent?
o Why You Should Avoid Vectors and Stacks
o Understanding Copy On Write Arrays
o Introducing Queue and Deque, and Their Implementations
o Understanding How Queue Works in a Concurrent Environment
o Adding Elements to a Queue That Is Full: How Can It Fail?
o Understanding Error Handling in Queue and Deque
o Introducing Concurrent Maps and Their Implementations
o Atomic Operations Defined by the ConcurrentMap Interface
o Understanding Concurrency for a HashMap
o Understanding the Structure of the ConcurrentHashMap from Java 7
o Introducing the Java 8 ConcurrentHashMap and Its Parallel Methods
o Parallel Search on a Java 8 ConcurrentHashMap
o Parallel Map / Reduce on a Java 8 ConcurrentHashMap
o Parallel ForEach on a Java 8 ConcurrentHashMap
o Creating a Concurrent Set on a Java 8 ConcurrentHashMap
o Introducing Skip Lists to Implement ConcurrentMap
o Understanding How Linked Lists Can Be Improved by Skip Lists
o How to Make a Skip List Concurrent Without Synchronization

• Lambda Expressions
o Introduction
o Writing Lambda Expressions
o Functional Interfaces
o Types of Functional Interfaces
o Method reference
• Stream API
o Introduction
o Stream API with Collections
o Stream Operations

Introduction to Design Pattern

Self learning with online links and explanation by Trainer with Demos
o Creational Design Pattern
▪ Factory Pattern

Company Confidential
 ▪ Singleton Pattern
▪ Prototype Pattern
o Structural Design Pattern
▪ Decorator Pattern
▪ Facade Pattern
▪ Proxy Pattern
o Behavioral Design Pattern
▪ Chain Of Responsibility Pattern
▪ Iterator Pattern
▪ Observer Pattern
▪ State Pattern

o Presentation Layer Design Pattern

▪ Intercepting Filter Pattern
▪ Front Controller Pattern
▪ View Helper Pattern
o Business Layer Design Pattern
▪ Business Delegate Pattern
▪ Session Facade Pattern
▪ Transfer Object Pattern
o Integration Layer Design Pattern
▪ Data Access Object Pattern

DevOps/ CI CD concepts (GitHub/Nexus, CI Jenkins, Sonar)

Contents:
• Introduction to DevOps :
o What is DevOps
o Evolution of DevOps
o Agile Methodology
o Why DevOps
o Agile vs DevOps
o DevOps Principles
o DevOps Lifecycle
o DevOps Tools
o Benefits of DevOps
o Continuous Integration and Delivery pipeline
o Use-case walkthrough

• GitHub
o What is DevOps
o Introduction to Git
o Version control
o Repositories and Branches
o Working Locally with GIT
o Working Remotely with GIT

Company Confidential
 • Jenkins
o Introduction to CI
o Jenkins Introduction
o Creating Job in Jenkins
o Adding plugin in Jenkins
o Creating Job with Maven & Git

• Jenkins With TDD(Junit testing)

o Integration of jUnit testing with Jenkins

• Sonar

Database Using PostgreSQL

Duration : 2 days
Contents:

• Introduction
o The Relational Model
o What is PostgreSQL?
o PostgreSQL – Data Types
o Arrays Functions and Operators
• Understanding Basic PostgreSQL Syntax
o The Relational Model
o Basic SQL Commands - SELECT
o Basic SQL Commands - INSERT
o Basic SQL Commands - UPDATE
o Basic SQL Commands – DELETE

• Querying Data with the SELECT Statement

o Wildcards (%, _)
o The SELECT List
o SELECT List Wildcard (*)
o The FROM Clause
o How to Constrain the Result Set
o DISTINCT and NOT DISTINCT
• Arrays Functions and Operators
o array_append
o array_cat
o array_lower
o array_to_string
o array_agg
o every,Count,sum,avg
o Array Operators
• Filtering Results with the Where Clause

Company Confidential
 o WHERE Clause
o Boolean Operators
o The AND Keyword
o The OR Keyword
o Other Boolean Operators BETWEEN, LIKE, IN, IS, IS NOT

• Shaping Results with ORDER BY and GROUP BY

o ORDER BY
o Set Functions
o Set Function And Qualifiers
o GROUP BY
o HAVING clause

• Matching Different Data Tables with JOINs

o Table Aliases
o CROSS JOIN
o INNER JOIN
o OUTER JOINs
o LEFT OUTER JOIN
o RIGHT OUTER JOIN
o FULL OUTER JOIN
o SELF JOIN
o Natural Join

• Creating Database Tables

o CREATE DATABASE
o CREATE TABLE
o NULL Values
o PRIMARY KEY
o CONSTRAINT
o ALTER TABLE
o DROP TABLE
• PostgreSQL Transactions
o BEGIN, COMMIT, ROLLBACK

• PostgreSQL Constraints
o CHECK, UNIQUE, NOT NULL

▪ Introduction to JDBC
o Connection, Statement, PreparedStatement, ResultSet

JPA Using PostgreSQL

Program Duration: 2 days

Contents:
▪ Introduction

Company Confidential
 - Introduction & overview of data persistence
- Overview of ORM tools
- Understanding JPA
- JPA Specifications
▪ Entities
- Requirements for Entity Classes
- Persistent Fields and Properties in Entity Classes
- Persistent Fields
- Persistent Properties
- Using Collections in Entity Fields and Properties
- Validating Persistent Fields and Properties
- Primary Keys in Entities
▪ Managing Entities
- The EntityManager Interface
- Container-Managed Entity Managers
- Application-Managed Entity Managers
- Finding Entities Using the EntityManager
- Managing an Entity Instance's Lifecycle
- Persisting Entity Instances
- Removing Entity Instances
- Synchronizing Entity Data to the Database
- Persistence Units
▪ Querying Entities
- Java Persistence query language (JPQL)
- Criteria API
▪ Entity Relationships
- Direction in Entity Relationships
- Bidirectional Relationships
- Unidirectional Relationships
- Queries and Relationship Direction
- Cascade Operations and Relationships

Spring 5.0
Program Duration: 6 days

Contents:
1. Spring Core
Spring Core Introduction / Overview
- Shortcomings of Java EE and the Need for Loose Coupling
- Managing Beans, The Spring Container, Inversion of Control
- The Factory Pattern
- Configuration Metadata - XML, @Component, Auto-Detecting Beans
- Dependencies and Dependency Injection (DI) with the BeanFactory
- Setter Injection

Company Confidential
 Spring Container
- The Spring Managed Bean Lifecycle
- Autowiring Dependencies

Dependency Injection
- Using the Application Context
- Constructor Injection
- Factory Methods
- Crucial Namespaces ‘p’ and ’c’
- Configuring Collections

Metadata / Configuration
- Annotation Configuration @Autowired, @Required, @Resource
- @Component, Component Scans. Component Filters
- Life Cycle Annotations
- Java Configuration, @Configuration, XML free configuration
- The Annotation Config Application Context

2. Spring MVC
Introduction / Developing Web applications with Spring MVC
- The WebApplicationContext and the ContextLoaderListener
- Model View Controller
- Front Controller Pattern
- DispatcherServlet Configuration
- Controllers, RequestMapping
- Working with Forms
- Getting at the Request, @RequestParam, @RequestHeader
- ModelAndView

Advanced Techniques
- Spring form tags and Model Binding, @ModelAttribute

Spring Controllers
- Using @ResponseBody
- JSON and XML data exchange

RESTful Web Services

- Core REST concepts
- REST support in Spring 5.x
- Use Spring MVC to create RESTful Web services
- REST specific Annotations in Spring
- Working with RestTemplate
- URITemplates, @PathVariable, @RequestParam
- JSON and XML data exchange
- @RequestMapping

3. Spring Boot
SPRING BOOT Introduction

Company Confidential
 - Spring Boot starters, CLI, Gradle plugin
- Application class
- @SpringBootApplication
- Dependency injection, component scans, Configuration
- Externalize your configuration using application.properties
- Context Root and Management ports
- Logging
Using Spring Boot
- Build Systems, Structuring Your Code, Configuration, Spring Beans and
Dependency Injection, and more.

Spring Boot Essentials

- Application Development, Configuration, Embedded Servers, Data Access, and
many more
- Common application properties
- Auto-configuration classes
- Spring Boot Dependencies

4. Spring Data JPA

- Spring Data JPA Intro & Overview
- Core Concepts, @RepositoryRestResource
- Defining Query methods
- Query Creation
- Using JPA Named Queries
- Defining Repository Interfaces
- Creating Repository instances
- JPA Repositories
- Persisting Entities
- Transactions

5. Spring Data REST

- Introduction & Overview
- Adding Spring Data REST to a Spring Boot Project
- Configuring Spring Data REST
- Repository resources, Default Status Codes, Http methods
- Spring Data REST Associations
- Define Query methods

6. Introduction to Spring Security with Demo

7. Introduction to Spring Microservices with Demo

HTML 5, CSS 3 with Bootstrap, Javascript ES6

Program Duration: 4 days

Contents:
HTML 5:

Company Confidential
 • HTML Basics
o Understand the structure of an HTML page.
o New Semantic Elements in HTML 5
o Learn to apply physical/logical character effects.
o Learn to manage document spacing.
• Tables
o Understand the structure of an HTML table.
o Learn to control table format like cell spanning, cell spacing, border
• List
o Numbered List
o Bulleted List
• Working with Links
o Understand the working of hyperlinks in web pages.
o Learn to create hyperlinks in web pages.
o Add hyperlinks to list items and table contents.
• Image Handling
o Understand the role of images in web pages
o Learn to add images to web pages
o Learn to use images as hyperlinks
• Frames
o Understand the need for frames in web pages.
o Learn to create and work with frames.
• HTML Forms for User Input
o Understand the role of forms in web pages
o Understand various HTML elements used in forms.
o Single line text field
o Text area
o Check box
o Radio buttons
o Password fields
o Pull-down menus
o File selector dialog box
• New Form Elements
o Understand the new HTML form elements such as date, number, range, email, search
and datalist
o Understand audio, video, article tags

CSS 3
▪ Introduction to Cascading Style Sheets 3.0
- What CSS can do
- CSS Syntax

Company Confidential
 - Types of CSS
▪Working with Text and Fonts
- Text Formatting
- Text Effects
- Fonts
▪ CSS Selectors
- Type Selector
- Universal Selector
- ID Selector
o Class selector
▪ Colors and Borders
- Background
- Multiple Background
- Colors RGB and RGBA
- HSL and HSLA
- Borders
- Rounded Corners
- Applying Shadows in border
• Implementing CSS3 in the "Real World"
o Modernizr
o HTML5 Shims
o SASS, and Other CSS Preprocessors
o CSS Grid Systems
o CSS Frameworks

BootStrap

▪ Introduction to Bootstrap
- Introduction
- Getting Started with Bootstrap
▪ Bootstrap Basics
- Bootstrap grid system
- Bootstrap Basic Components
▪ Bootstrap Components
- Page Header
- Breadcrumb
- Button Groups
- Dropdown
- Nav & Navbars
▪ JavaScript Essentials
▪ ES6
- Var, Let and Const keyword
- Arrow functions, default arguments
- Template Strings, String methods
-
- Object de-structuring

Company Confidential
 - Create,apply,prototype,bind method
- Spread and Rest operator
- Typescript Fundamentals
- Types & type assertions, Creating custom object types, function types
- Typescript OOPS - Classes, Interfaces, Constructor, etc
- Decorator & Spread Operator
- Difference == & ===
• Asynchronous Programming in ES6
- Promise Constructor
- Promise with Chain
- Promise Race
-

React JS
Program Duration: 6 days

Contents:
• Getting started with Node.js
o JavaScript Essentials
o How JavaScript works
o Event loop
o Stack, Heap and Queue
o Node.js Fundamentals
o Introduction to Node.js
o Why Node.js?
o Traditional Programming Limitations

• React Introduction
o Overview of frameworks, libraries for client side Web applications
o React introduction,
o Understanding “what” and “why” React
o React Component Demonstration using codepen
o Environment Setup for React Application
o Understanding NPM commands
o Using VS Code
o VS Code extensions for ES6, React(formatting and checkstyles)
o Helloworld app in React
• React Essential Features and Syntax
o React App Project Directory Structure
o Overview of Webpack, Babel

Company Confidential
 o React Component Basic
o Create React Component
o Understanding JSX
o Limitations of JSX
o Working with Components and Reusing Components
• React Components, Props and State
o Understanding and using Props and State
o Handling Events with methods
o Manipulating the State
o Two way data-binding
o Functional (Stateless) VS Class (Stateful) Components
o Parent – Child Communication
o Dynamically rendering contents
o Showing Lists, List and keys
• Styling Components
o CSS Styling
o Scoping Styles using Inline Styles
o Limitations of inline styes
o Inline Styles with Radium
• Google Material UI
o Installing Material UI
o Material UI AppBar
o Material UI's Toolbar
o Custom React NavBar CSS
o Material UI Buttons
o Using Material UI - Rendering a Button
o Material UI Card
o Material UI Checkbox
o Material UI Grid Component
o Material UI IconButton
o Material UI Paper Component
o Style Material UI Components with my own CSS
o UI Templates for Business
o Typography Usage
• Debugging React Apps
o Understanding React Error Messages
o Handling Logical Errors,
o Debugging React apps using google developer tools and React DevTool
o Understanding Error Boundaries
• React Component life cycle
o Updating life cycle hooks
o PureComponents
o React’s DOM Updating Strategy
o Returning adjacent elements
o Fragments
• React Component in Details
o Higher Order Components

Company Confidential
 o Passing unknown Props
o Validating Props
o Using References
o React Context API
o Updated LifeCycle hooks (16.3)
o Best practices for React Projects
o Demo apps
• HTTP Requests/Ajax Calls
o HTTP Requests in React
o Introduction of Axios package
o HTTP GET Request, fetching & transforming data
o HTTP POST, DELETE, UPDATE
o Handing Errors
o Adding/Removing Interceptors
o Creating/Using Axios intances
o Redux
o React Thunk
o Difference between Thunk & other
o React hooks
o Application Using React & Redux

• React Routing
o Routing and SPAs
o Setting Up the Router Package
o react-router vs react-router-dom
o Preparing the Project For Routing
o Switching Between Pages, Routing-Related Props
o The "withRouter" HOC & Route Props
o Passing & extracting route/query parameters
o Using Switch to Load a Single Route
o Navigating Programmatically
• React Forms and Form Validation
o Creating a Custom Dynamic Input Component
o Setting Up a JS Config for the Form
o Dynamically Create Inputs based on JS Config
o Adding a Dropdown Component
o Handling User Input
o Handling Form Submission
o Adding Custom Form Validation
o Fixing a Common Validation
o Adding Validation Feedback
o Showing Error Messages
o Handling Overall Form Validity
• Deploying React App to the Web
• Testing React apps with Jasmine & implementining JEST

Company Confidential