Spring syllabus

Introduction of Spring Framework

* Why Spring Framework?
* Advantages of Spring Framework?
* Modules of Spring Framework
Spring Core Module
* What is Spring IOC?
* IOC Container
* Configuring metadata
* Types of Spring IOC
* Dependency Lookup
* Dependency Injection
* Types of Dependency Injection
* Setter Injection (SI)
* Constructor Injection (CI)
* SI with Primitives
* SI with Objectives
* Inner Beans
* <ref> element
* SI with Collections
* Set
* List
* Map
* Properties
* Constructor Injection
* Index attribute
* Type attribute
* Problems of Constructor Injection
* Bean Autowiring
* Bean Scopes
* Dependency check and Depends on attributes
* InstantiationBean and DisposableBean
* Bean Instantiation
* Using new operator
* Using static factory method
* Using Instance factory method
* Bean Lifecycle
* Annotations
Spring Aspect Oriented Programming (AOP)
* Why Spring AOP?
* Advantages of Spring AOP?
* Terminologies of Spring AOP
* Weaving
* Advices API
* MethodBeforeAdvice
* AfterReturningAdvice
* ThrowsAdvice
* AroundAdvice

* Pointcut
* Static Pointcut
* Dynamic Pointcut
* Static Pointcut
* NameMatchMethodPointcut
* JdkRegexpNameMatchMethodPointcut
* PointcutAdvisor
* NameMatchMethodPointcutAdvisor
* JdkRegexpNameMatchMethodPointcutAdvisor
* DefaultPointcutAdvisor
* Annotations based Spring AOP
Spring JDBC
* Introduction of Spring Jdbc
* Advantages of Spring Jdbc
* DataSource
* Centeralized Classes of Spring Jdbc
* JDBCTemplate
* NamedparameterJdbcTemplate
* StoredProcedure
* SimpleJdbcTemplate
* JDBC Template
* Constructors/Configurations
* API Methods
* NamedParameterJdbcTemplate
* Constructors/Configurations
* API Methods
* SqlParameterSource
* Map
* StoredProcedure
* Invoking Procedure from DB
* Invoking Function from DB
* Callback Interfaces
* RowMapper
* ResultSetExtractor
* PreparedStatementSetter
* Spring Jdbc BatchUpdates
Spring ORM
* Integrating Spring with Hibernate
Spring MVC
* MVC Designpattern
* FrontControllerDesignPattern
* Spring 3.X Features
* Spring MVC Architecture
* DispatcherServlet
* HanderMappings
* ControllersSpring MVC Internationalization
* Controller
* AbstractCommandController

*
*
*
*
*
*
*

SimpleFormController
MultiActionController
AbstractWizardFormController
ValidationFramework
HandlerInterceptors
Spring MVC TilesFramework
Spring MVC Themes

Hibernate Training Course Overview

Advantages of Hibernate compared to JDBC
Introduction
ORM (Object Relational Mapping)
Hibernate Resources
* Configuration file
* Mapping file
* Persistent class or POJO
* Client application.
Hibernate Architecture
Installation and Directory Structure
Hibernate Data Types
First Application using Hibernate
Hibernate API
* Configuration
* SessionFactory
* Session
* Transaction
Object Lifecycle in Hibernate
Object Lifecycle in Hibernate
* Persistent object
* Detached object
CRUD operations using Session methods.
* save, persist, SaveOrUpdate
* update, merge, delete
* load, get
* flush, evict, clear etc
Versioning
Primary key Generators
* Assigned
* Increment
* Sequence
* Hilo
* Seqhilo
* Identity
* Foreign
* Native
* UUID
* Custom generator
Hibernate Query Language (HQL)
Joins in Hibernate
Batch processing and Native SQL
Criteria API
Criteria with projections
Inheritance Mapping

* Table per class

* Table per sub class
* Table per concrete class
Component Mapping
Custom Mapping
Collection Mapping
* <list>
* <set>
* <map>
* <bag>
* Mapping array
* Sorting collections
Association Mapping
* one to one
* one to many
* many to one
* many to many
* Uni directional
* Bi directional
* Explanation on inverse and cascade attributes
Caching
* First level Cache(Session cache)
* Second level Cache(SessionFactory cache)
* Query level cache
Connection Pool
* Default connection pool
* Server supplied pool
* Third party vendor connection pool
Transactions and Concurrency
* Programmatic transactions with JTA
* Optimistic Concurrency control
* Pessimistic Concurrency control
Hibernate Pagination
Hibernate Filter
Hibernate Interceptor
Connecting with Multiple Databases(Oracle, HypersonicSQL)
Integrating Hibernate with Servlet
Integrating Hibernate with Struts
Working with Hibernate Annotations

STRUTS 1.x
Different types of Applications
Different Layers in Application
* Presentation Processing Layer
* Business Processing Layer
* Data Storage and Access Layer
Web Application Designing Models
* Model1-Architecture
* Model2-Architecture(MVC)
* Designing web application using MVC architecture
Struts Introduction
Struts Architecture
Struts Resources
* JSP
* ActionServlet
* web.xml
* ActionForm
* Action class
* Struts Configuration File
* Explanation about Struts-configuration File
* Detailed explanation of struts request processing flow
* Customizing RequestProcessor
Validations in Struts
Client Validations
Server side Validations
* By using validate() method programmatic approach
* By using Validator Framework declarative approach
* Combination of programmatic approach and declarative approach
Different types of ActionForms and Dynamic ActionForms
* ActionForm
* DynaActionForm
* ValidatorForm
* DynavalidatorForm
* ValidatorActionForm
* DynaValidatorActionForm
ExceptionHandling in Struts
* Programmatic Approach
* Declarative Approach
Local Forwards & Global Forwards
Local Exceptions & Global Exceptions
Struts predefined Tag libraries
* HTML Tag Library
* Bean Tag Library
* Logic Tag Library
* Nested Tag Library

* Tiles Tag Library

Predefined Action Classes
* ForwardAction
* IncludeAction
* DispatchAction
* LookupDispatchAction
* MappingDispatchAction
* SwitchAction
* LocaleAction
* DownloadAction
* EventDispatchAction
Internationalization(I18N) in Struts 1.x
Struts with Ajax Example
Preventing Double Submits
DataSource
File Uploading and Downloading in Struts
Tiles Framework
IDEs: Eclipse, Netbeans
STRUTS 2.x
Basic Components of Struts 2
* Struts 2 Features
Differences between Struts 1.x & 2.x
Steps to Create Struts 2 Application
Core Components in Struts 2
* FilterDispatcher
* Interceptors
* Value Stack
* Action Context
* Action Invocation
* OGNL(Object Graph Notation Language)
Struts 2 Work Flow
Struts 2 Action
Struts 2 Configuration
* Multi Configuration
* MultiNameSpace
Struts 2 Tag Library
Interceptors
* Params Interceptor
* Model Driven Interceptor
* Custom Interceptor
* Exception Handling
Struts 2 Validation
* Custom Validation
* Input Validation
Aware Interfaces

* Application Aware
* Session Aware
* Request and Response Awares
Internationalization(I18N) in Struts 2.x
Zero Configuration
* By Convention
* By Annotation
Files Uploading and Downloading
Securing struts application
Debugging and profiling
Progress Meters
Custom interceptors
Data store using struts 2
JFreechart plugins
Struts2 with Tiles2

Servlets 3.0
* Need of Server side Programming
* Introduction to Servlets
* Servlet Life Cycle
* javax.servlet package
* ServletConfig, ServletContext, ServletResponse
* Supplying initialization parameters to Servlets
* Performing database operations in Servlets
* Include and forward mechanisms
* Applying filters to Servlets
* javax.servlet.http Package
* HttpServlet Life Cycle
* Http request methods GET vs POST
* HttpServletRequest, HttpServletResponse
* Dealing with Http headers & error codes
* Session Tracking, purpose
* Hidden form fields, Cookies
* Http Session, URL rewriting
* Event listeners
* Web application security

JDBC 4.0
* Introduction to JDBC
* JDBC architecture
* java.sql Package
* Connection, Statement, ResultSet
* Prepared Statement
* Callable Statement
* Scrollable and Updatable ResultSet
* Batch Updates
* ResultSetMetaData
* Simple Transaction Management
* Four Levels of JDBC drivers, their pros & cons
* Features of JDBC 3.0

JSP 2.2
* Disadvantages of Servlets
* Introduction to JSP
* JSP Life Cycle
* Creating dynamic Web content with JSP
* Scripting elements
* Scriptlet
* Declaration
* Expression
* XML syntax for JSP elements
* JSP directives page, include and taglib
* JSP implicit objects
* JSP scopes
* Include and forward mechanism
* Using a Java bean in a jsp
* JSP Model 1 architecture
* JSP Model 2 (MVC) architecture
* Custom Tag Development
* Classic Tags, Simple Tags
* Error Handling in a jsp
* JSTL
* Expression Language
* Processing XML in a JSP

XML Web Services Training Course Overview

A. XML
B. Web Services
A. XML
* What is XML?
* What is markup? (Markup = Tagging)
* What are the similarities between HTML and XML?
* Is XML is Replacement for HTML?
* What are the differences between HTML and XML?
* What is the purpose of XML?
* What XML Does?
* Who invented xml tags?
* What is an XML document?
* What is xml application?
XML Syntax
* An example XML document:
* All XML elements must have a closing tag
* XML tags are case sensitive
* All XML elements must be properly nested
* All XML documents must have a root tag
* Attribute values must always be quoted
* Entity References
* Comments in XML
* White-space is Preserved in XML
What is a well-formed XML document?
What is an XML Element?
What are the XML Naming Rules?
What are the Best Naming Practices?
XML Attributes
* XML Attributes Must be Quoted
* Use of Elements vs. Attributes
* Avoid using attributes? (I say yes!)
* XML Attributes for Metadata
* XML Documents Form a Tree Structure
How to view XML files?
How to develop an XML document?
How to check the well-formedness of XML document?
How to validate XML document?
What is an XML parser? What are its functions?
What is DTD?
What are the constituents of DTD file? (Contains)
* Elements
* Attributes
* Entities
* PCDATA Parsed Character Data

* CDATA (Unparsed) Character Data

DTD Elements
* Declaring an Element
* Empty elements
* Elements with data
* Elements with children (sequences)
What is cardinality operator in DTD?
* Declaring only one occurrence of the same element
* Declaring minimum one occurrence of the same element
* Declaring zero or more occurrences of the same element
* Declaring zero or one occurrences of the same element
* Declaring mixed content
DTD Attributes
* Declaring Attributes
* Attribute declaration example
* Default attribute value
* Implied attribute
* Required attribute
* Fixed attribute value
* Enumerated attribute values
DTD Entities
* Entities as variables used to define shortcuts to common text.
* Entity references are references to entities.
* Entities can be declared internal.
* Entities can be declared external
How to associate a DTD with XML?
* Inside an XML document
* External reference.
What do you know about SYSTEM keyword in DOCTYPE declaration?
What are the limitations of DTD?
What is an XSD?
What XSD defines?
Compare and contrast DTDs and XSDs?
Data Types
* Simple Types
* Complex Types
How to give Default and Fixed Values to Simple Elements ?
How to Define an Attribute?
How to define fixed and default values to attributes?
How to specify an attribute as optional/ required?
XSD Restrictions/Facets
* Restrictions on Values
* Restrictions on a Set of Values
* Restrictions on a Series of Values
* Number of Digits

* Restrictions on Whitespace Characters

* Restrictions on Length
* Restrictions for Datatypes
Nonatomic Types
* Lists
* Unions
Complex Types
* Elements with attributes
* Elements with sub elements
* Elements with attributes and text
* Elements with sub elements and text
Empty Elements
Indicators
Order indicators:
* All
* Choice
* Sequence
Occurrence indicators:
* maxOccurs
* minOccurs
Group indicators:
* Group name
* attributeGroup name
Annotating XML Schemas
XML Namespaces
Refer a Schema in an XML Document
Import/include Schemas
B. Web services
Web services Introduction
Web services architecture
Web Services Development Parameters
* Specification
* API
* Implementation
* Approach
* MEP
* MEF
Communication in distribute technology
* Stub
* Skeleton
SOAP
WSDL
Soap UI
TCP IP Monitor
JAX-RPC, JAX-RPC-SI web service development

* Service development
* Contract first approach
* Contract last approach
* Client development
* Stub-based
* Dynamic-proxy based
* Dynamic-Invocation-Interface
* Development using command line tools
* Development using IDE support
JAX-RPC, Axis Web service development
* Service Development
* Contract first approach
* Contract last approach
* Client Development
* Development using command line tools
* Development using IDE support
JAX-RPC Handlers
* Applying Handlers to Service
* Applying Handlers to Client
* Tracking Input, Output SOAP message
JAX-WS
* Introduction
* Differences between JAX-RPC and JAX-WS
* Architecture
JAX-WS, Metro Web service development
* Service development
* Contract first approach
* Contract last approach
* Client development
* Stub based client
* Dynamic proxy based client
* Annotation based client
* Development using command line tools
* Development using IDE tools
* Handlers
* Attach handlers at client side handler
* Attach handlers at server side handler
* Track soap message using handlers
* Adding soap headers
* Adding http headers
* Developing secured web services
* Web service development using stand alone server
JAX-WS, Axis2 Web service development
* Service development
* Client development

JAX-RS
* Introduction
* Differences among JAX-RPC, JAX-WS and JAX-RS
JAX-RS, Jersey Web service development
* Service development
* HTML
* XML
* JSON
* Plain text
* Images
* Downloads
* Uploads
* Client development
* Http client
* GET
* POST
* Jersey Client
* GET
* POST
* Handlers for restful services
* Exception Handlers in restful services
JAX-RS, REST Easy Web service development
* Service development
* Client development

Core java
Volume -1: Java
1. Introduction
2. Java Tokens3. Working with

Language, OOPS, Programming

to Java and OOPS
Comments, Identifiers, Keywords, Separators
Java Editor Softwares Editplus, NetBeans, Eclipse

5. Working with jar

6. Modifiers File level, Access level and Non-access level
7. Datatypes, Literals, Variables, Type Conversion, Casting & Promotion
8. Reading runtime values from keyboard and Properties File
9. Operators and Control Statements
10. Method and Types of methods
11. Variable and Types of Variables
12. Constructor and Types of constructors
13. Block and Types of Blocks
14. Declarations, Invocations and Executions
15. Compiler & JVM Architecture with Reflection API
16. Static Members and their execution control flow
17. Non-Static Members and their execution control flow
18. Final Variables and their rules
19. Classes and Types of classes
20. OOPS- Fundamentals, Models, Relations and Principles
21. Coupling and Cohesion (MVC and LCRP Architectures)
22. Types of objects & Garbage Collection
23. Arrays and Var-arg types
24. Enum and Annotation
25. Design Patterns
Volume -2: Java API and Project
1. API & API Documentation
2. Fundamental Classes Object, Class, System, Runtime
3. String Handling
4. Exception Handling and Assertions
5. Multithreading with JVM Architecture
6. IO Streams (File IO)
7. Networking (Socket Programming)
8. Wrapper Classes with Auto boxing & unboxing
9. Collections with Generics
10. Java 5, 6, 7, 8 new features
11. Inner classes
12. AWT, Swings, Applet
13. Regular Expressions
14. Formatting date, time (java.text package)

Advanced Java Training Outline

Generics
Using Generics
Type Erasure
Type Boundaries
Wildcards

Generic Methods
Strengths and Weaknesses of Generics
Legacy Code and Generics
Threads
Java Thread Model
Creating and Running Threads
Manipulating Thread State
Thread Synchronization
Volatile Fields vs. Synchronized Methods
wait and notify
join and sleep
The Concurrency API
Atomic Operations
Thread Pools
Reflection
Uses for Meta-Data
The Reflection API
The Class<T> Class
The java.lang.reflect Package
Reading Type Information
Navigating Inheritance Trees
Dynamic Instantiation
Dynamic Invocation
Reflecting on Generics
Annotations
Aspect-Oriented Programming and Java
The Annotations Model
Annotation Types and Annotations
Built-In Annotations
Annotations vs. Descriptors (XML)
Sockets
The OSI Reference Model
Network Protocols
The Socket Class
The ServerSocket Class
Connecting Through URL Objects
HTTP and Other TCP Servers
Datagram Clients and Servers
Non-Blocking Sockets
Multi-Threading in Servers
Review of Java Fundamentals
The Java Architecture
Forms for Java Software
Three Platforms
The Java Language
Numeric Types
Characters and Booleans
Enumerations

Object References
Strings and Arrays
Conditional Constructs
Looping Constructs
Varargs
Object-Oriented Software
Complex Systems
Abstraction
Classes and Objects
Responsibilities and Collaborators
UML
Relationships
Visibility
Classes and Objects
Java Classes
Constructors and Garbage Collection
Naming Conventions and JavaBeans
Relationships Between Classes
Using this
Visibility
Packages and Imports
Overloading Methods and Constructors
JARs
Inheritance and Polymorphism in Java
UML Specialization
Extending Classes
Using Derived Classes
Type Identification
Compile-Time and Run-Time Type
Polymorphism
Overriding Methods
The @Override Annotation
Superclass Reference
Using Classes Effectively
Class Loading
Static Members
Statics and Non-Statics
Static Initializers
Static Imports
Prohibiting Inheritance
Costs of Object Creation
Strings and StringBuffers
Controlling Object Creation
Understanding Enumerated Types
Stateful and Behavioral Enumerations
Interfaces and Abstract Classes
Separating Interface and Implementation
UML Interfaces and Realization

Defining Interfaces
Implementing and Extending Interfaces
Abstract Classes
Collections
Dynamic Collections vs. Arrays
UML Parameterized Type
Generics
Using Generics
The Collections API
The Collection<E> and List<E> Interfaces
The ArrayList<E> and LinkedList<E> Classes
Looping Over Collections: Iterable<E>
Collecting Primitive Values: Auto-Boxing
Using Wildcards with Generic Types
Iterators and the Iterator<E> Interface
Maps and the Map<K,V> Interface
Sorted Collections
The SortedSet<E> and SortedMap<K,V> Interfaces
The Collections Class Utility
Algorithms
Conversion Utilities
Exception Handling and Logging
Reporting and Trapping Errors
Exception Handling
Throwing Exceptions
Declaring Exceptions per Method
Catching Exceptions
The finally Block
Catch-and-Release
Chaining Exceptions
The J2SE Logging API
Severity Levels
Log Hierarchies
Inner Classes
Passing Behavior
Inner Classes in GUI Programming
Named Inner Classes
Outer Object Reference
Static Inner Classes
Anonymous Inner Classes
The Java Streams Model
Delegation-Based Stream Model
InputStream and OutputStream
Media-Based Streams
Filtering Streams
Readers and Writers
Working with Files
File Class

Modeling Files and Directories

File Streams
Random-Access Files
Advanced Stream Techniques
Buffering
Data Streams
Push-Back Parsing
Byte-Array Streams and String Readers and Writers
Java Serialization
The Challenge of Object Serialization
Serialization API
Serializable Interface
ObjectInputStream and ObjectOutputStream
The Serialization Engine
Transient Fields
readObject and writeObject
Externalizable Interface
Automated Unit Testing with JUnit
Automated Testing
JUnit and Related Tools
The @Test Annotation
The Assert Class Utility
Test Runners
Lifecycle Methods
Introduction
A First Look
A Simple Java Class
Javas Hello World Program
Java Basics
Language and Platform Features
Program Life Cycle
The Java SE Development Kit (JDK)
Working with the Development Environment
Class and Object Basics
The Object Model and Object-Oriented Programming
Classes, References, and Instantiation
Adding Data to a Class Definition
Adding Methods (Behavior)
More on Classes and Objects
Accessing data, the "this" variable
Encapsulation and Access Control, public and private Access
Constructors and Initialization
static Members of a Class
Scopes, Blocks, References to Objects
Flow of Control
Branching: if, if-else, switch
Iteration: while, do-while, for, break, continue

Strings and Arrays

String, StringBuffer, StringBuilder
Arrays, Primitive Arrays, Arrays of Reference Types
Varargs
Packages
Package Overview - Using Packages to Organize Code
import statements
Creating Packages, package Statement, Required Directory Structure
Finding Classes, Packages and Classpath
Composition and Inheritance
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
Class Object
Abstract Classes
Interfaces
Using Interfaces to Define Types
Interfaces and Abstract Classes
Default Methods and static Methods (Java 1.8 or later only)
Using Interfaces to Remove Implementation Dependencies
Exceptions
Exceptions and the Exception Hierarchy
try and catch
Handling Exceptions
Program Flow with Exceptions
Finally
Java Collections and Generics
The Collections Framework and its API
Collections and Java Generics
Collection, Set, List, Map, Iterator
Autoboxing
Collections of Object (non-generic)
Using ArrayList, HashSet, and HashMap
for-each Loop
Processing Items With an Iterator
More About Generics
Database Access with JDBC and JPA
JDBC Overview
Using DriverManager, Connection, Statement and ResultSet
JDBC Architecture and API
JPA Overview
JPA Architecture and Programming View
Entity Classes and Annotations
Mapping an Entity Class
EntityManagerFactory and EntityManager
Working with JPA (Find by primary key and inserts)
Additional Java Features

Assertions
Type-safe Enums
Annotations
Lambda Expressions and Method References (Java 1.8 or later only)
Additional Features
I/O Streams (Optional)
Readers and Writers
Filter Streams
Byte Streams
Formatted Output
New I/O (NIO) APIs

Oracle Training Course Overview

Introduction to DBMS:
* Approach to Data Management
* Introduction to prerequisites
* File and File system
* Disadvantages of file
* Review of Database Management Terminology
* Database Models
* Hierarchal Model
* Network Model
* Relational Model
Introduction to RDBMS
* Feature of RDBMS
* Advantages of RDBMS over FMS ad DBMS
* The 12 rules (E.F Codds Rules RDBMS)
* Need for Database Design
* Support of Normalization Process for Data Management
* Client server Technology
* Oracle Corporation Products
* Oracle Versions
* About SQL&SQL*PLUS
Sub Language Commands:
* Data Definition Language (DDL)
* Data Retrieval Language (DRL)
* Data Manipulation Language (DML)
* Transaction Control Language (TCL)
* Database Security and Privileges (DCL)
Introduction to SQL Database Object
* Oracle Pre Defined Data types
* DDL Commands
* Create, Alter (add, modify, rename, drop)Columns, Rename, truncate, drop
* DML-Insert, update, delete
* DQL-SELECT Statements using WHEREclause
* Comparison and Conditional Operators
* Arithmetic and Logical Operators
* Set Operators (UNION, UNION ALL, INTERSECT, MINUS)
* Special Operators IN (NOT IN), BETWEEN (NOT BETWEEN), LIKE (NOTLIKE), IS NULL (IS NOT
* Working with DML, DRL Commands
* Operators Support
Built in Functions
* Arithmetic Functions, Character Functions, Date Functions, Conversion Functions
* Aggregate Functions, OLAP Functions & General Functions
Grouping the Result of a Query
* Using Group by and Having Clause of DRL Statement
* Using Order by clause

Working with Integrity Constraints

* Importance of Data Integrity
* Support of Integrity Constraints for Relating Table in RDBMS
* NOT NULL constraint
* UNIQUE constraint
* PRIMARY KEY constraint
* FOREIGN KEY constraint
* CHECK constraint
* Working with different types of integrity Constraints
REF constraint
* Understanding ON DELETE clause in referential integrity constraint
* Working with composite constraint
* Applying DEFAULT option to columns
* Working with multiple constraints upon a column
* Adding constraints to a table
* Dropping of constraints
* Enabling / Disable constraints
* Querying for constraints information
Querying Multiple Tables (Joins)
* Equi Join/Inner Join/Simple Join
* Cartesian Join
* Non-Equi Join
* Outer Joins
* Self Join
Working with Sub Queries
* Understanding the practical approach to Sub Queries/Nested Select/Sub Select/Inner Sele
* What is the purpose of a Sub Query?
* Sub Query Principle and Usage
* Type of Sub Queries
* Single Row
* Multiple Row
* Multiple Column
* Applying Group Functions in Sub Queries
* The impact of Having Clause in Sub Queries
* IN, ANY/SOME, ALL Operators in Sub Queries
* PAIR WISE and NON PAIR WISE Comparison in Sub Queries
* Be Aware of NULLs
* Correlated Sub Queries
* Handling Data Retrieval with EXISTS and NOT EXISTS Operators
Working with DCL, TCL Commands
* Grant, Revoke
* Commit, Rollback, Savepoint
* SQL Editor Commands
* SQL Environment settings
Maintaining Database Objects

VIEWS in Oracle
* Understanding the Standards of VIEWS in Oracle
* Types of VIEWS
* Relational Views
* Object Views
* Prerequisites to work with views
* Practical approach of SIMPLE VIEWS and COMPLEX VIEWS
* Column definitions in VIEWS
* Using VIEWS for DML Operations
* In-Line View
* Forced Views
* Putting CHECK Constraint upon VIEWS
* Creation of READ ONLY VIEWS
* Understanding the IN LINE VIEWS
* About Materialized Views
* View Triggers
Working with Sequences
Working with Synonyms
Working with Index and Clusters
Creating Cluster Tables, Implementing Locks, working with roles
Pseudo Columns in Oracle
* Understanding Pseudo Columns in Oracle
* Types of Pseudo Columns in Oracle
* CURRVAL and NEXTVAL
* LEVEL
* ROWID
* ROWNUM
Data Partitions & Parallel Process
* Types of Partitions
* Range Partitions
* Hash Partitions
* List Partition
* Composite Partition
* Parallel Query Process
Locks
* Row level Locks
* Table Level Locks
* Shared Lock
* Exclusive Lock
* Dead Lock
SQL * Loader
* SQL * Loader Architecture
* Data file (Input Datafiles)
* Control file
* Bad file

* Discard file
* Log file
* .txt to base table
* .csv to base table
* From more than one file to single table
PL-SQL (Procedure Language SQL)
* Introduction to Programming Languages
* Introduction to PL/SQL
* The Advantages of PL/SQL
* PL/SQL Architecture
* PL/SQL Data types
* Variable and Constants
* Using Built_in Functions
* Conditional and Unconditional Statements
* Simple if, if else, nested if..else, if..else Ladder
* Selection Case, Simple Case, GOTO Label
and EXIT
* Iterations in PL/SQL
* Simple LOOP,WHILE LOOP,FOR LOOP
and NESTED LOOPS
* SQL within PL/SQL
* Composite Data types (Complete)
* Cursor Management in PL/SQL
* Implicit Cursors
* Explicit Cursors
* Cursor Attributes
* Cursor with Parameters
* Cursors with LOOPs Nested Cursors
* Cursors with Sub Queries
* Ref. Cursors
* Record and PL/SQL Table Types
Advanced PL/SQL
* Procedures in PL/SQL
* STORED PROCEDURES
* PROCEDURE with Parameters (IN,OUT and IN OUT)
* POSITIONAL Notation and NAMED Notation
* Procedure with Cursors
* Dropping a Procedure
* Functions in PL/SQL
* Difference between Procedures and Functions
* User Defined Functions
* Nested Functions
* Using stored function in SQL statements
* Packages in PL/SQL
* Creating PACKAGE Specification and PACKAGE Body
* Private and Public Objects in PACKAGE
EXCEPTIONS in PL/SQL

* Types of exceptions
* User Defined Exceptions
* Pre Defined Exceptions
* RAISE_APPLICATION_ERROR
* PRAGMA_AUTONOMOUS_TRANSACTION
* SQL Error Code Values
Database Triggers in PL/SQL
* Types of Triggers
* Row Level Triggers
* Statement Level Triggers
* DDL Triggers
* Trigger Auditing
File Input/Output
* PL/SQL file I/O (Input/Output)
* Using UTL_FILE Package
Implementing Object Technology
* What is Object Technology ?
* OOPS-Object Instances
* Creation of objects
* Creating User Defined Data Types
* Creating Object Tables
* Inserting rows in a table using Objects
* Retrieving data from Object based Tables
* Calling a Method
* Indexing Abstact Data type Attributes
Using LOBS
* Large Objects (LOBS)
* Creating Tables-LOB
* Working with LOB values
* Inserting, Updating & Deleting Values in LOBs
* Populating Lobis DBMS_LOB Routines
* Using B-FILE
Using Collections
* Advantages of collection
* Ref cursor (Dynamic Cursor)
* Weak ref cursor
* Strong ref cursor
* Nested Tables VARRAYS or VARYING arrays
* Creating tables using nested tables
* Inserting, updating & deleting Nested
* Table records
* Nested table in PL/SQL
Oracle Database Architecture
* Introduction to Oracle Database Architecture
* Physical structures Logical structures

* DB Memory Structures Background Process

* 2 Tire, 3 Tire, N-Tier Architecture
Advanced Features
* 9i Joines
* New Date function
* Rename column
* Inner Join/Natural Join
* Left Outer Join/Right Outer Join
* Full Outer Join
* Multiple Inserts
* Insert All Command
* Merge statement
* NVL2(), NULLIF(), COALESCE()
* CASE expression of Select Command
* Temporary Tables/Global Tables
* New Function EXTRACT()
* Autonomous Traction
* Pragma _ Autonomous_ Transaction()
* Bulk Collect
* About Flash Back Queries
* Dynamic SQL
* New data types, Flash back Command
* Purge Command, Recyclebin
* Regular expressions, DML Error Logging
* Data Pump, Virtual Columns
* Read only tables, Cross tab Views using
* Pivot/Unpivot operators, Follows Clause
* Compound triggers, New data types
DBA CONCEPTS
* Database
* Tablespace
* Types of Tablespaces
* Data files /Se

Introduction to Collections
* What is Collection?
* What Is a Collections Framework?
* Benefits of the Java Collections Framework
* Difference between arrays and collections
* Types of Collections
List
* What is List?
* Advantages of List
* Disadvantages of List
* Applications
* List Methods
* Types Of ListDifference between ArrayList and Vector
* ArrayList
* Vector
* Stack
* LinkedList
* Concurrent Lists
* CopyOnWriteArrayList
* Difference between ArrayList and LinkedList
* Difference between ArrayList and CopyOnWriteArrayList
Examples on above lists
Reading Elements from collections
* Using getter methods
* Enhanced for loop
* CursorsDifference between Iterator and ListIterator
* Iterator
* ListIterator
* Enumeration
* Difference between Iterator and Enueration
* What is failfast iterator and failsafe iterator
Working with Comparable and Comparator
Set
* What is Set?
* Advantages of Set
* Applications of Set
* Set methods
* Types of Sets
* HashSet
* LinkedHashSet
* SortedSet
* NavigableSet
* TreeSet
* Concurrent sets

* CopyOnWriteArraySet
* ConcurrentSkipListSet
Examples on each type of set
Queue
* What is Queue?
* Advantages of Queue
* Application of Queue
* Methods of Queue
* Types of QueueConcurrent Queues
* PriorityQueue
* LinkedBlockingQueue
* ArrayBlockingQueue
* PriorityBlockingQueue
* DelayQueue
* SynchronousQueue
* LinkedBlockingDeque
* LinkedTransferQueue
Examples on each type of Queue
Map
* What is Map?
* Advantages of Map
* Map methods
* Types of Maps
* HashMap
* LinkedHashMap
* SortedMap
* NavigableMap
* TreeMap
* IdentityHashMap
* WeakHashMap
* Hashtable
* Properties
Concurrent Maps
* ConcurrentHashMap
* ConcurrentSkipListMap

Java Concurrency
Java Concurrency / Multithreading Tutorial
Multithreading Benefits
Multithreading Costs
Creating and Starting Java Threads
Race Conditions and Critical Sections
Thread Safety and Shared Resources
Thread Safety and Immutability
Java Memory Model
Java Synchronized Blocks
Java's Volatile Keyword
Java ThreadLocal
Thread Signaling
Deadlock
Deadlock Prevention
Starvation and Fairness
Nested Monitor Lockout
Slipped Conditions
Locks in Java
Read / Write Locks in Java
Reentrance Lockout
Semaphores
Blocking Queues
Thread Pools
Compare and Swap
Anatomy of a Synchronizer

ANGULAR JS
INTRODUCTION
Expressions
AngularJS Expressions
AngularJS Numbers
AngularJS Strings
AngularJS Objects
AngularJS Arrays

Directives
Directives
ong-app
ong-init
ong-model
ong-repeat
ong-Class
ong-Template
ong-Include
Data Binding

Controllers
Properties
Methods
In External Files

Filters
Adding Filters to Expressions
The currency Filter
Adding Filters to Directives
Filtering Input

HTML DOM
ng-disabled
ng-show
ng-hide

Events
ng-click
Hiding HTML Elements

Modules
Controllers Pollute the Global Namespace
AngularJS Application Files

AngularJS XMLHttpRequest
AngularJS $http

AngularJS Tables
AngularJS Forms
AngularJS Input Validation
Single Page Applications

Multiple Controllers, Multiple Views

Routing and Controllers

AngularJS Service Types

Constants And Values
Factories
Services
Providers
Dependency Injection

jQuery Training Course Overview

Introduction
WhatYouShouldAlreadyKnow
WhatisjQuery?
AddingthejQueryLibrarytoYourPages
BasicjQueryExample
DownloadingjQuery
AlternativestoDownloading
jQuerySyntax
TheDocumentReadyFunction
HowtouseCustomScripts?
UsingMultipleLibraries
jQuerynoConflict()Method
jQuery Basics

String:
Numbers:
Boolean:
Objects:
Arrays:
Functions:
Arguments:
Scope:
Built-inFunctions:
jQuery Selectors
How to use Selectors?

jQueryCSSElementSelector
jQueryCSSElementIDSelector
jQueryCSSElementClassSelector
jQueryCSSUniversalSelector
jQueryCSSMultipleElementsE,F,GSelector
jQueryCallbackFunctions
jQuery DOM Attributes

GetAttributeValue:
SetAttributeValue:
jQuery DOM Traversing

FindElementsbyindex:
FilteringoutElements:
LocatingDescendentElements:
JQueryDOMTraversingMethods:
jQuery CSS Methods

ApplyCSSProperties:
ApplyMultipleCSSProperties:
SettingElementWidth&Height:
JQueryCSSMethods:
jQuery DOM Manipulation Methods

ContentManipulation:
DOMElementReplacement:
RemovingDOMElements:
InsertingDOMelements:
DOMManipulationMethods:
jQuery Events Handling

Bindingeventhandlers:
Removingeventhandlers:
EventTypes:
TheEventObject:
TheEventAttributes:
jQuery Effects

JQueryEffectMethods:
jQueryHideandShow
jQueryToggle
jQuerySlideslideDown,slideUp,slideToggle
jQueryFadefadeIn,fadeOut,fadeTo
jQueryCustomAnimations
jQuery AJAX

load()
get()
post()
ajax()
jQuery JSON

getJSON()

Oracle Training Course Overview

Introduction to DBMS:

ApproachtoDataManagement
Introductiontoprerequisites
FileandFilesystem
Disadvantagesoffile
ReviewofDatabaseManagementTerminology
DatabaseModels

HierarchalModel
NetworkModel
RelationalModel
Introduction to RDBMS

FeatureofRDBMS
AdvantagesofRDBMSoverFMSadDBMS
The12rules(E.FCoddsRulesRDBMS)
NeedforDatabaseDesign
SupportofNormalizationProcessforDataManagement
ClientserverTechnology
OracleCorporationProducts
OracleVersions
AboutSQL&SQL*PLUS
Sub Language Commands:

DataDefinitionLanguage(DDL)
DataRetrievalLanguage(DRL)
DataManipulationLanguage(DML)
TransactionControlLanguage(TCL)
DatabaseSecurityandPrivileges(DCL)
Introduction to SQL Database Object

OraclePreDefinedDatatypes
DDLCommands
Create,Alter(add,modify,rename,drop)Columns,Rename,truncate,drop
DML-Insert,update,delete
DQL-SELECTStatementsusingWHEREclause
ComparisonandConditionalOperators
ArithmeticandLogicalOperators
SetOperators(UNION,UNIONALL,INTERSECT,MINUS)
SpecialOperatorsIN(NOTIN),BETWEEN(NOTBETWEEN),LIKE(NOTLIKE),ISNULL(ISNOTNULL)
WorkingwithDML,DRLCommands
OperatorsSupport
Built in Functions

ArithmeticFunctions,CharacterFunctions,DateFunctions,ConversionFunctions
AggregateFunctions,OLAPFunctions&GeneralFunctions
Grouping the Result of a Query

UsingGroupbyandHavingClauseofDRLStatement
UsingOrderbyclause
Working with Integrity Constraints

ImportanceofDataIntegrity
SupportofIntegrityConstraintsforRelatingTableinRDBMS

NOTNULLconstraint
UNIQUEconstraint
PRIMARYKEYconstraint
FOREIGNKEYconstraint
CHECKconstraint
WorkingwithdifferenttypesofintegrityConstraints
REF constraint

UnderstandingONDELETEclauseinreferentialintegrityconstraint
Workingwithcompositeconstraint
ApplyingDEFAULToptiontocolumns
Workingwithmultipleconstraintsuponacolumn
Addingconstraintstoatable
Droppingofconstraints
Enabling/Disableconstraints
Queryingforconstraintsinformation
Querying Multiple Tables (Joins)

EquiJoin/InnerJoin/SimpleJoin
CartesianJoin
Non-EquiJoin
OuterJoins
SelfJoin
Working with Sub Queries

UnderstandingthepracticalapproachtoSubQueries/NestedSelect/SubSelect/InnerSelect/OuterSelect
WhatisthepurposeofaSubQuery?
SubQueryPrincipleandUsage
TypeofSubQueries
SingleRow
MultipleRow
MultipleColumn
ApplyingGroupFunctionsinSubQueries
TheimpactofHavingClauseinSubQueries

IN,ANY/SOME,ALLOperatorsinSubQueries
PAIRWISEandNONPAIRWISEComparisoninSubQueries
BeAwareofNULLs
CorrelatedSubQueries
HandlingDataRetrievalwithEXISTSandNOTEXISTSOperators
Working with DCL, TCL Commands

Grant,Revoke
Commit,Rollback,Savepoint
SQLEditorCommands
SQLEnvironmentsettings
Maintaining Database Objects
VIEWS in Oracle

UnderstandingtheStandardsofVIEWSinOracle
TypesofVIEWS
RelationalViews
ObjectViews
Prerequisitestoworkwithviews
PracticalapproachofSIMPLEVIEWSandCOMPLEXVIEWS
ColumndefinitionsinVIEWS
UsingVIEWSforDMLOperations
In-LineView
ForcedViews
PuttingCHECKConstraintuponVIEWS
CreationofREADONLYVIEWS
UnderstandingtheINLINEVIEWS
AboutMaterializedViews
ViewTriggers
Working with Sequences
Working with Synonyms
Working with Index and Clusters
Creating Cluster Tables, Implementing Locks, working with roles
Pseudo Columns in Oracle

UnderstandingPseudoColumnsinOracle
TypesofPseudoColumnsinOracle
CURRVALandNEXTVAL
LEVEL
ROWID
ROWNUM
Data Partitions & Parallel Process

TypesofPartitions
RangePartitions

HashPartitions
ListPartition
CompositePartition
ParallelQueryProcess
Locks

RowlevelLocks
TableLevelLocks
SharedLock
ExclusiveLock
DeadLock
SQL * Loader

SQL*LoaderArchitecture
Datafile(InputDatafiles)
Controlfile
Badfile
Discardfile
Logfile
.txttobasetable
.csvtobasetable
Frommorethanonefiletosingletable
PL-SQL (Procedure Language SQL)

IntroductiontoProgrammingLanguages
IntroductiontoPL/SQL
TheAdvantagesofPL/SQL
PL/SQLArchitecture
PL/SQLDatatypes
VariableandConstants
UsingBuilt_inFunctions
ConditionalandUnconditionalStatements
Simpleif,ifelse,nestedif..else,if..elseLadder
SelectionCase,SimpleCase,GOTOLabelandEXIT
IterationsinPL/SQL

SimpleLOOP,WHILELOOP,FORLOOPandNESTEDLOOPS
SQLwithinPL/SQL
CompositeDatatypes(Complete)
CursorManagementinPL/SQL
ImplicitCursors
ExplicitCursors
CursorAttributes
CursorwithParameters
CursorswithLOOPsNestedCursors
CursorswithSubQueries

Ref.Cursors
RecordandPL/SQLTableTypes
Advanced PL/SQL

Procedures in PL/SQL
STOREDPROCEDURES
PROCEDUREwithParameters(IN,OUTandINOUT)
POSITIONALNotationandNAMEDNotation
ProcedurewithCursors
DroppingaProcedure

Functions in PL/SQL
DifferencebetweenProceduresandFunctions
UserDefinedFunctions
NestedFunctions
UsingstoredfunctioninSQLstatements
Packages in PL/SQL
CreatingPACKAGESpecificationandPACKAGEBody
PrivateandPublicObjectsinPACKAGE
EXCEPTIONS in PL/SQL

Types of exceptions
UserDefinedExceptions
PreDefinedExceptions
RAISE_APPLICATION_ERROR
PRAGMA_AUTONOMOUS_TRANSACTION
SQLErrorCodeValues
Database Triggers in PL/SQL

TypesofTriggers
RowLevelTriggers
StatementLevelTriggers
DDLTriggers
TriggerAuditing
File Input/Output

PL/SQLfileI/O(Input/Output)
UsingUTL_FILEPackage
Implementing Object Technology

WhatisObjectTechnology?
OOPS-ObjectInstances
Creationofobjects
CreatingUserDefinedDataTypes
CreatingObjectTables
InsertingrowsinatableusingObjects

RetrievingdatafromObjectbasedTables
CallingaMethod
IndexingAbstactDatatypeAttributes
Using LOBS

LargeObjects(LOBS)
CreatingTables-LOB
WorkingwithLOBvalues
Inserting,Updating&DeletingValuesinLOBs
PopulatingLobisDBMS_LOBRoutines
UsingB-FILE
Using Collections

Advantagesofcollection
Refcursor(DynamicCursor)
Weakrefcursor
Strongrefcursor
NestedTablesVARRAYSorVARYINGarrays
Creatingtablesusingnestedtables
Inserting,updating&deletingNested
Tablerecords
NestedtableinPL/SQL
Oracle Database Architecture

IntroductiontoOracleDatabaseArchitecture
PhysicalstructuresLogicalstructures
DBMemoryStructuresBackgroundProcess
2Tire,3Tire,N-TierArchitecture
Advanced Features

9iJoines
NewDatefunction
Renamecolumn
InnerJoin/NaturalJoin
LeftOuterJoin/RightOuterJoin
FullOuterJoin
MultipleInserts
InsertAllCommand
Mergestatement
NVL2(),NULLIF(),COALESCE()
CASEexpressionofSelectCommand
TemporaryTables/GlobalTables
NewFunctionEXTRACT()
AutonomousTraction
Pragma_Autonomous_Transaction()

BulkCollect
AboutFlashBackQueries
DynamicSQL
Newdatatypes,FlashbackCommand
PurgeCommand,Recyclebin
Regularexpressions,DMLErrorLogging
DataPump,VirtualColumns
Readonlytables,CrosstabViewsusing
Pivot/Unpivotoperators,FollowsClause
Compoundtriggers,Newdatatypes
DBA CONCEPTS

Database
Tablespace
TypesofTablespaces
Datafiles/Se

JAVASCRIPT
Introduction to javascript
Syntax
Statements
Comments
Enabling in various browsers
Popup Boxes
Alert
Confirm
Prompt
Variables
Operators
Arithmetic
Assignment
Comparison
Logical
Conditional
Conditional Statements
if
if...else
if...else if...else
Switch
Loops
while
do...while
for
for...in Statement
Break
Continue
Functions
User-defined Functions
Function Syntax
Function with Arguments
Returning Values from Functions
Local and Global Variables
Built-in Functions
paraseInt and parseFloat
Events
Introduction
Mouse Events
Keyboard Events
Form Events
Document/Window Events

Cookies
Page redirection
Page Printing
Built-in Objects
Introduction
Number
Strings
Math
Arrays
Associative
Array Properties and Methods
Date
Boolean
Regexp
HTML DOM
Advanced javascript
Error handling
Form Validations
Basics of Form Validation
Validating Radio Buttons
Validating Checkboxes
Validating Select Menus
Validating Textareas
Debugging
Browsers