Java Full Stack Structure (12 weeks)………………. 2
Core Java 8 + JDBC………………………………. 2
Database & SQL………………………………….. 8
JDBC…………………………………………… 9
HTML 5, CSS 3 with Bootstrap……………………… 9
JavaScript, Typescript & Angular 6………………… 11
Servlets 3.0……………………………………. 13
JPA with Hibernate 3.0…………………………… 14
Spring 5.0……………………………………… 14
Parallel Project Evaluation………………………. 15
BDD……………………………………………. 15
Quality Process Awareness………………………… 16
Pseudo Live Project (PLP)………………………… 16


JEE LoT provides exposure to the entire spectrum of Java technologies starting from Core Java to Spring as well as testing. It focuses on Web Application development using Spring Technology. The following table lists the course structure for JEE LoT.

Sl No Course Duration (In Days)
1 Discover 2
2 Campus to Corporate 2
3 Core Java 8 + Database & SQL + JDBC 17
4 Core Java 8 Test 1
5 HTML 5, CSS 3 with bootstrap 4 2
6 Javascript, Typescript & Angular 6 5
7 Servlets 3.0 2
8 HTML5, CSS + Angular 6 Test 0.5
9 Soft skills Part I 0.5
10 JPA with Hibernate 3
11 Spring 5.0 7
12 Parallel Project Evaluation 1
13 Spring 4.0 + JPA with Hibernate 3.0 Test 0.5
14 Soft Skills Part II 0.5
15 BDD 5
16 BDD Test 0.5
17 Soft Skills Part III 0.5
18 Quality Process Awareness + PLP + PLP Presentation 8
19 L1 Preparation + Test 2
Total Training Duration 60

JEE Curriculum

Core Java 8 +JDBC
Program Duration: 15 days

• Declarations and Access Control
a. Identifiers & JavaBeans
b. Legal Identifiers
c. Sun’s Java Code Conventions
d. JavaBeans Standards
e. Declare Classes
f. Source File Declaration Rules
g. Class Declarations and Modifiers
h. Concrete Subclass
i. Declaring an Interface
j. Declaring Interface Constants
k. Declare Class Members
l. Access Modifiers
m. Nonaccess Member Modifiers
n. Constructor Declarations
o. Variable Declarations
p. Declaring Enums

• Object Orientation
a. Encapsulation
b. Inheritance, Is-A, Has-A
c. Polymorphism
d. Overridden Methods
e. Overloaded Methods
f. Reference Variable Casting
g. Implementing an Interface
h. Legal Return Types
i. Return Type Declarations
j. Returning a Value
k. Constructors and Instantiation
l. Default Constructor
m. Overloaded Constructors
n. Statics
o. Static Variables and Methods
p. Coupling and Cohesion

• Assignments
a. Stack and Heap—Quick Review
b. Literals, Assignments, and Variables
c. Literal Values for All Primitive Types
d. Assignment Operators
e. Casting Primitives
f. Using a Variable or Array Element That Is Uninitialized and Unassigned
g. Local (Stack, Automatic) Primitives and Objects
h. Passing Variables into Methods
i. Passing Object Reference Variables
j. Does Java Use Pass-By-Value Semantics?
k. Passing Primitive Variables
l. Array Declaration, Construction, and Initialization
m. Declaring an Array
n. Constructing an Array
o. Initializing an Array
p. Initialization Blocks
q. Using Wrapper Classes and Boxing
r. An Overview of the Wrapper Classes
s. Creating Wrapper Objects
t. Using Wrapper Conversion Utilities
u. Autoboxing
v. Overloading
w. Garbage Collection
x. Overview of Memory Management and Garbage Collection
y. Overview of Java’s Garbage Collector
z. Writing Code That Explicitly Makes Objects Eligible for Garbage Collection

• Operators
a. Java Operators
b. Assignment Operators
c. Relational Operators
d. instanceof Comparison
e. Arithmetic Operators
f. Conditional Operator
g. Logical Operators

• Flow Control, Exceptions
a. if and switch Statements
b. if-else Branching
c. switch Statements
d. Loops and Iterators
e. Using while Loops
f. Using do Loops
g. Using for Loops
h. Using break and continue
i. Unlabeled Statements
j. Labeled Statements
k. Handling Exceptions
l. Catching an Exception Using try and catch
m. Using finally
n. Propagating Uncaught Exceptions
o. Defining Exceptions
p. Exception Hierarchy
q. Handling an Entire Class Hierarchy of Exceptions
r. Exception Matching
s. Exception Declaration and the Public Interface
t. Rethrowing the Same Exception
u. Common Exceptions and Errors

• Maven Fundamentals
a. Introduction
b. Folder Structure
c. The pom.xml
d. Dependencies
e. Goals
f. Scopes
g. The Compiler Plugin
h. Source Plugin
i. Jar Plugin

• TDD with Junit 5
a. Types of Tests
b. Why Unit Tests Are Important
c. What’s JUnit?
d. JUnit 5 Architecture
e. IDEs and Build Tool Support
f. Setting up JUnit with Maven
g. Lifecycle Methods
h. Test Hierarchies
i. Assertions
j. Disabling Tests
k. Assumptions
l. Test Interfaces and Default Methods
m. Repeating Tests
n. Dynamic Tests
o. Parameterized Tests
p. Argument Sources
q. Argument Conversion
r. What Is TDD?
s. History of TDD
t. Why Practice TDD?
u. Types of Testing
v. Testing Frameworks and Tools
w. Testing Concepts
x. Insights from Testing
y. Mocking Concepts
z. Mockito Overview
aa. Mockito Demo
bb. Creating Mock Instances
cc. Stubbing Method Calls

• Strings, I/O, Formatting, and Parsing
a. String, StringBuilder, and StringBuffer
b. The String Class
c. Important Facts About Strings and Memory
d. Important Methods in the String Class
e. The StringBuffer and StringBuilder Classes
f. Important Methods in the StringBuffer and StringBuilder Classes
g. File Navigation and I/O
h. Types of Streams
i. The Byte-stream I/O hierarchy
j. Character Stream Hierarchy
k. RandomAccessFile class
l. The Class
m. Serialization
n. Dates, Numbers, and Currency
o. Working with Dates, Numbers, and Currencies
p. Parsing, Tokenizing, and Formatting
q. Locating Data via Pattern Matching
r. Tokenizing

• Generics and Collections
a. Overriding hashCode() and equals()
b. Overriding equals()
c. Overriding hashCode()
d. Collections
e. So What Do You Do with a Collection?
f. List Interface
g. Set Interface
h. Map Interface
i. Queue Interface
j. Using the Collections Framework
k. ArrayList Basics
l. Autoboxing with Collections
m. Sorting Collections and Arrays
n. Navigating (Searching) TreeSets and TreeMaps
o. Other Navigation Methods
p. Backed Collections
q. Generic Types
r. Generics and Legacy Code
s. Mixing Generic and Non-generic Collections
t. Polymorphism and Generics

• Threads
a. Defining, Instantiating, and Starting Threads
b. Defining a Thread
c. Instantiating a Thread
d. Starting a Thread
e. Thread States and Transitions
f. Thread States
g. Preventing Thread Execution
h. Sleeping
i. Thread Priorities and yield( )
j. Synchronizing Code
k. Synchronization and Locks
l. Thread Deadlock
m. Thread Interaction
n. Using notifyAll( ) When Many Threads May Be Waiting

• Concurrent Patterns in Java
a. Introducing Executors, What Is Wrong with the Runnable Pattern?
b. Defining the Executor Pattern: A New Pattern to Launch Threads
c. Defining the Executor Service Pattern, a First Simple Example
d. Comparing the Runnable and the Executor Service Patterns
e. Understanding the Waiting Queue of the Executor Service
f. Wrapping-up the Executor Service Pattern
g. From Runnable to Callable: What Is Wrong with Runnables?
h. Defining a New Model for Tasks That Return Objects
i. Introducing the Callable Interface to Model Tasks
j. Introducing the Future Object to Transmit Objects Between Threads
k. Wrapping-up Callables and Futures, Handling Exceptions

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

• Lambda Expressions
a. Introduction
b. Writing Lambda Expressions
c. Functional Interfaces
d. Types of Functional Interfaces
e. Method reference

• Stream API
a. Introduction
b. Stream API with Collections
c. Stream Operations

Database & SQL

Program Duration:2 days


• Introduction
a. The Relational Model

• Understanding Basic SQL Syntax
a. The Relational Model
b. Basic SQL Commands – SELECT
c. Basic SQL Commands – INSERT
d. Basic SQL Commands – UPDATE
e. Basic SQL Commands – DELETE

• Querying Data with the SELECT Statement
a. The SELECT List
b. SELECT List Wildcard (*)
c. The FROM Clause
d. How to Constrain the Result Set

• Filtering Results with the Where Clause
a. WHERE Clause
b. Boolean Operators
c. The AND Keyword
d. The OR Keyword
e. Other Boolean Operators BETWEEN, LIKE, IN, IS, IS NOT

• Shaping Results with ORDER BY and GROUP BY
b. Set Functions
c. Set Function And Qualifiers
e. HAVING clause

• Matching Different Data Tables with JOINs

• Creating Database Tables
c. NULL Values

• Introduction to JDBC
a. Introduction to JDBC
b. Architecture of JDBC
c. Role of Driver Manager
d. Understanding JDBC Driver Types

• Getting Started with JDBC
a. Connecting to Database using JDBC
b. Managing Database resources
c. Handling JDBC Exceptions

• Performing Basic CRUD operations using JDBC
a. Executing Static SQL Statements
b. Iterating Through ResultSets
c. Understanding Scrollable ResultSets
d. Understanding Updatable ResultSets
e. Understanding PreparedStatement
f. Retrieving Data Using PreparedStatement
g. Inserting the Record
h. Updating the Record
i. Removing the Record

HTML 5,CSS 3 with Bootstrap
Program Duration:2 days

• HTML Basics

a. Understand the structure of an HTML page.
b. New Semantic Elements in HTML 5
c. Learn to apply physical/logical character effects.
d. Learn to manage document spacing.

• Tables
a. Understand the structure of an HTML table.
b. Learn to control table format like cell spanning, cell spacing, border

• List
a. Numbered List
b. Bulleted List

• Working with Links
a. Understand the working of hyperlinks in web pages.
b. Learn to create hyperlinks in web pages.
c. Add hyperlinks to list items and table contents.

• Image Handling
a. Understand the role of images in web pages
b. Learn to add images to web pages
c. Learn to use images as hyperlinks

• Frames
a. Understand the need for frames in web pages.
b. Learn to create and work with frames.

• HTML Forms for User Input
a. Understand the role of forms in web pages
b. Understand various HTML elements used in forms.
c. Single line text field
d. Text area
e. Check box
f. Radio buttons
g. Password fields
h. Pull-down menus
i. File selector dialog box

• New Form Elements
a. Understand the new HTML form elements such as date, number, range, email, search and datalist
b. Understand audio, video, article tags

• Introduction to Cascading Style Sheets 3.0
a. What CSS can do
b. CSS Syntax
c. Types of CSS

• Working with Text and Fonts
a. Text Formatting
b. Text Effects
c. Fonts

• CSS Selectors
a. Type Selector
b. Universal Selector
c. ID Selector
d. Class selector

• Colors and Borders
a. Background
b. Multiple Background
c. Colors RGB and RGBA
d. HSL and HSLA
e. Borders
f. Rounded Corners
g. Applying Shadows in border

• Introduction to Bootstrap
a. Introduction
b. Getting Started with Bootstrap

• Bootstrap Basics
a. Bootstrap grid system
b. Bootstrap Basic Components

• Bootstrap Components
a. Page Header
b. Breadcrumb
c. Button Groups
d. Dropdown
e. Nav & Navbars

JavaScript, Typescript & Angular 6
Program Duration: 5 days

• ES6 & Typescript
a. Var, Let and Const keyword
b. Arrow functions, default arguments
c. Template Strings, String methods
d. Object de-structuring
e. Spread and Rest operator
f. Typescript Fundamentals
g. Types & type assertions, Creating custom object types, function types
h. Typescript OOPS – Classes, Interfaces, Constructor, etc

• Introduction to Angular Framework
a. Introduction to Angular Framework, History & Overview
b. Environment Setup, Angular CLI, Installing Angular CLI
c. NPM commands &package.json
d. Bootstrapping Angular App, Components, AppModule
e. Project Setup, Editor Environments
f. First Angular App & Directory Structure
g. Angular Fundamentals, Building Blocks
h. MetaData

• Essentials of Angular
a. Component Basics
b. Setting up the templates
c. Creating Components using CLI
d. Nesting Components
e. Data Binding – Property & Event Binding, String Interpolation, Style binding
f. Two-way data binding
g. Input Properties, Output Properties, Passing Event Data

• Templates, Styles & Directives
a. Template, Styles, View Encapsulation, adding bootstrap to angular app
b. Built-in Directives, Creating Attribute Directive
c. Using Renderer to build attribute directive
d. Host Listener to listen to Host Events
e. Using Host Binding to bind to Host Properties

• Pipes, Services & Dependency Injection
a. In-built Pipes, Creating a Custom Pipes
b. Services & Dependency Injections
c. Creating Data Service
d. Understanding Hierarchical Injector

• Template-Driven and Reactive Forms
a. Template-Driven vs Reactive Approach
b. Understanding Form State
c. Built-in Validators & Using HTML5 Validation
d. Grouping Form Controls
e. FormGroup, FormControl, FormBuilder
f. Forms with Reactive Approach
g. Predefined Validators & Custom Validators
h. Showing validation errors

• Components Deep Dive / Routing
a. Component Life Cycle Hooks
b. Reusable components in angular using
c. Navigating with Router links
d. Understanding Navigation Paths
e. Navigating Programmatically
f. Passing Parameters to Routes
g. Passing Query Parameters and Fragments
h. Setting up Child (Nested) Routes
i. Outsourcing Route Configuration (create custom module)

• Http Requests / Observables
a. HTTP Requests
b. Sending GET Requests
c. Sending a PUT Request
d. Using the Returned Data
e. Catching Http Errors
f. Basics of Observables & Promises

• Deployment / Authentication
a. JIT vs AOT Compilation
b. Deployment
c. How Authentication works in SPA
d. JSON Web Tokens
e. Signup, Login and logout application
f. Router Protection, Route Guards
g. CanActivate interface

Servlets 3.0
Program Duration: 2 days.
• Java Web Applications

a. Web Applications – An Overview
b. Web Components
c. JEE Containers

• Introduction to Servlets API and Ease of Development through Annotations
a. Introduction to Servlet
b. Role of Servlets in Web Application Design
c. Advantages of Servlets
d. Basic Servlet Architecture: Servlet Container
e. Servlet Lifecycle
f. Ease of Developing Servlets through Annotations
g. Retrieving Information from HTML Page

• Request Object
a. Processing Get and Post Requests from Web Clients
b. Request Dispatcher

• Listener
• Session Tracking

a. Introduction and Need for Session Tracking
b. Different Techniques for Session Management
c. Examples and Best Practices

JPA with Hibernate 3.0
Program Duration:3 days

• Introduction to ORM and its need
• The Persistence Life Cycle
• Java persistence API (JPA)
• Association and Mapping

Spring 5.0
Program Duration:7 days


• Introduction to Spring Platform and environment and Spring Boot Features

• Introduction to Spring Framework, IoC
a. What is Spring Framework,Benefits of Spring
b. The Spring architecture
c. IOC – Inversion of control, wiring beans
d. Bean containers, lifecycle of beans in containers
e. Customizing beans with BeanPostProcessors&BeanFactoryPostProcessors
f. XML and Annotation-based, mixed configurations
g. Java configuration

• Spring MVC framework
a. Introduction: DispatcherServlet, Handler mappings, Resolving views
b. Annotation-based controller configuration
c. Web Based Application Using Spring Boot
d. Introduction to Web Services
e. Introduction to REST web Services
f. REST Controllers on the top of MVC
g. Spring Boot Integration with Rest

• Spring JPA Integration
a. Spring support for JPA
b. Implementing Spring JPA integration
c. Spring Data
d. Spring Boot(Annotation based and Java configuration)
e. Spring ReST
f. Spring DATA ReST

Parallel Project Evaluation
Program Duration:1 day



Program Duration: 5days


• Introduction to BDD; TDD vs BDD;How BDD supports Agile
• Gherkins Language- Basics
• Gherkins Language- Feature, scenarios, scenario outlines;Data driven scenario outlines, Backgrounds
• Cucumber – Step definition binding; Running and debugging scenarios
• Cucumber – Creating a step definition with data table
• Automated UI vs Manual UI testing; Introduction to selenium
• Selenium – Webdriver; Creating first testHTML element selection; working with forms
• Selenium – Business readbale UI automation with cucumberAdding a cucumber scenario
• Selenium – Introducing Page Object Models

• Testing a REST api with cucumber and gherkins (Case study)

Quality Process Awareness
Program Duration: 0.5 day.


• Understand the following :
a. Quality – What and Why
b. Introduction to Quality Management System
c. QMS support to Software Methodology
d. Metrics
e. Defect Prevention

Pseudo Live Project (PLP)
Program Duration: 7.5 days.


Pseudo Live Project (PLP) program is primarily to handhold participants who are fresh into the IT stream & newly recruited from college.PLP project is executed to orient the trainees towards Quality processes followed in the organization.In PLP, more importance given to “Process Adherence” . Maven, Jenkins, GIT, Sonar are the Devops concepts to be introduced during PLP.

• Agile methodology should be carried out during PLP