Java Online Training

Course Duration : 90 to 100 Hrs

Java is one of the most dynamic, powerful and popular programming languages used today. This is an object-oriented programming language. Java has been evolved from a language known as Oak. Java language finds its own position in today's IT Industry. Every IT professional should be thorough with the Java programming since major projects are done in this language.

Core Java - Java Standard Edition

Introduction:

Introduction to java platform, javac, java, data types, source file, comments, setup.

Flow Control

Conditional constructs
- Different types of if condition
Looping constructs
- While
- Do-while
- For
- For-each
break, continue
Switch statement

Object Oriented Programming

Introduction to Object Oriented Programming
Introduction to Classes and Objects
Instance & Static variables
Constructor
Methods
Instance & Static methods
Static & Instance blocks

Packages

Package creation
Importing packages
Importing Class

Inheritance:

Extending classes
Constructor calling chain
The “super” keyword
Method overriding
Method hiding
Final Class and Method

Abstract classes and Interfaces

Abstract methods
Abstract classes
Interfaces
Implementing interfaces
Abstract class vs. Interfaces

Inner classes

Non-static inner class
Static inner class
Local inner class
Anonymous inner class

Exception Handling

Introduction to exceptions
Effects of exception
Exception Handling framework
Exception class Hierarchy
Custom exception class
Assertions

Memory Management

Different types of memory used in Java
Garbage Collection
Memory Leaks

Collections Framework

Introduction to collections
Core Collection Interfaces
List interface and its implementations
Set interface and its implementations
Queue interface and its implementations
Map interface and its implementations

Java I/O Stream

I/O Streams Introduction
Types of Streams
Stream class Hierarchy
Buffered Streams
Working File Streams

Serialization

Introduction to serialization
Serialization process
Deserialization process

Threads

Introduction to threads
Thread states and priorities
Thread class
Runnable interface
Thread Group
Synchronization
Inter thread communication

Generics, Enums, AutoBoxing

Internationalization., Locale, Formatting text and dates

Logging

Introduction to logging
Loggers
Handlers
Formatters
Configuration

JDBC API

Understanding the design of JBDC API
Obtaining JDBC Drivers
Establish connection with DB Servers
Execute SQL Queries using Statement and Prepared Statement
Fetch the data
- Reading the records using result set object
Adding and Updating the records

J2ee- Java Enterprise Edition(JEE)

Enterprise applications provide the business logic for an enterprise. They are centrally managed and often interact with other enterprise software.

The aim of the Java EE platform is to provide developers with a powerful set of APIs while shortening development time, reducing application complexity, and improving application performance. Using Java EE we can develop web, distributed multitier applications.

Web application development

Introduction to web application development
Purpose of web application development
Various elements of web applications
Setting up Tomcat web server and Eclipse WTP
Developing dynamic web applications using Servlet’s
- Overview of Servlet2.5 & 3 API’s
- Handling a client’s request using Servlet
- Configuring servlet’s using xml and annotations
- Web Container
- Servlet Life Cycle
- Http Protocol
  - Http Request Format
  - Http Response Format
- Coordinating servlets
- Scope objects(Sharing data)

Servlet Filters

Filter basics
Creating a filter
Understanding the applications of filters

Servlet Listeners

Listener’s basics
Creating a listener & registering
Understanding the applications of listeners

Session Tracking
JSP (JavaServerPages)

JSP Elements
- Directives
- Declarations
- Scriptlets
- Expressions
- JSP Actions
- Comments
Implicit objects
Expression Language (EL)
JSTL(JSP Standard Tag Libraray)
- Core Tags
- Formatting tags
- SQL tags
- XML tags
- JSTL Function
Creating Custom JSP Tag Libraries: The Basic
- Java-based tags
- Components of a tag library
- Basic tags
- Tags that use body content
- Tags that optionally use body content
JSP-based tags (tag files)
- Components of a tag library
- Basic tags
- Tags that use attributes
- Tags that use body content

XML Processing API's

XML syntax and namespaces
Describing XML with schema
Java APIs for XML Parsing and Transformation
JAXP, SAX, and DOM

Java API for XML Binding(JAXB)

The need for Data Binding
Mapping schema types for Java
Java-to-xml mapping using annotation’s
Marshalling and Unmarshalling with JAXB
Working with JAXB Object models

Java Persistence API (JPA)

Entity class and O/R mappings
Persistent fields and properties
Entity relationship mappings
- One-One
- One-Many
- Many-One
- Many-Many
Inheritance mappings
Annotations and XML descriptors for defining mappings
Entity Operations
- The EntityManager interface
- Entity instance life cycle
- Entity listeners and call-back methods
Java Persistence Query Language (JPQL)

Understanding Other Data binding Frameworks in Java

XMLBeans

Hibernate Frame work

Object Persistence

Object/Relational Paradigms
O/R Mismatch
Object Relational Mapping (ORM)
Java ORM/Persistent Frameworks

Hibernate Architecture

Hibernate Architecture and API
Hibernate Installation/Setup
Configuration
Configuration Properties
Mapping Files

Persistent Classes

POJOs
JavaBeans
Basic Mapping
Class to Table Mappings
Property Mapping
Identifiers
Generators
Natural Keys
Identifier Exposure
Quoting SQL Tables and Columns

Working with Persistent Objects

Entity Lifecycle
Transient State
Persistent State
Persistent Object Updates and Automatic Dirty Checking
Deattached State
Deleted
Object Identifiers Revisited
Merge

Components

Domain Model
Entities and Values
Components

Associations

Many-to-one
Bidirectional Many-to-one
Other Collections
Other Associations
One-to-one
Bidirectional One-to-one
Many-to-many
Bidirectional Many-to-many

Value Type Collections

Collections of Value Types
Collections of Components
Sorting Collections

Inheritance

Inheritance Mapping Strategies
Table per concrete class
Table per subclass
Table per hierarchy
Inheritance Mapping Pros/Cons
Polymorphism
Table per concrete class with unions
Choosing an Inheritance Strategy

Transitive Persistence

Lazy Loading
Proxies
Eager Loading
What’s a Proxy?
Detached Objects and Proxies
Polymorphic Associations Revisited

HQL

Hibernate Object Fetching Options
Hibernate Query
HQL Parameters
Named Queries
Native SQL

Criteria

Restrictions
Query By Example
Scrolling
Query Hints
Query Option Pros/Cons

Transactions and Concurrency

The Java Transaction
Hibernate Transaction Configuration
Hibernate Transaction API
Concurrency
Isolation Levels
Optimistic Locking
Versioning
Pessimistic Locking

Cache

Hibernate Caching Architecture
First Level Cache
Second Level Cache
Cache Concurrency
Configuring Second Level Cache

Spring Frame work

Overview of Spring3 modules

The Core IOC Module
AOP (Aspect Oriented Programming)
Spring JDBC
Spring ORM(Object Relational Mapping)
Spring JEE (Java Enterprise Edition)
Spring MVC
Spring Security

Dependency Injection /Inversion of control
IOC Containers

Instantiating a container
Application Context
Using the container
Creating beans
Injecting dependencies
Auto wiring
Bean scope
Bean life cycle
Property Editors
Event Handling

Spring 3 Expression Language(SpEL)

The Spring Expression Language (SpEL for short) is a powerful expression language that supports querying and manipulating an object graph at runtime

Annotation Driven Configuration in Depth

Stereotypes: @Component, @Service, @Controller, @Repository
Java EE 5 Annotation Support
Defining Custom Annotations
Autowiring
- @Autowired on setters, constructures, methods, fields
- Injecting resources like ApplicationContext
- Fine tuning with @Qualifier
Java Based Bean Metadata (JavaConfig)
- Overview - code-centric Configuration
- @Confguration, @Bean, and @Value
- Importing and @Import
- Autowiring in Configuration Classes
- Mixing XML Configuraiton and @Configuration

AspectOrientedProgramming

AOP Concepts
Advices and its types
Auto proxying
AOP Proxies
AspectJ Style of Programming
- @Aspect
- @Before
- @After
- @AfterReturning
- @Around
- @AfterThrowing
- Working with point cut expression’s

Spring Web MVC Annotation driven

Introduction to Spring MVC Flow
DispatcherServlet
Handlers, HandlerMappings,View Resolvers
Writing Controllers, @Controller, @RequestMapping, @RequestParam, @PathVariable
The HTTP Request/Response - @RequestBody and @ResponseBody
Binding and Validation, @ModelAttribute
Session Attributes, @SessionAttributes

Spring JDBC

Spring Jdbc Template
Row Mappers
Exception Handling
Transaction Management

Object Relational Mapping Intergration

Spring-Hibernate integration
Spring-JPA integration

Spring Transaction (TX) Management

Intro to Spring Transaction Management
- Overview, Component TX Model, TX Propagation, Declarative Transactions, Transaction Managers
Using Spring Transactions
Annotation Configured Transactions
- @Transactional and its settings
XML Configured Transactions
- new elements, Configuring tx:advice, and tx:attributes
Defining the TX advisor

Spring Security

Overview - Capabilities, Architecture
Introduction to Spring Security
- HTTP Security
- Method Security
- Annotation-Based Security
- Expression-Based Access Control
Authentication Providers
Custom User Service Details
Authentication Using Custom DB Tables

Struts 2 Framework

Struts 2 - Overview

The Big picture - Why and What of Struts 2
Architecture - Identifying the key components
MVC and Struts 2
Workflow: Request-Response lifecycle
Anatomy of a Struts 2 application
Installation and configuration
Configuring Struts 2 with Spring
Configuring eclipse for Struts 2 development

Application Development with Struts 2

Key concepts
The Action objects
Configuration
Dependency Injection
Debugging

Action

The Action interface
The ModelDriven interface
The ActionSupport class
Implementing Actions
Chaining Actions
Configuring Actions

Results

The Result interface
Chain Result
Dispatcher Result
HttpHeader Result
Redirect Result
Redirect Action Result

Introduction to Ajax

The problem with traditional web applications
Contacting the server without page refreshing
The XmlHttpRequest object

Presentation with Struts Tags

Generic Tags
UI Tags
Themes and Templates
Ajax Tags
OGNL
Tabular inputs
HTML form buttons
Using Checkboxes
Iterator tag
Formatting dates and numbers
Skinning
Multiple Submit Buttons
Tabular inputs with HashMap

Interceptors

Introduction to AOP
The Interceptor interface
Implementing aspects using interceptors
Configuring interceptors in struts.xml
Interceptor Order
File Upload Interceptor
ExecuteAndWait Interceptor

Test-driven Development

JUnit
Writing unit tests
Test Actions

Validation

Basic Validation
Client Validation
AJAX Validation
Using Field Validators
Using Non Field Validators
Using Visitor Field Validator

Type Conversion

Built in Type Conversion Support
Implementing a custom Type Converter
Null Property Handling
Type Conversion Error Handling

REST Full Web Services (JAX-RS with Jersey Implementation)

Understand the advantages of the REST architecture for web services
Developing REST Full Web services using JAX-RS
Manage XML content using XML Schema and JAXB
Understanding Resources
Using Http Methods to represent CRUD operations
Dispatching Request to Methods
- The Application Path
- The @Path Annotation
- The HTTP Method Annotations
- Sub-Resource Locators
- Annotation Inheritance and overriding
Parameters
- Different Types of Parameters
Response Types
- @Produces
- Working with different response types
  - Java Objects
  - XML
  - JSON
  - HTML/Text
  - Binary Content
Understanding RESTFull Web services support in Spring Framework with a sample application

SOAP Based Web Services(Axis2 & JAX-WS)

Defining SOAP Messages with WSDL

Structure of SOAP messages
- SOAP over HTTP
- SOAP Envelope
- The message header
- The message body
- Soap faults
- Attachments

Role of SOAP in Web services Anatomy of a WSDL document

WSDL Basics
WSDL Bindings

Overview of Web Services and Apache Axis2

Apache Axis2
Axis2 Features
Axis2 Architecture and Processing Model

Simple Web Services

Deploy the Service
Run the Client
SOAP Overview
The SOAP Document
WSDL Overview
WSDL Content
Abstract WSDL Elements
Concrete WSDL Elements
SOAP Monitor

Apache Axis2 Web Service Clients

Steps to Create a Client
Obtain the WSDL File
Generated Code
Client Code Overview
Import the Generated Classes
Instantiate the Stub
Set the Request Parameters
Call the Service Method and Get the Results
Compile and Run the Client Code

Apache Axis2 Web Service End-points

Creating Server Code
Steps to Create a POJO Service
Building a POJO
The Server Descriptor
The service Element
MEPs and Message Receivers
More services.xml Configurations
AAR Files
Generating WSDL from Java Code
Steps to Create a WSDL Based Service
Generate Server Artifacts from WSDL
Steps to Edit the Skeleton
Import the Generated Classes
Get the Parameters
Write the Business Code
Instantiate a Response
Build and Deploy

Exposing Plain Old Java Objects (POJOs) as Web Services Implementing code-first Web services

Choosing between WSDL-first and code-first Web services
Generating portable artifacts using JAX-WS
Preserving maintainability with proxies and adapters

Improving generated WSDL

Annotating Java services
Deploying end points

Implementing Web Service Clients in Java Generating client code from WSDL

Accessing Web services through their WSDL
Creating client source files from WSDL
Customizing generated source files with JAX-WS

JSF 2.0

JSF Overview

Model View Controller
JSF elements - web.xml and faces-config.xml
The power of Facelets
- tile-like composition
- debugging/error handling
- custom logic tags and expressions
- XHTML
JSF 2.0 - quick summary of features
Annotations - a review

GUI Components 1

Component Families
UIViewRoot and the FacesContext
The JSF lifecycle
- GET vs. POST(JSF 2.0)
Facelets pages
Output components - text and labels
Forms
Formatting output
Inputting text and passwords
Messages and severity

Navigation in JSF applications

Navigation rules and cases via annotations
Static vs. dynamic actions
Declaring navigation in faces-config.xml
JSF Expression Language
- Comparison to JSP EL
- Basic syntax
- Array, Map and List access in JSF EL
- JSF EL Operators
- JSF EL Implicit Objects
Backing Beans
- The uses of backing beans
- Declaring managed beans and properties via annotations
  - Managed beans and properties in faces-config.xml
- Lists and Maps properties in Managed Beans
- Using the FacesContext
- Action methods in backing beans
- Connecting to back-end services
  - business logic
  - persistence

Conversion and Validation

Conversion and Validation in the JSF Lifecycle
Implicit and explicit conversion
Date/Time conversion
Number conversion
Standard input validators
Implementing validation in backing beans
Displaying conversion/validation error messages
Custom converters and validators
Client-side validation

JSF Events

The phases of JSF
- Restore View
- Apply Request Values
- Process Validations
- Update Model Values
- Invoke Application
- Render Response
GET vs. POST
- creating the view tree
- rendering the existing view tree
Page actions (JSF 2.0)
Action Events
- Action methods and Action Listeners
- Methods of ActionEvent and UIComponent
Value Change Events
- Methods of ValueChangeEvent
Phase Events
- Registering a Phase Listener
- Specifying which requests are handled by the Phase Listener
Data Model Events

GUI Components 2

Selecting items from lists
Checkboxes and radio buttons
Command Buttons and Command links
Panel Group and Panel Grid
Data Tables
- display-only data tables
- "interactive" data tables
Using the component in a JSP

Page composition using Facelets

Templating
- creating a Facelets template
- creating a Facelets client page
- creating a Facelets content page
Passing parameters to pages
Facelets and JSTL
Facelets composition components
- defining a composition component
- using a composition component
- tips and tricks
Using other tag libraries
- taglibs supporting Facelets

We are providing Java Online Training in Ameerpet Hyderabad. We are one of best Institute to provide Best High Quality Java online training all over India. The IT Professionals and Students from India and abroad who are unable to attend regular classes can attend our Java online training from their home in their convenient timings. For more details on Java Online Training please call to 9290971883, / 9247461324, or drop a mail to revanthonlinetraining@gmail.com

Java online training institute address : B1, 3rd Floor, Eureka Court, Near Image Hospital, Ameerpet, Hyderabad, India

Online Training Enquiry Form

Name :

Mobile :

Email :

Location :

Country :

Course Interested :

Security Code :

Please enter: *