ADV-JAVA by Ramchandra New (Update1)

ADVANCED JAVA
Java Software Editions or Modules or Flavors:
Java software classified into three modules
A. JSE Module / J2SE Module.

B. JEE Module / J2EE Module.
C. JME Module / J2ME Module
JSE Module:
Java Standard Edition
Or
Java 2 Platform Standard Edition
It is basic module for JEE and JME.
The reason is if we want develop JEE and JME

module we required JSE module.
It is installable software.
To work with JSE first we need to install one

software that is JDK.
JDK: Java Standard Edition Development Kit.
By using this software we can only compile and execute

the JSE related programs and operations but we can’t
execute JEE and JME module applications.
The Last Version of JDK Version is JDK 11 / Java 11.
Mainly software versions are classified into two types.
A. Major Version.
B. Minor Version.
Major Version: If we want to add new features to existing software

then new software coming into market in the form of Major Version.
Minor Version: Once we add new features into existing software,
there may be a chance of bugs.
To resolve the bugs, we need to write bug resolve code for

Major Version, after adding bug resolve code we need to introduce
new software into the market in the form Minor Version.
With the help of JSE, we can develop the following applications.
A. Standalone Applications.
B. Gamming Applications.
C. Networking Applications.
D. Applet programs.
E. File Interaction applications.
F. Database interaction applications.
Standalone Applications:
Here Standalone Applications means, only one end user can be

interact with the resources at a time.
We need install separately in all systems.
We don’t required any data connection.[internet]
Types of Standalone Applications:
A. Character User Interface Applications / Console Interaction

Applications.
B. Graphical User Interface Applications / Desktop
Applications.
CUI Applications:
These types of applications are interacts with end user in the

form of character by character.
Ex: If we want to read Employee related information, we need

to provide some user friendly message like ENTER EMPLOYEE ID and
EMPLYEE NAME etc…
By using these messages only end user can interact with

applications.
These are not user friendly applications.
These applications not provide any look and feel to end users.
Some times may be face difficulty to interact with applications.
To avoiding these drawbacks java introduced one more type of

application those are GUI applications.
GUI Applications:
These are very user friendly applications.
Provide more Look and Feels.
These applications are provides more facilities to interact with

in easy manner.
Every person who doesn’t have any idea on applications also

can easily interact with applications.
These type of applications can develop by using some of JSE

libraries those are AWT, SWING and APPLET.
Networking applications or Socket Programming:
These applications are one type client and server applications.
Most of the peoples feel like client and server applications

means client and server applications are running under
different machine. That is totally wrong.
We can develop client and server applications within the single

applications also.
We can develop networking applications or socket application

by using JSE library that is java.net package.
Gaming Applications:
We can develop these applications by using AWT and SWING

library; these are interacts with only one end user.
Q) Why should we learn JAVA Software?
There are lots of reasons we have to learn java software.
A. Platform Independent:
Developing one application under one operating system
and compile in the same os and executing under different
operating systems.
Java provides response to all the end users within the

same time and quickly.
The reason is it supports multiple Operating Systems.
In windows, with the support of multiple processors
(Around 8 processors)
In Linux, with the support of multiple processors. (Around
64 microprocessors).
B. Open Source:
a. Java software is open source.
b. Java software documentation is open source
c. Java software supported servers are open source.
d. Java software supported frameworks are open source.
e. Java software supported IDE’s are open source.
C. Supports All Scale Applications.
Java software will supports small and middle and large
scale applications.
Ex: Banking applications, ATM applications, Amazon,
Flipkart applications etc.
D. Security:
Java Byte code will provide security. Once we tampering
the byte code that will be not executed.
E. Job Security:
The meaning of job security is java having long life in the
market.
Now a day’s java is the basic technology to develop and
learn other technologies like Android, Hadoop, spring,
Servlet, JSP, JDBC, Sales Force, Selenium and etc….
Java Standard Edition comes into the picture in 3 Parts.
A. Language:
It will provide basic infrastructure or information to

develop applications. Technically we can calls as raw
materials.
Languages are provides basic syntax and procedures.
Syntax means don’t use keyword as class name, every

statement is ended with semicolon etc…
Procedure means the way writing the program from top to
bottom
Like in every java program
1. Starts with documentation.

2. Package statements.
3. Import statements.
4. Interface.
5. Abstract class.
6. Concrete class.
7. Final class.
8. Enum.
9. Annotations.
10. Main method class.
Programming language are supported to develop software

technologies (JDBC, Servlet, JSP, frameworks (spring,
Hibernate, Struts), tools (Ant, Maven, CVN, GIT).
Ex: C, C++, Java, VC++, C# etc
Java provides basic information in the form of oops,

exception handling, applet, iostreams, multithreading,
reflection-api.
B. Technology:
Java is a technology, it will provide specifications.
Specification means set of rules and guide lines.
Rules we can develop with the support of interfaces and

guide lines we can develop with the support of classes.
Java provides different types of technologies like JDBC,

Servlet, JSP in the form of specifications.
By using these specifications we can develop software’s.
For example JDBC is technology, which is used to develop

JDBC drivers, these are software’s.
Servlet is a technology, which is used to develop
software’s like Servers.
Ex: Apache Tomcat, Glass Fish, Web Logic etc..
Technologies are not installable software’s. But

technology based software’s installable like JDBC drivers
and servers and so on.
Every technology coming into the market in the form api

and packages.
Package contains set of interface and class.
For Example JDBC interfaces are provides rules and

classes provides guide lines.
When ever, any third party vendor wants to develop

technology based software’s, those vendors must be
followed by the technology rules and guidelines.
Working with the technology means working with

technology based software’s.
Working with JDBC technology means working with JDBC

technology based software’s.
Technologies are mainly classified into two types.

1. Open technologies.
2. Proprietary technologies.
Open technologies are provides specifications to all third party

vendors to develop their own technology based software’s.
JDBC is one Open technology it provides specifications to all third

party vendors.
Different third party vendors develop different software’s means

different drivers like oracle driver, mysql driver, postgresql and so
on.
In the same manner Servlet is one open specification to all third
party vendors.
By using these specifications different third party vendors develop

different server software’s.
Like Apache Tomcat, Web Logic, Glass Fish etc…
If the rules and guide lines are open source then competition will be
increases, then we will get best software product.
Cost of software product will be cheap.
Once technology is open source day by day new features will be

added for providing best software.
Proprietary technologies are provides rule and guidelines for only

one vendor.
That vendor itself provides technology based software’s.
Like asp.net related to Micro Soft.
If vendor is same there is no competition.
The cost of the software will be more.
May be some we will get best product and sometimes not.
C. Platform:
Java has its own platform[environment/provides
sufficient memory locations] to execute the programs in
the form JVM.
JEE Module:
The full form is Java Enterprise Edition.

New Version is JEE7.
JEE module is not installable software.

It is specification.
Provides rule and guide lines to develop server software’s
like Apache Tomcat, GlassFish, Web Logic etc.
JEE module specification coming into the market in the

form of .jar files.
For example JDBC specification coming into the market in

the form of jar files like ojdbc6.jar or ojdbc14.jar files.
Servlet specification coming into the market in the form of

jar files like Servlet-api jar file.
By using JEE Module we can develop following

applications
Like
A. Web Applications.
B. Distributed Applications.
C. Enterprise Applications.
Both Web and Distributed Applications are part of the
Enterprise Applications only.
Web Applications:
It is one web program which will get the request from the end
user and provides appropriate response to end user (client).
We can simply say this is client-server application.
To make communication between clients to server we use one

protocol that is “http”.
The collection of web application we can calls as web site.
For example web site is “Naresh I Technoloiges” and web

application is “Course”.
In generally we can say web site is one restaurant and

individual menu items are web applications.
In this applications client is fixed client. (Browsers like Google

Chrome, Opera Mini, Safari, Mozilla Firefox and Internet
Explorer).
To make a communication between client to server either we

can use LAN or MAN or WAN.
This architecture we can also called as “Thin Client and Fact

Server”.
Thin Client:
No need of any extra software architecture. Ex: Browsers.
Thick Client/ Fat Client:
Required some extra software configurations.
Thick Server/ Fat Server:
We required some extra software’s configurations.
Like gmail.com and facebook.com etc.

Distributed Applications:
The application resource common for all end user commonly

throughout networks.
It is also one type client- server application.
To make communication between client and server we can use

different type protocols.
Ex:
FTP (File Transfer Protocol).
SMTP (Simple Mail Transfer Protocol).
TCP (Transmission Control Protocol).
Telnet (Teletype Network).
HTTP (Hyper Text Transfer Protocol).
HTTPs (Secure Hyper Text Transfer Protocol).
MTP (Media Transfer Protocol).
Initially client is not directly communicates with server applications.
First client must be gets the details about server application from
repository.
If any application wants to provides services to client, that
application details must be placed into repository.
Once getting the details from the repository, then client interact
with server for appropriate services.
Ex: ATM Machine, Banking Applications, Health Care, Insurance etc.
These applications we can also called Fat Client and Fat Server
Architecture.
Ex: If we want to withdraw the money from ATM machine.
First ATM Machine will communicate with appropriate server and

provide the response to end user.
ATM machine is one client here. ATM machine definitely we required

extra software equipment.
There are lot of difference between Web Applications and Distributed

Applications.
In Web Application Architecture:
Client is thin client
Client can able communicate with the server directly.
No need of any extra repository for communicates with server.

In Distributed Application Architecture:
Client is Thick Client
We required repository services.
Once get service details from repository and communicate with

server.
Server is always thick.
Enterprise Applications:
It is always deals with very large or complex, middle scale

projects.
It is the combination of web and distributed applications.
Diagram:
PayPal Holdings is an American company operating a worldwide

online payments system.
It has been supports online money transfers and serves as an
electronic.
It is alternative of traditional papers and methods like checks and

money orders.
It is the world largest internet payment companies.
It will provide more security.
It is communicate with different types of card and related

organization (Banks).
JME Module:
JME full form is Java Micro Edition.
If we want to develop JME related applications we need install

MDK software (Mobile Development Kit).
It is used to develop mobile related and electronic chip level

applications.
These applications related programs develop on top of regular

machine architecture and finally dumped into chip.
These applications performance is very higher but application

wise smaller.
By using JME module we can develop fully function oriented

application like refrigerator, washing machines, micro woven
and also develop mobile oriented applications like mobile
phonebook, phone call mechanism, music and video player,
mobile plugin, mobile games etc.
Now days no body using these applications. Peoples are

showing interest to develop above mobile related applications
through Android and IPhone.
Real Time Terminologies:
Software Vendor/Developing Organization:
The Organization, which is develops the software and released

into market either open or proprietary.
Ex: Data Base (Oracle), Operating System (Windows),

Programming Language (Java, .NET), Frameworks (spring,
hibernate).
Software Services Organization:
These Organization are used software’s which are given by the

vendors and develop software project or products.
Ex: Value Labs, TCS, Wipro etc.
Software Service Utilization Organization or Client Organization:
These are used the project or products for business services

developed by software service organization.
Ex: Citi Bank, Amax etc..
The main intension of client organization is providing services to end

user.
Types of Projects:
Project is a collection of applications, it will provide services to

end user with specific client.
Scratch Level Projects:
Each and every code of projects we need to develop.
Maintenance Projects:
After developing the projects, there may be chance of

bugs. To solve these bugs we need to write bug resolve
code to existing projects.
Based on client business requirements we need to add

some new features and enhancement to existing project.
The above type of projects comes under Maintenance
projects.
Migration Projects:
Based on new technologies and new features of software,

sometimes we need to migrate our application from one
version to another and one technology to other
technologies.
Application Programming Interface:
To develop any application under any technology, we required some

theoretical and programming knowledge.
These types of knowledge we can achieve through documentation

and API.
API is communication channel between end user and program.
Here interface terminology is nothing but it is one English

terminology. This word is no more related to java concept interface
topic.
If we want to develop application on any programming language we

required some predefine coding, those code are coming in the form
of API’s.
For example if we want to develop application on C language we

required some predefine code, these code are coming in the form of
header files.
Ex: <stdio.h> and <conio.h>
If we want to develop application on java language we required

some predefine code coming in the form of classes, interface, enum
and annotations.
All these coding concepts are coming in the form of API.
Ex:
If we want to develop general and common programs in java

we required java.lang API.
If we want to develop graphic oriented applications we
required java.awt or javax.swing or java.applet API.
If we want to develop database interaction application we

required java.sql and javax.sql API.
If we want to develop web and distributed application we

required javax.servlet API.
Types of API:
There are three types of applications.
Pre-Define API:
The API which coming along with technology, software and

frameworks we can called as pre-define API.
User-Define API:
The API which is develops by the programmer or developer

called as user-define API.
Third Party API:
The API, which is given by the third party vendors like
Ex: Apache tomcat, Glass Fish, Web Logic, Oracle corporations..
Environment Variables Setting:
Command prompt is comes with operating system, whereas java

development tools (binary files) and library files are comes with java
software.
So our command prompt is unable to recognize the development

tools.
Then programmer should provide the information about binary and

library files to command prompt, with the help of environment
variables.
OS by default uses environment variables to recognize software.

For java we have two types of path settings.
1) Temporary Settings.
2) Permanent Settings.
Temporary Settings:
Whatever the setting which we are done at one command prompt

these settings are applicable to that command prompt only not
applicable to other command prompt and also if we did close the
command prompt automatically all the settings are gone.
Syntax: set path=C:\Program Files\Java\jdk\bin;
With the help of above settings our command prompt recognizes the
binary files. (javac, java, javap command).
Syntax”: set classpath=.;C:\Users\lenovo\Desktop\ojdbc6.jar;
With the help of above settings our compiler and JVM can recognize
the predefine .class files.
Binary files used to compile and execute the program, where as

Library files are used develop the user define program.
Permanent Settings:
The settings which are applicable for entire system, these

settings are called permanent settings.
Steps to permanent settings:
Right click on my computer Properties Advanced System Settings
Advance Environment Variables under System variables.
Click on new button set the path.
Variable Name: path

Variable Value: C:\Program Files\Java\jdk1.6.0\bin;
Click on new button set the classpath.
Variable Name: classpath
Variable Value: .;C:\Users\lenovo\Desktop\ojdbc6.jar;
Java archive: (jar):
It is one compressed file in java standard edition.
It contains java standard edition classes.

It can reduce file size.
With the help jar we can execute the programs also.
Web archive: (war):
It is also one compressed file in advanced java.
It contains the following files.
.servlet related classes
.jsp file
.html files
.jpeg files
.xml files
.properties files
Enterprise archive: (ear):
It is also one compressed file in enterprise edition.
This file contains the following files.
.servlet related classes
.jsp
.html
.jpeg
.xml files
.properties files
Enterprise java beans classes.

Creating .jar file and add .class file:
public class A{
public static void main(String... args){
System.out.println("jar file");
javac A.java
We are getting A.class file
jar -cf one.jar A.class
Delete the A.class file
Set the one.jar file in the class path then execute the program
java A
output: jar file.
JVM ARCHITECTURE:
Virtual Machine:
VM is a software/Application which will provide environment or

memory areas for executing the programs.
JVM: JVM is a software/application which will provide environment
or five individual identical memory areas for executing the java
programs.
We have two types of JVM
1) Client JVM
2) Server JVM.
JVM is only provides abstraction.
JRE is provides implementation for that abstraction.
We have different JVM'S for different OS.
That means we have different JRE software for different Operating

Systems.
If we want to execute the java program, first we should interact

with the JVM.
With the help of "java" command we communicate with JVM. "java"

keyword is always followed by class name.
syntax: java Class_Name
Java is internally communicate the with JVM, then JVM will come
into the picture, first JVM will read class name and JVM control will
go to secondary memory, that class byte code will be loaded from
secondary memory to primary memory.
JVM internally uses ClassLoaderSubSystem to load the .class files

from secondary memory to primary memory.
In the ClassLoaderSubSystem, we have three separate phases.

Those are
1) Loading phase.
2) Linking phase.
3) Initialization phase.
Loading Phase:
In this phase the byte code (predefine and user define class) will be
loaded from secondary memory to primary with the help of bellow
classloaders.
In this phase we have three ClassLoaderSubSystems.
1. ApplicationClassLoaderSubSystem
2. ExtensiveClassLoaderSubSystem
3. BootstrapClassLoaderSubSystem.
ApplicationClassLoaderSubSystem:
It will loads user define class files from current directly and
environment variable path.
ExtensiveClassLoaderSubSystem:
It will loads predefine class files from jre\lib\ext folder.
BootstrapClassLoaderSubSystem:
It will load predefine class files from jre\lib\rt.jar file.

In the above three phases class is not available, then we will get one
error cannot find or load main class <class_name>.
If available that .class file will loaded from secondary memory to

primary memory and handover to linking phase.
Linking:
In this phase the loaded byte code will be checked by verifier.
In this phase we have three components.
1. Verifier
2. Preparer
3. Resolver.
Verifier will check whether the byte code is properly organized or

not, is there any virus and hacking code or not. If yes verifier will
give verifier error, if not that byte code will be handover to preparer.
Preparer will provide the default values to static variables in loading

phase.
Resolver: it will convert symbolic reference into original references.
After this phase code will be handover to initializer.
Initialization: all default values of static data will be replaced with

original or actual data.
Runtime Memory Areas:
JVM provides 5 runtime memory areas.
1) Method Area
2) Heap Area
3) Java Stack Area

4) PC Registers
5) Native Method Area
Method Area: In this area all class data is stored. that means all the
static data is available in the method area.
Heap Area: in this area all object data is stored. that means all the
non-static data is available in heap area.
All the objects are created in the heap area only.
Java Stack Area: Every thread have its own stack.
These stack will be interact with local data/method level data.

Java stack have different slots, those slots are called stack frames.
Java Stack Frame:
It will convert into three parts.
1) Local Variable Storage Area:
In this all local variables are stored.
2) Operand Stack:
in this phase all operations and calculations will be happens.
3) Frame Data:
If method contains any exceptions, those exceptions will be

thrown by frame data only.
PC Registers:
Every thread have its own PC Registers, these registers will

hold the next execution statements address.
Native method area:
If java wants communicate with c and c++ code, that code will
be available in Native method area.
If we interact with c and c++ code, we need libraries, those
will be given by Native Library, that library will be handover by
Native Method Interface to executable engine.
Execution Engine:
Internally JVM uses two translators to convert byte code to

executable code.
1. Interpreter
2. JIT Compiler
Interpreter is good at execute the single time execution statements.
JIT compiler is good at execute the looping statements.
But these two are unable to find out behavior of statements.
In this one special component come into picture that is "profiler"
First profiler will identify the weather statements are single time or
looping statements.
If single time execution statement then those statements handover

to interpreter otherwise handover to JIT compiler.
Java is a high performance language, the reason java internally uses

two translators to covert our byte code to executable. So java
applications are executed with in the less time. If the application
executed within the less time automatically the performance will
increasers.
In this executable engine we have some other special components.
Those are Garbage Collector and Security manager.
Reflection API:
If we want know source code information from ".class" file (byte

code) then we can go for Reflection API.
With reflection API we can read information from runtime loaded
class(.class).
Reflection API provides mirror information about variables,

methods, constructors, annotations, exception class information.
With the help of reflection API we can access both private and public
data.
This Reflection API is coming under java.lang.reflect package.
Important classes under java.lang.reflect packages are
1)Filed
2)Constructor
3)Method
4)Modifer
Filed: It is used to store the variable information. Variables may

public or private.
Method: It is used to store the methods information (public or

private)
Constructor: It is used to store the information about constructors.
Modifier: It is used to store information about access modifier and

modifier.
This class provides the modifier information in the form of int.
If want convert from int to string then Modifier class itself provides
some predefine method (toString()).
ABSTRACT 1024
FINAL 16
INTERFACE 512
NATIVE 256
PRIVATE 2
PROTECTED 4
PUBLIC 1
STATIC 8
STRICT 2048
SYNCHRONIZED 32
TRANSIENT 128
VOLATILE 64
java.lang.Class: This class having capability to hold bytecode

information.
Important method under java.lang.Class:
1)getDeclaredFields()
2)getFields()
3)getDeclaredMethods()
4)getMethods()
5)getDeclaredConstructors()
6)getConstructors()
forName():
It is an one static factory method, is used to loads the byte code of

any class.
forName() always needs bytecode not source code.
Syntax : Class cls = Class.forName("class_name");
This method has been throwing one compile time exception i.e
Java.lang.ClassNotFoundException.
forName() is throwing exception like ClassNotFoundException if we

are not passing exsisting “.class” file name(classname).
newInstance():
This is one instance factory methods, which is used to create object
with the help of class reference variable.
Object obj = cls.newInstance().
newInstance() has been throwing two compile time excepitons.
1) IllegalAccessException
2) InstantiationException
Jvm will throwing Instantiation Exception, if given “.class “file

(class) doesn’t contains zero argument constructor.
Private variables by defaultly having one background method like

setAccessible(false), so this method doesnot provide permission to
access the data outside of the class.
If we want to access private data outside of the class we need to

convert from setAccessible(false) to setAccessible(true), otherwise
we will IllegalAccessException
import java.io.FileNotFoundException;
import java.io.IOException;
public class A {
public int b=2000;
A(){ //getDeclatedConstructor or Constructor
System.out.println("A class construc");
A(int x){
System.out.println("A class paramconstruc");
private static int c =3000;
int m1()throws IOException,FileNotFoundException{

return 10;
public void m2(int x){
System.out.println("hi");
***********************************
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class B extends A{
public static void main(String[] args)
throws ClassNotFoundException,
InstantiationException, IllegalAccessException {
java.lang.Class cls = java.lang.Class.forName("A");

java.lang.Object obj = cls.newInstance();
Field f[]= cls.getDeclaredFields();
for(Field f1:f){
String modi = Modifier.toString(f1.getModifiers());
if(modi.contains("private")){
System.out.println(f1);
f1.setAccessible(true);
System.out.println(f1.get(obj));
Object type = f1.getType();

System.out.println(type);
System.out.println(f1);
System.out.println("*****************");
Constructor[] c = cls.getDeclaredConstructors();
for(Constructor c1:c){
System.out.println(c1);
Method[] m = cls.getDeclaredMethods();
for(Method a:m){
System.out.println(a);
System.out.println("*************");
Class[] e = a.getExceptionTypes();
for(Class e1:e){
System.out.println(e1);
}
Block:
Blocks are used to hold the logic.
Doesn’t have identity.
Automatically executing.
Method:
Methods are used to hold the logic.
Not executing automatically.
If we want execute, we need to call.
Methods are having identity.
Website architecture by using JDBC and SERVLETS and JSP:
To develop above architecture we required the following operations

like.
a. Reading and storing data form end user.

b. Doing validation and calculations using input and to
generate output.
c. Storing output or response permanently in data base.
To develop above operations we can use any type of language and

technologies.
The above three operations calling they as
a. Presentation Logic.
b. Business Logic.
c. Persistence logic.
Presentation Logic:
The logic, which is used to developing GUI for reading the data from
end user and providing response or output to end user, is called
Persistence logic.
To develop the presentation logic we have rendering technologies

like html, servlet, jsp, php etc.
Business Logic:
This is the main logic of the application. That logic contains

validation and calculations for storing and generates response to
end user.
We don’t have any technologies for developing business logics, the

reason is business type is different from one to other as well as
business logic is different from business to another.
Ex: Bank , Naresh I Technologies.
Persistence Logic:
The logic which is used to store the data permanently is called

persistence logic.
Ex: JDBC, JPA, PHP, ADO.NET, Servlet, JSP etc….
JDBC
Whenever the java application in running mode, we can access the
different type of data in different memory areas of JVM.
For example static data, non-static or instance data and objects and
local data are available in method area, heap area and java stack
area respectively.
Once the java program execution completed all the data which is
available in different memory location will be destroy.
So if we want to store the data permanently, then we should go for

persistence stores like File Management Systems (Flat-File
Database), Relational Data Base Management Systems.
In Java Standard Edition we have one library like java.io, by using

this library we can able to make a communication with files and
doing some operations like writing data into file and reading the
data from files.
File system data management (or flat-file databases) served as the

only method of file storage and retrieval before the advent of
database management systems (such as relational databases).
While retaining some use, flat-file databases suffer from poor
accessibility, data redundancy, lack of standard file access and the
inability to organize data.
But we have lot of drawbacks in this procedure. Those are listed

below.
A. Data Redundancy (or) Duplicate data:

The same type of data can be exists in different files.
B. Limited User Access:

Only one end user can access the data from file, the content
of the file is not sharable between all the end users at a time
or simultaneously.
C. Data Mapping and Access:
We are unable providing mapping between content
between one file information to other file information.
D. Data format and dependency:
Based on the structure of data, which is existed in the
files, we need to access it.
This concept we can understand through Buffered Reader
and String Tokenizer classes.
E. Security:
Every file is having some password protection.
If one file having multiple information I want to provide
the permissions on one particular info not on all info.
That type of flexibility not available in files.
F. Unable to store huge amount of data.
G. No Sequel Query Language support.
H. Merging one file to another file is difficult.
I. No constraints concept unique key, null key etc…
The drawbacks which we have related to file management system,

we can avoids through Relational Data Base Management System.
To communicate with different types of RDBMS we required one

specification.
That specification is given by the java in the form of JDBC.
Introduction to JDBC:
It is a Trademark.
We don’t have any official name like Java Data Base Connectivity.
Persistence Store:
The area or place which is used to store the data permanently is

called persistence store.
Persistence:
The procedure to store the data in persistence store permanently is

called Persistance.
Persistence Logic:
The logic which is used to store the data permanently is called

Persistence logic.
Persistence Data:
The Data which is stored permanently is called persistence data.
Persistence Operations:
The operations, which are going to do on persistence data which is

available in persistence store by using persistence logic through
persistence technologies are called persistence operations.
Persistence Technologies or specifications or frameworks:
The specifications, which are used to develop persistence logic for

doing persistence operations on persistence data which is available
in persistence store is called persistence specifications.
Ex: JDBC and Hibernate.
What is JDBC?
JDBC is specification API.
JDBC is a standard.
JDBC is a technology.
It is provides some set of rules and guidelines to communicate with

persistence area’s like relational database management system.
With the help of JDBC we can store and retrieving the data from
RDBMS.
Ex: oracle, mysql, db2, sqlserver etc….

JDBC provides some abstraction layer in the form of interface and
methods from java program to communicate with DataBase.
JDBC is not existed in java software programmer must be write the

different code for connecting different database connections.
Here code may be like this, communicate with jdbc methods to C-

language methods.
Note: Database software’s are developing on top of C-language.
What is JDBC and JDBC Driver Software?

JDBC driver is software it is used to convert java calls or syntax to
db calls or syntax to communicate with db for curd operations.
JDBC Driver is a JDBC specification implementing software, it

provides the logic for interface methods which are given by the JDBC
API.
In these methods JDBC drivers software vendors writing the logic

like calling database related functions to connect to db.
Role JDBC Driver software:
It is translator software, which is used to convert java calls to

DB calls and establish the connection between java program and
database.
Steps to connection with Data Base:
1. Installation of Java Software(JDK).

2. JDBC API.(java.sql and javax.sql).
3. Installation of Database server software.
4. Driver API. (Driver interface implementation class details,
nothing but Driver implementation software).
Ex: OracleDriver, MysqlDriver.
To develop java application for interacting with database
we required following things.
5. Data Base URL.

6. Data Base Username.
7. Data Base Password.
8. Driver Name.
Programmer no need to write connection logic to communicating

with Data Base, this logic is already provided by Driver
implementation classes.
Ex: oracle.jdbc.driver.OracleDriver
DB URL is used to make communication with specific database, this

URL contains Driver Name, Data Base name, IP Address of Data Base
installation system, port number, global service name.
Ex: jdbc:oracle:thin:@localhost:1521:XE
Data Base Username will provide data base username for provides
security.
Data Base Password will provide data base password for provides
security.
Prerequisites to develop JDBC Program:

To develop JDBC related programs we require two types of
software’s.
A. Java Standard Edition Development Kit (JDK).

B. Data Base software.
To develop JDBC related program, we require two types of API’s.
1. JDBC API.
2. Driver software API. (JDBC Technology Based Software).
JDBC API is used to call the methods and making a communications

and execute the queries.
Driver API is used to call actual logic. This logic is different from one
database to other.
By seeing the above diagram, we came to one following conclusion.
That is java programmer calling methods by using JDBC API in the

form of interface methods and calling actual logic from driver
software API.
Interface always provides commonality to all implementation

classes.
Calling interface methods by using interface reference variables and

executing actual logic form their implementation class is part of
object oriented programming principle, that runtime polymorphism.
If we follow the runtime polymorphism, we can able to communicate
with different databases by using single java program.
For example if we want to communicate with oracle, we need to give

oracle database related information, as well as mysql database
related information.
So one db to other, only database related input data will be changes

but not methods.
JDBC API is coming to our machine in the form of rt.jar file which is
located in our java software installation directory. That is
java\jre\lib\rt.jar file.
Driver software related API is coming to our machine in the form

of .jar or zip file.
Ojdbc jar file is available in our data base installation directory that
is
C:\oraclexe\app\oracle\product\10.2.0\server\jdbc\lib\ojdbc14.ja
r
ODBC:
Stands for Open Database connectivity.
It is used to interact with database.
It has been developed on top of “C” language specific methods.
If we want to communicate with ODBC we need to execute native

methods in our applications.
If we are using native methods implementation in our java

application we can lose java features, like platform independency.
If the bug or error are raises in the native methods, there may be
chance of destroy the JVM.
To overcome this problem Java community people introduce one
technology or specification in the form of JDBC.
Understanding JDBC API:
JDBC API is used for accessing the JDBC Driver software, which can
be drive (carry) our queries to data base and execute them in the
data base server and finally that outputs will be carry to end user or
java application, for this we need to establish the SESSION.
How can we develop the Session between Java Client to Database

software?
By using the JDBC Driver software, it is the implementation class of

java.sql.Driver interface.
After that we need to call the connect method.
Java.sql.Connection connect (String url, Properties props) throws

SQLException{}.
import java.sql.Connection;
import java.sql.Driver;
import java.util.Properties;
public class JDBCEx1 {
public static void main(String[] args) throws

Exception,ClassNotFoundException {
Driver d = new oracle.jdbc.driver.OracleDriver();

String url = "jdbc:oracle:thin:@localhost:1521:xe";
Properties p = new Properties();
p.setProperty("user", "system");
p.setProperty("password", "manage");
Connection con = d.connect(url, p);
System.out.println(con);
if(con !=null){
System.out.println("connection established");
}
else
System.out.println("not established");
}
In the above approach, we need to face one problem that is assume

we are developing one project with 10 classes. All the classes
require data base connection then, above statements we need to
write in all the classes, then automatically number of Driver objects
are increases in JVM heap memory, to avoiding this process JDBC
introduce one helper class that is java.sql.DriverManager.
This is one predefine class, which is used to register the multiple

drivers with help of one method that is registerDriver (driverobject d
).
More Information about Factory Methods:
import java.util.Scanner;
interface Animal{
void eat();
void sleep();
}
class AnimalFactory{
static Animal factoryAnimal(String animalName){
if(animalName.equalsIgnoreCase("lion")){
return new Lion();
}else if(animalName.equalsIgnoreCase("rabit")){
return new Rabit();
}return null;
}
}
class Lion implements Animal{
@Override
public void eat() {
System.out.println("eats non-veg");
}
@Override
public void sleep() {
System.out.println("sleeping in caves");
}
}
class Rabit implements Animal{
@Override
public void eat() {
System.out.println("eats veg");
}
@Override
System.out.println("sleeping in bushes");
}
}
class Tiger implements Animal{
@Override
public void eat() {
System.out.println("tiger eats non-veg");
}
@Override
System.out.println("tiger sleeping in caves");
}
}
public class FactoryMethod {
public static void main(String[] args) {
System.out.println("enter which animal object you
want");
Scanner scan = new Scanner(System.in);
String animalName = scan.next();
Animal obj = AnimalFactory.factoryAnimal(animalName);
//Animal obj = new Lion();
obj.eat();
obj.sleep();
}
}
In the above approach we are facing NullPointerException.
We can resolve above problem with factory method.
interface Animal{
void eat();
void sleep();
class AnimalFactory{
static Animal factoryAnimal(String animalName) throws

ClassNotFoundException,
InstantiationException, IllegalAccessException{
/*if(animalName.equalsIgnoreCase("lion")){
return new Lion();
}else if(animalName.equalsIgnoreCase("rabit")){
return new Rabit();
}return null;*/
Class cls = Class.forName(animalName);
Object obj = cls.newInstance();
return (Animal)obj;
class Lion implements Animal{
@Override
public void eat() {
System.out.println("eats non-veg");
@Override
System.out.println("sleeping in caves");
}
class Rabit implements Animal{
@Override
public void eat() {
System.out.println("eats veg");
@Override
System.out.println("sleeping in bushes");
class Tiger implements Animal{
@Override
public void eat() {
System.out.println("tiger eats non-veg");
@Override
System.out.println("tiger sleeping in caves");
Save with Test.java
And compile like javac Test.java

public class MethodDemo {

InstantiationException, IllegalAccessException {
System.out.println("enter which animal object you want");
String animalName = scan.next();
Animal obj =
AnimalFactory.factoryAnimal(animalName);
//Animal obj = new Lion();
obj.eat();
obj.sleep();
Save above file with FactoyMethod.java
Compile and execute.
Note: Before executing first we need to compile Test.java file

otherwise we will get ClassNotFoundException.
The Same factory method approach we can use for Driver software
loading process.
There are lots of ways to loading Driver Software.
forName() will load .class file from secondary memory to primary

memory.
newInstance() will create object for .class file (byte code).
forName() will throws one exception like

java.lang.ClassNotFoundExcepiton if the .class file is not existed.
newInstance() will throws two exceptions like

java.lang.IllegalAccessException, if there is no zero argument
constructor declared as private and throws
java.lang.InstantiationExcepitn if there is no zero argument
constructor.
We have lot of approaches to load Driver class.
import java.sql.DriverManager;
import java.sql.SQLException;
import oracle.jdbc.driver.OracleDriver;
public class Demo1 {

SQLException, ClassNotFoundException{
//step 1
DriverManager.registerDriver(new OracleDriver());
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@lenovo-
PC:1521:xe","system","manager");
if(con != null){
System.out.println("connection is
established");
System.out.println("connection object: "+con);
}
else
System.out.println("connection is not
established");
}
DriverManager.getConnection(-,-,-) will create object for
implementation class (T4CConection) of Connection and placed
object into Connection reference.
Simply DriverManager.getConnection(-,-,-) will create connection

object for communicating with db.
If we are not providing DriverName then we will get

java.sql.SQLException: No suitable driver found for
jdbc:oracle:thing:@localhost:1521:xe
We will find portnumber, global service-name and computer name in

the following location.
C:\oraclexe\app\oracle\product\10.2.0\server\NETWORK\ADMIN\
tnsnames file
ojdbc14.jar file we can find in the following location:
C:\oraclexe\app\oracle\product\10.2.0\server\jdbc\lib\ojdbc14.ja
r
The url may existed in the following manner.
1. “jdbc:oracle:thin:@localhost:1521:xe”
2. “jdbc:oracle:thin:@Ramchandar-PC:1521:xe”
3. “jdbc:oracle:thin:@ipaddress:1521:xe”
localhost current system
Lenovo-pcrepresents computer name
Ipaddresssystem identification number
Approach-2:
OracleDriver od = new OracleDriver();

Connection con =
if(con != null){
System.out.println("connection is established");
System.out.println("con: "+con);
}
else
System.out.println("connection is not established");
Approach:3:
import oracle.jdbc.driver.OracleDriver;
class Demo extends OracleDriver{
Connection connection() throws SQLException{
Connection con = DriverManager.getConnection(
"jdbc:oracle:thin:@lenovo-PC:1521:xe",
"system",
"manager");
return con;
}
}
public class JdbcDemoProgram2 {
public static void main(String[] args) throws SQLException{
Demo d = new Demo();
Connection con = d.connection();
if(con != null){
}
else
System.out.println("connection not established");
}
}
Approach:4:
Class.forName("oracle.jdbc.driver.OracleDriver");//fully
qualified name mandatory
Connection con =
if(con != null){
}
else
Approach:5:
Connection con =
if(con != null){
}
else
Appraoch:6:
p.put("user","system");
p.put("password", "manager");
Connection con =
PC:1521:xe", p);
if(con != null){
}
else
In the above program p.setProperty(-,-) key value must be
“user”, don’t write key like username or User.
Approach:7:
FileInputStream fis = new FileInputStream("db.properties");
p.load(fis);
String driver = p.getProperty("driver");
String url = p.getProperty("url");
String user= p.getProperty("username");
String password = p.getProperty("password");
Class.forName(driver);
Connection con = DriverManager.getConnection(url,user,password);
if(con != null){
}
else
In the above program if write the bellow code like

Connection con =
DriverManager.getConnection(url,p);
we get one exception that is java.sql.SQLException
invalid
agrument in call
the we want to write this getConnection(url,p) for connecting the

database
we must be set the username and password explicitly to
properties object (p) by using setProperty(-,-).
like bellow
p.setProperty("user", user);
p.setProperty("password", password);
Connection con =
DriverManager.getConnection(url,p);
AutoLoading:
From JDBC 4.0 no need to specify any details related DriverName.

Automatically Driver is loading.Driver Class automatically loading
from bellow path
ojdbc6.jar\META-INF\services\java.sql.Driver file.
This feature only supported by the one jar file like ojdbc6.jar file.
From ojdbc6.jar file OracleDriver is available in tow loacations.
a. oracle.jdbc.driver.OracleDriver
b. oracle.jdbc.OracleDriver
public static void main(String[] args) throws SQLException,

ClassNotFoundException{
Connection con =
if(con != null){
System.out.println("connection: "+con);
else
}
ResourceBundle:
import java.util.ResourceBundle;
public class FirstJdbcDemo {
SQLException{
ResourceBundle rb =
ResourceBundle.getBundle("oracledb.properties");
String driver = rb.getString("drivername");
String url = rb.getString("urlname");
String user = rb.getString("username");
String password = rb.getString("password");
Connection con =
DriverManager.getConnection(url,user,password);
}
}
ResourceBundle always added “.properties” to our file

and it will always checks within the folder like src.
Don’t write enter file extension, we need to write
only filename.
Whenver we working with ResourceBundle better create
your .properties file within src folder.
Possible Exceptions in bellow program:
public class Demo1{

Class.forName("oracle.jdbc.driver.OracleDrivers");
Connection con =
if(con != null){
else
1. If given class name not existed or any spelling mistake while

type the program we will face one exception that is
Java.lang.ClassNotFoundException.
2. In above program, if we are giving any invalid global service

name we will face exception like
Exception in thread "main" java.sql.SQLException: Listener refused

the connection with the following error:
ORA-12505, TNS:listener does not currently know of SID given in

connect descriptor.The Connection descriptor used by the client was:
lenovo-PC:1521:oracl
3. In above program if we are doing mistake in port

number,localhost then we will face bellow exception
Exception in thread "main" java.sql.SQLException: Io exception: The

Network Adapter could not establish the connection
4. In above program if we are doing any mistake related

username and password we may be faced problem like bellow.
Java.sql.SQLException Inavalid username/password.
5. It the given table is not existed then we will face bellow

exception that is
Java.sql.SqlSyntaxErrorException Table or View does not exist.
6. If data is not displayed on the console may related data is not

available and records are inserted or after inserting the records
may be records are not commit.
7. With out calling rs.next() if we are trying to read the data from
the ResultSet object then jvm will give exception like ‘
8. After crossing/navigating all records of a table, if we are trying
read values from table by using RestSet reference variable we
will get java.sql.SQLException: Exhausted Resultset.
Explanation about First Program:
Class.forName(-) Method loads the OracleDriver class bytecode into

JVM from ojdbc6.jar.
After that JVM executes static block from OracleDriver class. In this
static block OracleDriver object is created later forward
DriverManager class to register.
DriverManager establish the connection using this OracleDriver.
DriverManager class having one collection object to store or register

different driver objects.
forName() is not register our driver object to DriverManager class.
OracleDriver class itself creates object and register with

DriverManager object by calling registerDriver().
We can able to register to OracleDriver object to DriverManager, but

no need already this will be done by the automatically.
Connection con = DriverManager.getConnection() ;

In the getConnection(), there is one more logic that is
driver.connect() method is called for establish connection to the
data base.
DriverManager is not create the connection it is just find out the url
of given driver and handover these details to driver class. Driver
classes itself create object and handover to DriverManager.
DriverManager will find out the suitable driver from registers drivers
by using driver.acceptURL().
In the getConnection(), the DriverManager will fetch the drivers

from collection object by calling acceptURL() by passing current url,
if DriverManager get return value is true then it call connect()
method.
Both acceptURL() and connect() are available in Driver

implementation class like OracleDriver.
DriverManager returns Connection interface implementation class

object.
Statement stmt = con.createStatement();
Connection implementation class creates object for Statement

interface implementation class object on loaded driver and finally
handover to stmt variable.
Statement implementation class object created by the connection
object because, to send and execute in the db, we need Connection
object ID.
This connection id will copied from connection object to statement

object meanwhile creating statement object.
Whenever sending the query to db, first statement object append

that connection id to query.
Whenever query is handover to db, then db will reads the connection

id and then finds its appropriate buffer and later execute the query
and stores or gets result from main table according to that query.
If connection id related buffer not found or available, then simply

database throw an exception that is connection closed.
If we are calling stmt.executeQuery() after connection closing

(con.close()) , then we will face one exception like below.
That is java.sql.SQLException: Closed Connection.
ResultSet rs = st.executeQuery(-);
With the help of above line the given query is send and executed at
db side by using appropriate buffer.
The results are stored in at database end in appropriate connection

id buffer, and it reference id is given back to java app in the form
ResultSet implementation class object and that will be stored in rs
variable.
ResultSet is a cursor, it wills always pointing to non-record are that

is before first record stored location.
If we want read the data from db we need to use rs.next() first, this
will help us to move the cursor from non-record area to record area.
If the record is available that record will given back to java side and
we should read that data by using rs.get() by passing index position
or column name.
Once all records reading finally rs.next() will return false, then our
reading operation will be closed.
Q) How many ways can we read data from ResultSet object?
A) There are two ways to read the data from ResultSet object.
a. by using column index based on query(response order).
b. by using column name based on table column names and

ResultSet object data.
example on first way:
import java.sql.ResultSet;
import java.sql.Statement;
public class JDBCDemo1 {
throws SQLException,ClassNotFoundException{
"jdbc:oracle:thin:@localhost:1521:xe",
"system","annie");
Statement st = con.createStatement();
System.out.println("st: "+st);
ResultSet rs =
st.executeQuery("select * from sbaj9to11");
System.out.println("rs: "+rs);
System.out.println("SID\tSNAME\tSAGE\tSFEE");
while(rs.next()) {
System.out.println(rs.getInt(1)+"\t"+rs.getString(2)
+"\t"+rs.getInt(3)+"\t"+rs.getInt(4));
/*System.out.println(rs.getString(1)+"\t"+rs.getInt
(2)+"\t"
+"\t"+rs.getInt(3)+"\t"+rs.getInt(4));*///invalid
Program2: on first ways:
"system","annie");
ResultSet rs =
st.executeQuery("select sfee,sage,sname from

sbaj9to11");
System.out.println("SFEE\tSAGE\tSNAME");
while(rs.next()) {
System.out.println(rs.getInt(1)+"\t"+rs.getInt(2)+"\t"+rs.getStrin
g(3));
/*System.out.println(rs.getInt(1)+"\t"+rs.getString(2)
+"\t"+rs.getInt(3)+"\t"+rs.getInt(4));*///valid
/
*System.out.println(rs.getInt(1)+"\t"+rs.getInt(2)+"\t"+rs.getStri
ng(3)+"\t"+rs.getInt(4));*/ //invalid
/
*System.out.println(rs.getInt(1)+"\t"+rs.getInt(2)+"\t"+rs.getStri
ng(3)+"\t"+rs.getInt(1));*/ //valid
/*System.out.println(rs.getInt(1)+"\t"+rs.getInt(2)); */
//valid
/*System.out.println(rs.getInt(1)); */ //valid
Program on second way:
"system","annie");
ResultSet rs =
st.executeQuery("select sfee,sage,sname from

sbaj9to11");
System.out.println("SFEE\tSAGE\tSNAME");
while(rs.next()) {
/*System.out.println(rs.getInt("sfee")+"\t"
+rs.getInt("sage")+"\t"
+rs.getString("sname"));*/
+rs.getString("sname")+rs.getInt("sid"));*/
//invalid column name
+rs.getString("sname")+rs.getInt(4));*/
//invalid column index
API and API Documentation:
API means collection of classes and interfaces, these reusable

components.
These are used to develop new classes, we can also called

these new classes like user define classes.
Ex: String, Thread, Runnable, Connection, Driver etc…

API Documentation is theoretical information about API class and
interfaces.
Like how to use the class, member variables and methods, their
syntax….
Java developer can develop their own classes by reading

documentation and using API class and interfaces.
API classes and interfaces byte code are using by the compiler and
JVM.
Every java class can be developing by using three extensions.
1. .java (source code)

2. .class (byte code)
3. .html (theoretical information)
.html file we can develop by using one command that is “javadoc”,

which is available in java\jdk\bin folder.
Java provides API documentation for both JSE and JEE.
How develop first jdbc program in eclipse:

--> download and install eclipse ide
--> create java project for JSE programs.
1. File--->new-->others--->java project--->next-->GiveName
for Project-->select jre(java version)-->finish.
--> crate class in our project.
extract the project
right click on src folder
goto new-->click on other-->select class-->click on next
--->type class name-->click on finish.
Type program as bellow in that class file.
public class JdbcDemo1 {
throws ClassNotFoundException,SQLException{
Class.forName("oracle.jdbc.driver.OracleDriver");
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@locahost:1521:xe",
"system","annie");
System.out.println();
run the application: right click on our class --->goto run as -->click
on java application.
exception: java.lang.ClassNotFoundExcepiton
to over come the above problem we need add ojdbc6.jar file to
ecliipse.
How add jar files in eclipse for java project:
-->right click on project
-->click builid path
---> click congure build path
--->click on libraries
--->click on add external jars and browse our ojdbc6.jar files
--->and run the program again
ResultSetMetaData:
It is a JDBC object.
It is used retrieve the column information from given query.
Column information is changing from one query to another.
It will not give original table number of column information.
Select * from emp;
It will give all column information.
Select eno,ename from emp;
In the above RSMD will give only eno, ename column information.
Difference between ResultSet and ResultSetMetaData:
ResultSet is mainly design for reading the data from the row actual
data whereas RSMD will provide column information, which is quires
from RS.
ResultSet contains some methods to read and move the cursor from
one row to another row.
RSMD is also contains some methods column information like

column name, column type, precision and scale and number,check
nullable or not, lable name, column class type name.
If we want to work with RSMD method, first we need to retrieve the

RSMD object.
To obtain RSMD object, first we need obtain ResultSet object, in that

object we have one factory method like getMetaData().
public ResultSetMetaData getMetaData() throws SQLException{
Syntax in java program:
ResultSetMetaData rsmd = rs.getMetaData();
import java.sql.ResultSetMetaData;
Connection con =
if(con != null){
}
else
ResultSet rs = st.executeQuery("select * from emp");
st.executeQuery("select * from emp");
System.out.println("Number of Columns:
"+rsmd.getColumnCount());
System.out.println("Name of the Column :
"+rsmd.getColumnName(1));
System.out.println("Type of the Column :
"+rsmd.getColumnTypeName(1));
System.out.println("precision of Column:
"+rsmd.getPrecision(4));
System.out.println("scale of the Column:
"+rsmd.getScale(4));
System.out.println("constraint of
Column:"+rsmd.isNullable(1));
Note: We cannot execut “desc” command from java program, we will

get one error. That is java.sql.SQLExcepiton: invalid sqlstatement.
Desc command is not a sql command, it is design for sql prompt for
windows os.
import java.sql.ResultSetMetaData;
import com.myfactoy.ConnectionFactory;
public class JDBCDemo {

SQLException, IllegalAccessException, InstantiationException,

IOException{
Connection con =
ConnectionFactory.getMyConnection();
ResultSet rs = st.executeQuery("select
sname,sid,sfee,sage from sbaj2to4");
System.out.println(rsmd.getColumnCount());
System.out.println(rsmd.getColumnType(1));
System.out.println(rsmd.getColumnTypeName(1));
System.out.println(rsmd.getColumnLabel(1));
System.out.println(rsmd.getPrecision(1));
System.out.println(rsmd.getScale(1));
System.out.println(rsmd.getColumnClassName(1));
System.out.println(rsmd.isNullable(1));
}
}
ParameterMetadata:
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
public class SetDemo {

Exception{
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost
:1521:xe",
"system","manager");
PreparedStatement ps =
con.prepareStatement("insert into values
sbaj4to6(?,?,?)");
ParameterMetaData pmd =
ps.getParameterMetaData();
System.out.println(pmd.getParameterCount());
//System.out.println(pmd.getParameterMode(1))
;
//System.out.println(pmd.getPrecision(1));
//System.out.println(pmd.getScale(1));
}
}
Note: native,oci, type2 are not support this feature.

Query:
A Query is a database command, that is used for performing an

operation on db. The operations are
Create,drop, delete, insert, select , update , delete etc options.
All queries are divided into 5 types.
1. Data Definition Languages: (DDL): Used to define database

objects.
a. Create.
b. Drop.
c. Alter.
d. Truncate.
e. Rename.
2. Data Manipulate Languages: (DML): It is used to manipulate
the data, which is available in Objects.
a. Insert.
b. Delete.
c. Update.
3. Data Retrieval and query Language: (DRL/DQL): It is used to
read the information from database.
a. Select.
4. Transactional Control Language: (TCL):
a. Commit.
b. Rollback.
c. Savepoint.
5. Data Control Language: (DCL):
a. Grant.
b. Revoke.
Examples on Commands:
create table empr (eid number, ename varchar2(10));
drop table empr;
alter table empr add esal number(10,3);

truncate table empr; (all the records will deleted)
rename empr to emps;
insert into emps values(101,’ram’,3000);
delete from emps where eid=101;
update emps set eid=201 where eid=101;
select * from emp;
create table empn(eid number(5) constraint eid_unq UNIQUE,

ename varchar2(10);
delete from sbaj9to11 where sid between value1 and value2
Mainly queries are classified into two types.
Select (DQL)
Non-select
Again Non-select queries are two types.
Updatable (DML)
Queries that return nothing (DDL, TCL, DCL).

public class JdbcDemo {
//int count=st.executeUpdate("create table sbaj6to8(eno

number(5),ename varchar2(15),esal number(10))");
//int count=st.executeUpdate("drop table sbaj6to8");
//int count= st.executeUpdate("alter table sbaj6to8 add deptno

number(3)");
//int count = st.executeUpdate("rename sbaj6to8 to kitaj6to8");
//int count = st.executeUpdate("insert into kitaj6to8

values(103,'annie',6000,30)");
//int count = st.executeUpdate("delete from kitaj6to8 where

eno=103");
//int count = st.executeUpdate("truncate table kitaj6to8");
//int count = st.executeUpdate("update kitaj6to8 set eno=101

where eno=103");
//int count = st.executeUpdate("desc kitaj6to8");//invalid
System.out.println("count: "+count);
con.close();
We can’t use desc command in our java application, the reason is

“desc” command is not part any type of language.
Statement Interface:
It is used to executing the queries in jdbc.
It will provide three methods.
1. execute( String query).

2. executeUpdate(String query)
3. executeQuery(String query).
execute() is used to run any type of query.
It will return Boolean value. The return value is true, if the

query is select else returns false(insert query).
If the query execution failed it will returns SQL Exception.
Boolean b = st.execute(“select * from emps where eid=101”);
In above code assume, there is no record on 101 still it will return

true.
executeUpdate() is used to run updatable queries and returns

nothing.
It will return int value.
executeQuery() is used to execute given select query.

It will return set of results in the from ResultSet object.
Special Case:
We can get result, which generated by the execute() by using

following methods.
a. getResultSet().
b. getUpdateCount().

Connection con =
if(con != null){
}
else
/*ResultSet rs = st.executeQuery("select * from emp");
System.out.println("rs: "+rs);*/
boolean b = st.execute("insert into emps values(101,'sam',4000)");
if(b){
ResultSet rs = st.getResultSet();
System.out.println("^^^^^^^");
while(rs.next()){
System.out.println(rs.getInt(1)+"..."+rs.getString(2));
}
}
else{
int updateCount = st.getUpdateCount();
System.out.println("updateCount: "+updateCount);
}
}

Connection con =
if(con != null){
}
else
/*ResultSet rs = st.executeQuery("select * from emp");
System.out.println("rs: "+rs);*/
boolean b = st.execute("select * from emps");
if(b){
ResultSet rs = st.getResultSet();
System.out.println("^^^^^^^");
while(rs.next()){
}
}
else{
int updateCount = st.getUpdateCount();
System.out.println("updateCount: "+updateCount);
}
}
Execute() can run all type of queries. But we need to write more line
of code to view the records.
Code understandability is difficult.
To run query and get the result within the single line we can go for
two more methods.
executeQuery()
executeUpdate()
If we are using executeUpdate(), that will be call execute() and that

method will executeUpdateCount() for return the value.
If we are using executeQuery(), that will be call execute() and that

method will call getResultSet() for return the results.

Connection con =
if(con != null){
}
else
int count = st.executeUpdate("insert into emps
values(444,'kittu',5000)");
ResultSet rs = st.executeQuery("select * from emps");
while(rs.next()){
System.out.println(rs.getInt(1)+"..."+rs.getString(2)+"...."+rs.getI
nt(3));
}
Note: In the above program we using both executeUpdate() and

executeQuery().
In which order using these method in that order only data will be
stored in Statement object.
According above problem first executeUpdate() result will be placed

into Statement object later executeQuery() result will be placed.
How to insert into a new employee data into a database:

Connection con =
if(con != null){
}
values(444,'kittu',5000)");
}
}
If we execute above program multiple times, the same data will be
inserting into emps table.
If the table having unique constraint then we need to face the

following problem from second time onwards that is SQLException:
unique constraint violated.
In data base side we need to execute this query:
create table empn(eid number(5) constraint eid_unq UNIQUE,

ename varchar2(10);
In java application we need to type following code.

Connection con =
if(con != null){
}
values(444,'kittu')");
}
First executing the above program no problem data will be stored in

db successfully. But from second time onwards we will face bellow
Exception.
java.sql.SQLIntegrityConstraintViolationException: ORA-00001: unique constraint
(SYSTEM.SID) violated
To avoding above problem we should rewrite above program like
bellow.
import java.sql.SQLIntegrityConstraintViolationException;
public static void main(String[] args){
Connection con;
try {
con = DriverManager.getConnection(
"system","annie");
System.out.println("cnon: "+con);
int count = st.executeUpdate("insert into sbaj2to4

values(101,'neeraj',26,5000)");
catch (SQLIntegrityConstraintViolationException e) {
System.out.println("you are entering duplicate

records");
}
catch (SQLException e) {
e.printStackTrace();
in the above we can stop abnormal termination but we cant insert

any other record.
To avoiding above problem we should code as bellow.
import java.sql.SQLIntegrityConstraintViolationException;
import java.sql.SQLSyntaxErrorException;
Connection con;
try {
"system","annie");
System.out.println("cnon: "+con);

System.out.println("enter student id");
int sid = scan.nextInt();
System.out.println("enter student name");
String sname = scan.next();
System.out.println("enter student age");
int sage = scan.nextInt();
System.out.println("enter student fee");
int sfee = scan.nextInt();
//int count = st.executeUpdate("insert into sbaj2to4

values(sid,sname,sage,sfee)");
int count = st.executeUpdate("insert into sbaj2to4

values("+sid+",'"+sname+"',"+sage
+","+sfee+")");
catch (SQLIntegrityConstraintViolationException e) {
System.out.println("you are entering duplicate

records");
catch(SQLSyntaxErrorException e) {
System.out.println("input data not matched with

table column type");
System.out.println("some problem in while inserting");
}
How to delete the data/record from Data Base:

Connection con =
if(con != null){
}
int count = st.executeUpdate("delete from empn where
eid=444”);
}
How to update record in Database:

Connection con =
if(con != null){
}
int count = st.executeUpdate("update empn set ename=’kiran’
where eid=101");
}
How to create table in db from java appn:
public class JdbcProgram5 {
throws ClassNotFoundException, SQLException{
"system",
"manager");
if(con!=null){
System.out.println("con: "+con.hashCode());
}
else
String query = "create table sbajram (eid number(5),ename
varchar2(20),esal number(10))";
int count = st.executeUpdate(query);
}
}
In the above program executeUpdate() will return value like
zero(0).
The reason is executeUpdate() method always gives information

about records/rows but not table.
How to drop the table in db from java appn:

"system",
"manager");
if(con!=null){
}
else
String query = "drop table sbajram";
}
}
How to add new column to existing table from java appn:
"system",
"manager");
if(con!=null){
}
else
String query = "alter table sbaj add institute varchar2(20)";
}
}
How to delete all the records the from table:

"system",
"manager");
if(con!=null){
}
else
String query = "truncate table sbaj";
}
}
How to rename the table in from java appn:
"system",
"manager");
if(con!=null){
}
else
String query = "rename sbaj to sbajram";
}
}
Connection con=null;
try{
p.put("user", "system");
p.put("password", "manager");
String url = "jdbc:oracle:thin:@localhost:1521:xe";
con = DriverManager.getConnection(url,p);
System.out.println("enter student id number");
System.out.println("etner student name ");
System.out.println("enter course fee");
//String query = "insert into sbaj values(sid,sname,sfee)";
String query = "insert into sbaj
values("+sid+",'"+sname+"',"+sfee+")";
}catch(Exception e){
}
finally{
if(con!=null){
try {
con.close();
} catch (SQLException e) {
}
}
}
}
}
Note: Whenever we create a table from java application by using

executeUpdate (-) we will get result is zero. That means don’t be
think table is not create in the db. Basically executeUpdate (-) will
provides number records are update or not in the table, but it will
not giving any information about table creation.
If we want to know about whether the table is created or not go

check in db.
Based on the values we are placing in query, queries are divided into
three types.
a. Static SQL query.

b. Dynamic SQL query.
c. Stored Procedures.
Static SQL query:
A query, that has values directly is called static sql query.
Ex: select * from empn where eid = 101;
Insert into empn values (102,’varun’);
Dynamic SQL query:
A query that will be getting parameter values at run time means

meanwhile of executing the program is called Dynamic SQL Query.
Query parameter is represented by using ‘?’.
By default ‘?’ is act as IN parameter.
In oracle we have three types of parameters.
a. IN  Input
b. Out  Output
c. INOUT  Both Input and Output.
All these 3 types of parameters are represented by ‘?’. It is also

called as “place holders”.
Insert into empn values(?,?);
We must set values for place holders (?) at run time meanwhile of
query execution.
While inserting the values to into place holder (?) we must be

represent place holder with index position.
In the above insert query first ‘?’ index is 1 and second ‘?’ index is 2.
Statement and Types of Statement:
Statement is one java object, which is used to send and execute the
query sql and pl/sql queries.
Internals of Statement Object:

1. Validating sql query (based on standard rules).
2. Compiling sql query (converting into internal db
instructions).
3. Prepared a build plan for query using db own algorithms.
4. Process the build plan to perform operations on db.
5. Finally destroy the build plan and returns appropriate result
to java application.
We have three types of statement objects.
1. Statement.
2. PreparedStatement.
3. CallableStatement
Statement interface or object is root interface for all types of

statement interface, is used for executing the static query.
PrepatedStatement is sub interface for Statement interface, is used

for executing pre-compile static or dynamic query.
CallableStatement is sub interface for PreparedStatement interface,

is used to executing the stored procedures.
In above I already noticed Statement interface internals. Here I will

give full information about Statement interface internals.
These internals technically we can call as build plan.
Build plan/SQL contains seven steps.
1. Verifying query syntax. If valid then

2. Verifying given table and columns existed or not. If available
3. Generating or creating C-language program for the Sql
query.
4. Compiling C-Language program.
5. Executing the above compiled C-Language program.
6. Finally returning the result to java app.
7. After successfully return the result, destroy the above C-
Language program.
If we are using Statement interface every time these above seven

steps are going to executing repeatedly.
From java side it is performance issue.
So we need create the build plan only one and reuse it then we
should go for concept like PreparedStatement interface.
If we are using Statement interface for sending the dynamic values

we need to face another program that is decrease query readability.
Example to insert two values into db we need to use following query

like
Insert into empn values(105, ‘swathi’);
“Insert into empn values (“+eid+”,’ ”+ename+” ’ )”;
To overcome the above two problems like Query Syntax readability

and avoiding Build plan recreation we should move to
PreparedStatement interface.
There is some issues to round trips. If our query syntax having

problem that will not recognize the by the compiler and jvm. The
reason we are always writing query in String format. The query
sntax problem recognize by the database and telling to jvm.
package jdbc.aj.ram;
public class JdbcProgram {

public static void main(String[] args)throws SQLException {
Connection con = ConnectionFactory.getConnect();

System.out.println("enter student details");
for(int i=1;i<=5;i++){
System.out.println("enter student number");
int sno = scan.nextInt();
String query = "insert into sbaj
values("+sno+",'"+sname+"',"+sfee+")";
st.executeUpdate(query);
}
}
}
public class FirstJdbcProg {
public static void main(String[] args) throws Exception{
System.out.println("=============");
Connection con = DriverManager.getConnection
("jdbc:oracle:thin:@localhost:1521:xe","system", "manager");
PreparedStatement ps = con.prepareStatement("insert into
sbajemp(?,?,?,?)");
System.out.println("ps: "+ps);
}
}
Java always provides rules to db vendors in the form of interface like

Connection, Statement, PreparedStatement.
The rules are implemented by the database vendors by using classes

like
T4CConnection, T4CStatement, T4CPreparedStatement.
In these classes method database vendors provides logic like

creating objects and placed into interface reference variables.
The implementation classes may be different from one database
vendor to another database vendor.
PreparedStatement:
PreparedStatement provides bellow benefits.
Those are
a. Build Plan or Sql plan created only one time meanwhile of

preparedstatement object creation and plan placed into that
object.
b. In place of variables we can use ‘?’ so no ‘+’ operators.
c. ‘?’ by default provides varchar type column, so no need to
write single quotes(‘), these single quotes automatically
added.
package jdbc.aj.ram;
public class JdbcProgram {

public static void main(String[] args)throws SQLException {

con.prepareStatement("select * from sbaj where
sname=?");
ps.setString(1, sname);
ResultSet rs = ps.executeQuery();
while(rs.next()){
+"\t"+rs.getInt(3));
}
}
}

Connection con =
if(con != null){
}
else
PreparedStatement ps = con.prepareStatement("insert into empn
values(?,?)");
System.out.println("enter id");
int eid=scan.nextInt();
System.out.println("enter ename");
String ename = scan.next();
ps.setInt(1, eid);
ps.setString(2, ename);
int x = ps.executeUpdate();
System.out.println("x: "+x);
}

Connection con =
if(con != null){
}
else
PreparedStatement ps = con.prepareStatement("insert into empn
values(?,?)");
ps.setInt(1, 104);
ps.setString(2, "ramesh");
int x = ps.executeUpdate();
System.out.println("x: "+x);
ps.setInt(1, 105);
ps.setString(2, "mahesh");
int y = ps.executeUpdate();
System.out.println("x: "+y);
}
}
Note: To execute the query one time better prefer Statement object.
To execute the query multiple times better prefer

PreparedStatement object.
Note: Whenever we work with PreparedStatement better execute
the query multiple times, otherwise it will leads to performance
issue.
Compare to Statement object, PreparedStatement object not destroy

the sql plan within the less time after query execution, we must call
close() explicitly.
While inserting data into table by using PreparedStatement place

holders(?) index positions same as column postions of a table.
While working with update, delete querites by using Prepared-

Statement, place holders(?) index position is not depends on
columns of a table, place holders(?) index position only depends on
the occurrence of a place holders(?) in a query from left to right.
package jdbc;
throws SQLException{
"jdbc:oracle:thin:@localhost:1521:xe","system
","manager");
System.out.println("select your operation");
System.out.println("1.INSERT\t2.DELETE");
System.out.println("3.TRUNCATE\t4.UPDATE");
System.out.println("5.SELECT");
int operation = scan.nextInt();
switch(operation){
case 1: System.out.println("YOUR ARE SELECTING INSERT
OPERATION");
PreparedStatement ps1 = con.prepareStatement("insert into
sbaj2_4 values(?,?,?,?)");
System.out.println("enter studnet name");
System.out.println("enter studnet fee");
System.out.println("enter studnet age");
ps1.setInt(1, sid);
ps1.setString(2, sname);
ps1.setInt(3, sfee);
ps1.setInt(4, sage);
int count1 = ps1.executeUpdate();
System.out.println("recored inserted
successfully: "+count1);
break;
case 2: System.out.println("YOU ARE SELECTING DELETE
OPERATION");
PreparedStatement ps2 = con.prepareStatement("delete from
sbaj2_4 where sno=?");
System.out.println("enter studnet number");
int sid1 = scan.nextInt();
ps2.setInt(1, sid1);
System.out.println("recored deleted:
"+count2);
break;
case 3: System.out.println("YOU ARE SELECTING
TRUNCATE OPERATION");
PreparedStatement ps3 =
con.prepareStatement("truncate table sbaj2_4");
System.out.println("all records are delected:
"+count3);
break;
case 4: System.out.println("YOU ARE SELECTING UPDATE
OPERATION");
con.prepareStatement("update sbaj2_4 set sname=? where
sno=?");
System.out.println("enter studnet name for
updation");
String sname1 = scan.next();
System.out.println("enter studnet number");
ps4.setString(1, sname1);
System.out.println("records are updated:
"+count4);
break;
SELECT OPERATION");
PreparedStatement ps5 = con.prepareStatement("select *
from sbaj2_4");
ResultSet rs = ps5.executeQuery();
while(rs.next()){
System.out.println(rs.getInt(1)+"\t"+rs.getString(2)+"\t"+rs.getIn
t(3)
}
}
}
}
package jdbc;
"jdbc:oracle:thin:@localhost:1521:xe","s
ystem","manager");
String query = "update sbaj2_4 set sfee=? where
sno=?";
PreparedStatement ps=
con.prepareStatement(query);
System.out.println("Enter Student fee");
System.out.println("Enter Student number");
ps.setInt(1, sfee);
ps.setInt(2, sno);
int count = ps.executeUpdate();
}
}
package jdbc;
"jdbc:oracle:thin:@localhost:1521:xe","system","manager
");
Scanner scan = new Scanner
(System.in);
System.out.println("do you want do the
operations if yes type yes if no type no");

String flag = scan.next();
while(flag.equalsIgnoreCase("yes")){
System.out.println("select your
operation");
System.out.println("1.INSERT
\t2.DELETE");
System.out.println("3.TRUNCATE
\t4.UPDATE");
System.out.println("5.SELECT");
int operation = scan.nextInt();
switch(operation){
case 1: System.out.println("YOUR ARE
SELECTING INSERT OPERATION");

PreparedStatement ps1 = con.prepareStatement("insert
into sbaj2_4
values(?,?,?,?)");
System.out.println("enter
student id");
studnet name");
studnet fee");
studnet age");
ps1.setInt(1, sid);
ps1.setString(2, sname);
ps1.setInt(3, sfee);
ps1.setInt(4, sage);
int count1 =
ps1.executeUpdate();
System.out.println("recored
inserted successfully: "+count1);

break;
DELETE OPERATION");
PreparedStatement ps2 = con.prepareStatement("delete
from sbaj2_4
where sno=?");
studnet number");
int count2 =
System.out.println("recored
deleted: "+count2);
break;
TRUNCATE OPERATION");
PreparedStatement ps3 = con.prepareStatement
("truncate table sbaj2_4");

int count3 =
System.out.println("all
records are delected: "+count3);

break;
UPDATE OPERATION");
con.prepareStatement("update sbaj2_4 set sname=?
where
sno=?");
studnet name for updation");

studnet number");
ps4.setString(1, sname1);
int count4 =
System.out.println("records
are updated: "+count4);

break;
case 5: System.out.println("YOU ARE
SELECTING SELECT OPERATION");

PreparedStatement ps5 = con.prepareStatement
("select * from sbaj2_4");

ResultSet rs = ps5.executeQuery();
while(rs.next()){
System.out.println(rs.getInt
(1)+"\t"+rs.getString(2)+"\t"+rs.getInt(3)
}//while
}//switch
System.out.println("do you want continue if no
type no");
flag = scan.next();
}//while
}
}
package jdbc;
/* //program-1
int count = st.executeUpdate(
"insert into sbaj6to8
values(111,'vikram',9000,40)");
System.out.println(count+" records inserted");
int count1 = st.executeUpdate("delete from
sbaj6to8 where deptno=20");
System.out.println(count1+" records deleted");
ResultSet rs = st.executeQuery("select * from
sbaj6to8");
System.out.println("ENO\t\tENAME\t\tESAL\t\tDEPTNO")
;
while(rs.next()){
System.out.println(rs.getInt(1)+"\t\t"+rs.getString(2)
+"\t\t"+rs.getInt(3)+"\t\t"+rs.getInt(4));
}
con.close();
*/
con.prepareStatement("select * from sbaj6to8");
System.out.println("ENO\t\tENAME\t\tESAL\t\tDEPTNO")
;
while(rs.next()){
System.out.println(rs.getInt(1)+"\t\t"+rs.getString(2)
+"\t\t"+rs.getInt(3)+"\t\t"+rs.getInt(4));
}
con.prepareStatement("delete from sbaj6to8 where
deptno=10");
int count = ps1.executeUpdate();
System.out.println(count+". recoreds are
deleted");
con.close();
}
}
Withthe help of single Statement object we can exeuctes
single(same) query multiple times and different types of queries.
With the help of single PreparedStatement object we can execute
same query multiple times but not different type of queries.
CallableStatement:
CallableStatement is one of the jdbc statement object, it is used for

executing the stored procedures and functions.
It is the sub interface of PreparedStatement interface.
Stored procedure is one pl/sql program.
It contains set of sql queries for execution with proper validation or

conditions and calculations to perform crud operations on db table.
Advantages of Stored Procedure:

Separate sql queries from java program and stores them
permanently in db server in compiled format.
So parallel development is possible, that means java program and

stored procedure programmer can work at a time.
StoredProcedure is reusable.
So All the programming language can use the same stored

procedure.
Procedure creation and calling same for all language.
No need to change the strored procedure program from one

language program to antoher language program.
It is precompiled program, so execution is happen very quickly.
Db query statements are different from one db to another so better

to avoid the writing queries in our app. So whenever we change db
no need to disturb the java program.
PreparedStatement query precompiled from second time onwards,

SQL plan is temporary(upto programexecution). It is not reusable.It
is only suitable for current and one PreparedStatement object
only.PreparedStatement connection is closed SQL or build plan
destroyed.
A procedure precompiled SQL plan is permanently stored in database

and reusable through multiple application and languages also.
Differences between Procedure and Functions in DB:
StoredProcedure are pre-compile objects which are compiled for first

time and its compiled format will be saved and executes whenever it
is called where as functions are compiled and called every time
when it is called.
Procedures may or may not return values where as functions must

return value.
Procedures have input and output parameters where as functions
have input parameters only.
Functions can calls from procedures where as procedures cannot

called from functions.
Syntax to create Stored Procedure:
create or replace procedure procedure_name(parameter list with ,

separator)
is
variable declarations;
begin
logic with sql commands and pl/sql operators, conditions, loops

and exception handling
end;
Create or replace function function_name(parameter list)
Return <type> here type is db datatype
Is
Variable declaration
Begin
logic
Return <result>;
End;
Types of Parameters:
To send input and to read output from stored procedure, every db
will support three types of parameters.
1. IN
2. OUT
3. INOUT
IN parameter is used to send input values.
OUT parameter is used to return output values.
INOUT parameter is used to read and also return output value.
To create parameter as Input we need to write IN in parameter

declaration.
By default parameters are comes under Input parameters only so no

need to declare IN in parameter declaration.
To create parameter as output we need to write OUT in parameter

declaration.
Create or replace procedure procedurename(
Eno IN Number,
Ename OUT varchar2,
Esal OUT number,
Empdept OUT varchar2)
To communicate with above procedure from java application, we

need to send eno as input to procedure and get ename, esal,
empdept as output.
Syntax to call procedure from java application:
“{call procedure_name (?,?)}”
Syntax to call function from java application:
“{?:=cal functionname(?)}”
CallableStatement object we can create by using following method.
That is prepareCall(String call);
create table empram(eno number(5) Primary key, ename

varchar2(10),sal number(7), dept varchar2(10));
insert into empram values(101,'ram',5000,'software');
insert into empram values(102,'sam',6000,'testing');
create or replace procedure empramprocedure (empnum IN

number,incrsal IN number,empname OUT varchar2,empsal OUT
number, empdept out varchar2)
is
oldsal empram.sal%type;
begin
select sal into oldsal from empram where eno=empnum;
update empram set sal=oldsal+incrsal;
commit;
select ename,sal,dept into empname,empsal,empdept from

empram where eno=empnum;
end;
Communicating with database through Procedure:

Connection con =
if(con != null){
}
else
CallableStatement cs = con.prepareCall("{call
empramprocedure(?,?,?,?,?)}");
cs.registerOutParameter(3,Types.VARCHAR);
cs.registerOutParameter(4,Types.NUMERIC);
cs.registerOutParameter(5,Types.VARCHAR);

System.out.println("enter eno");
int eno = scan.nextInt();
System.out.println("enter sal for increment");
int incrsal = scan.nextInt();
cs.setInt(1,eno);
cs.setInt(2, incrsal);
cs.execute();
//Reading process should depends on placehold out
parameters
//type but not depends on column index
in table
String ename = cs.getString(3);
int sal = cs.getInt(4);
String dept = cs.getString(5);
System.out.println(ename+"..."+sal+"..."+dept);
cs.close();
con.close();
}
}

CallableStatement cs =
con.prepareCall("{call
sbajramprocedure(?,?,?,?,?,?)}");
System.out.println("enter employee id");
System.out.println("enter increment salary");
int incrsal = scan.nextInt();
cs.setInt(1, eno);
cs.setInt(2, incrsal);
cs.registerOutParameter(3, Types.NUMERIC);
cs.registerOutParameter(4, Types.VARCHAR);
cs.registerOutParameter(5, Types.NUMERIC);
cs.registerOutParameter(6, Types.VARCHAR);
cs.execute();
/*ResultSet rs = cs.executeQuery();
rs.next();
System.out.println(rs.getInt(1));
System.out.println(rs.getString(2));
*/
int empnumber = cs.getInt(3);
String empName = cs.getString(4);
int empSal = cs.getInt(5);
String empDept = cs.getString(6);
System.out.println(empnumber+".."+empName+"..."+empSal+"..."
+empDept);
}
}
Whenever we working with stored procedure through

CallableStatement don’t read data in the form of ResultSet,
we can’t do fetch operations by using next().
How to communicate with static queries by using callable statemen

object:
import java.sql.CallableStatement;
import java.sql.Types;
import jdbc.aj.ram.ConnectionFactory;
CallableStatement cs = con.prepareCall("select * from
empram");
ResultSet rs = cs.executeQuery();
while(rs.next()){
System.out.println(rs.getInt(1)+".."+rs.getString(2)+".."+
rs.getInt(3)+"..."+rs.getString(4));
}
}
}
executeQuery() is not available in the CallableStatement interface, it

is available in PreparedStatement interface.
How to communicate with dynamic queries by using callable

statemen object:
import java.sql.CallableStatement;
import java.sql.Types;
CallableStatement cs = con.prepareCall("insert into
empram values(?,?,?,?)");
System.out.println("enter employee number");
System.out.println("enter employee name");
System.out.println("enter employee sal");
int esal = scan.nextInt();
System.out.println("enter employee dept");
String edept = scan.next();
cs.setInt(1, eno);
cs.setString(2, ename);
cs.setInt(3, esal);
cs.setString(4,edept);
int count = cs.executeUpdate();
}
}
How to function in database:
create or replace function empramfunction(empno number)
return number as amount number;
begin
select sal into amount from empram where eno=empno;
return amount;
end;
Communicating with database through function:

Connection con =
if(con != null){
}
else
CallableStatement cs =
con.prepareCall("{call ?:=empramfunction(?)}");

System.out.println("enter emp no: ");
cs.setInt(2, eno);
cs.registerOutParameter(1, Types.INTEGER);
cs.execute();
int sal = cs.getInt(1);
System.out.println("sal: "+sal);
con.close();
}
If given employee id not available while interacting with table
trhough function then we will get exception.
Whenever working with table directly, if the given id not avialble

then we never get function we will output or return value like false.
Transaction Management:
The process of taking database position from one state to another

state completely or none is called Transaction Management.
In transaction management more than one updatable query

executed.(insert,update,delete)
We need to commit results of all updatable queries only if all

updatable queries successfully executed.
If anyone updatable query is failed, we need to rollback all queries

result and should bring back to database state to its original state
before our transaction is started.
To commit and rollback transaction results, we must use methods

from connection interface.
They are:
void setAutoCommit(boolean autocommit)throws SQLException
By using above method, we can change auto commit mode true or

false.
If we pass true, each updatable statement (insert, delete, update)

result will be commit as individual transactions.
If we pass false, all updatable statements are grouped in a single

transaction, then all SQL Updatable queries results is committed or
rollback at a time by the method calls con.commit() or
con.rollback().
By default all new connections are opened in auto commit mode true
only.
Public void commit() throws SQLException

This method stores or saves all changes made in database since the
previous commit or rollback and releases any database currently
held by this connection object.
If we are insert new record that new record is locked until it is

committed. Other database clients with new connection cannot
access this row.
Whenever we run update or delete query on a particular row that

row is locked, that will not access by the other connection client.
Public void rollback() throws SQLException:
This method reverts the changes done in db in current transaction

and releases the locks.

try{
Connection con =
if(con != null){
established");
}
else
established");
con.setAutoCommit(false);
st.execute("insert into emps
values(110,'a',4444)");
st.execute("update emps set eid=301 where
ename='kam'");
st.execute("delete from emps where eid=444");
con.commit();
System.out.println("****************8");
}catch(SQLException e){
System.out.println("some problem");
}
}
IN the above program if we are not write con.commit() records are

not updated into main table. The reason is setAutoCommit(false) so
records are not updated by default. We need use commit().

Connection con =
if(con != null){
established");
}
else
established");
st.execute("insert into emps
values(110,'a',4444)");
st.execute("update emps set eid=301 where
ename='kam'");
st.execute("delete from emps where eid=444");
}
}
In the above program records directly committed into main table the
reason the setAutoCommit(true) by default.
QueryDemo.java
package com.ram.query;
public class QueryDemo {

public static final String QUERY1 =
values(101,'ram',5000,10)";
values(102,'sam',4000,20)";
values(103,'varun',6000,30)";
}
JdbcDemo.java
package jdbc;
import com.ram.query.QueryDemo;
Connection con = null;
try{
"jdbc:oracle:thin:@localhost:152
1:xe",
"system",
"manager");
st.executeUpdate(QueryDemo.QUERY1);
System.out.println("programmer go and
check ur db console");
Thread.sleep(10000);
con.commit();
System.out.println("catch block");
try {
con.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
}
}
package jdbc;
import com.ram.query.QueryDemo;
try{
1:xe",
"system",
"manager");
int count1 = st.executeUpdate(
values(102,'sam',7000,20)");
System.out.println(count1+".record
inserted");
int count2 = st.executeUpdate(
"delete from sbaj6to8 where
eno=103");
System.out.println(count2+".record
deleted");
"update sbaj6to8 set deptno=20
where eno=105");
System.out.println(count+".records
updated");
if(count == 0){
System.out.println("11111111111");
con.rollback();
}
else{
con.commit();
}
try {
con.rollback();
}
}
}
}
The bellow program will the complete information about Transaction

management and commit() and rollback().
import java.sql.*;
public class Test{

try{
"jdbc:oracle:thin:@localhost:1521:xe","system","manager");
int count1 = 0;
int count2 = 0;
int count3 = 0;
count1= st.executeUpdate(Queries.INSERT);
System.out.println(count1+"record inserted");
count2 = st.executeUpdate(Queries.UPDATE);
System.out.println(count2+"record updated");
count3 = st.executeUpdate(Queries.DELETE);
System.out.println(count3+"record deleted");
if(count1>=1 && count2>=1 && count3>=1){
System.out.println("if block");
con.commit();
}
else {
System.out.println("else block");
con.rollback();
}
System.out.println("outer catch block");
try {
con.rollback();
System.out.println("inner catch block");
}
}
}
}
The bellow program will the complete information about Transaction
management and commit() and rollback().

Connection con =null;
Statement st = null;
try{
con =
if(con != null){
established");
}
else
established");
String query1 = "insert into empn values(666,'fff')";
String query2 = "insert into empn
values(555,'ggg')";
st = con.createStatement();
st.executeUpdate(query1);
System.out.println("1st query inserted");
st.executeUpdate(query2);
System.out.println("2nd query inserted");
con.commit();
System.out.println("records are commited");
System.out.println("problem comes here");
if(con!=null){
try{
con.rollback();
}catch(Exception e1){
}
}
}
}
In the above both query1 and query2 are valid then both the insert
statement will updated to database main table with support of
commit(), otherwise no insert query will be updatable into database
main table.
Program on savePoint():
import java.sql.Savepoint;
public class TransactionManagementDemo {
try{
st.executeUpdate(
"insert into sbajemp values (204,'ram4',99991,'hr4')");
st.executeUpdate(
Savepoint sv = con.setSavepoint();
st.executeUpdate(
st.executeUpdate(
st.executeUpdate(
con.rollback(sv);
con.commit();
}catch(ClassNotFoundException e){
System.out.println("class is not existed");
}
catch(SQLException e){
System.out.println("problem database connection");
}
}
}
Batch Updations:
Batch updates is the process of sending and executing multiple

updatable queries (Insert, Update, Delete) in a single group is called
batch updations.
Whenever we execute multiple updatable queries as group or

execute multiple updatable queries with dependency we must
choose batch updations.
The advantages of the batch updations is performance is improved in
executing multiple updatable queries, because number of hits on the
database are reduced and moreover number of transformation
control from java app to db will be reduced.
If we want to send 1000 employee details into db, we need to write

1000 insert queries and 1000 times we need to hit db and 1000
times transfer control from java app to db.
If we are using batch updations, we can send 1000 insert queries

only one time.
Other advantage is if first query is successfully executed then only

second query will be executed successfully. This is called
dependency of queries.
To develop batch updations in java, we can take support of

Statement and PreparedStatement interface and their methods.
Void addBatch(String query) throws SQLException
The above method adds given sql command to this Statement object
batch.
Int[] executeBatch() throws SQLException
The above method is used to handover the all sql commands stored
in statement object batch to the database.
If all the sql statements executed successfully, it returns an int[].
If any exception is raised then we will get BatchUpdateException. It

is a subclass of SQLException.
Public void clearBatch()SQLException
The above method is used to removes all queries from the batch and
make this statement object batch as empty.
PrepatedStatement interface methods for batch updataions:
void addBatch() throws SQLException

the above is used to adds the same sql query, which is stored in
PreparedStatement object, multiple times to PreparedStatement
object batch with different values.
What is difference between in addBatch() in Statement and

PreparedStatment objects?
addBatch(-) of Statement is parameterized method, query passed at

adding time only.
addBatch() of PreparedStatement is non-parameterized method.
Program on Batch Updation:

try{
con =
if(con != null){
}
else
st=con.createStatement();
String iquery= "insert into empram values(103, 'varun', 7000,
'hr')";
String uquery = "update empram set dept='developer' where
eno=101";
String dquery = "delete from empram where eno=102";
st.addBatch(iquery);
st.addBatch(uquery);
st.addBatch(dquery);
int[] ia = st.executeBatch();
System.out.println(ia[0]+" rows inserted");
System.out.println(ia[1]+" rows updated");
System.out.println(ia[2]+" rows delete");
con.commit();
System.out.println("recoreds commit completed");
if(con!=null){
try{
con.rollback();
}catch(Exception e1){
}
}
BatchUpdates is only suitable for updateable querites like insert,

delete and update but not for select query.
If we add select query like bellow

st.addBatch(“Select * from sbaj2to4”);
We will get the following exception that is.
java.sql.BatchUpdateException: invalid batch command:

invalid SELECT batch command
public class Jdbcprogram15 {
Connection con=null; try{
“system",
"manager");
PreparedStatement ps = con.prepareStatement(
"insert into empram values(?,?,?,?) ");
ps.setInt(1, 205);
ps.setString(2, "megha");
ps.setInt(3, 999999);
ps.setString(4,"faculty");
ps.addBatch();
int a[]=ps.executeBatch();
System.out.println(a);
con.commit();
System.out.println("controle comes to here");
if(con!=null){
try {
con.rollback();
}
public class Jdbcprogram15 {
try{
"system",
"manager");
con.prepareStatement("insert into empram
values(?,?,?,?)");
for(int i =1; i<=3;i++){
String ename= scan.next();
System.out.println("enter employee salaray");
System.out.println("enter employee department");
String edept = scan.next();
ps.setInt(1,eno);
ps.setInt(3,esal);
ps.setString(4, edept);
ps.addBatch();
}
int a[]=ps.executeBatch();
System.out.println(a[0]);
con.commit();
System.out.println("controle comes to here");
if(con!=null){
try {
con.rollback();
}
}
}
}
}
import java.sql.*;
public class Test{
try{
con =
DriverManager.getConnection(“jdbc:oracle:thin:@localhost:1521:xe"
,"system","manager");
"insert into sbaj6to8 values(?,?,?,?,?)");
String sname= scan.next();
System.out.println("enter student spassword");
String spassword= scan.next();
ps.setInt(1, sid);
ps.setInt(3, sage);
ps.setInt(4,sfee);
ps.setString(5, spassword);
ps.addBatch();
/*ps.addBatch("update sbaj6to8 set sname=?where sid=?");
System.out.println("enter student id for update");
System.out.println("enter student name for update");

ps.setString(1,sname1);
ps.setInt(2,sid1);*/
int[] a = ps.executeBatch();
System.out.println(a[0]+".records inserted");
con.commit();
catch(Exception e){
try {
con.rollback();
finally{
if(con!=null){
try {
con.close();
}
}
In the above program we will get exception while adding new query
into preparedstatement object by using addBatch().
How to insert the image into database table:
import java.io.File;
import java.io.FileInputStream;

try{
con =
if(con != null){
}
else
con.prepareStatement("insert into empblob values(?,?)");
System.out.println("enter some emp id:");
ps.setInt(1, eno);
File f = new File("anni 097.jpg");
FileInputStream fis = new FileInputStream(f);
ps.setBinaryStream(2, fis, (int)f.length());
int i = ps.executeUpdate();
System.out.println(i+".is inserted");
}
}
}
Uploading and downloading video file from db:
Steps to uploading the video in table of oracle database:

1. Create connection object by providing database details.
2. Create Statement object for creating table in database.
3. Create PreparedStatement object for uploading video into
Database.
4. Creating File object to communicating with video file.
5. Creating FileInputStream object for reading the data from
video file.
6. Created ByteArrayOutputStream object for reading the data from
FileInputStream objecy.
7. Converting data of ByteArrayStream object into byte array.
8. Finally handover that byte array data to PreparedStatement.
Steps to downloading the video from table:
a. Creating statement object for reading data in the form of
ReusltSet.
b. Create File and FileOutputStream object for communicating
with file for writing purpose.
c. Finally read the data from ResultSet and handover to
FileOutputStream.
import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.sql.*;
public class VideoASInput {
IOException{
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","sys
tem","manager");
int count = st.executeUpdate("create table video(video blob)");
PreparedStatement ps = con.prepareStatement("insert into video
values(?)");
File f = new File("C:\\Users\\Public\\Videos\\Sample
Videos\\Wildlife.wmv");
ByteArrayOutputStream byins = new ByteArrayOutputStream();
while (fis.available()>0) {
byins.write(fis.read());
}
byte[] videobytes = byins.toByteArray();
ps.setBytes(1, videobytes);
int count1=ps.executeUpdate();
System.out.println(count1);
Statement st1 = con.createStatement();
ResultSet rs =st1.executeQuery("select * from video");
while(rs.next())
{
File file1 = new File("E://ram.mp4");
FileOutputStream foStream = new
FileOutputStream(file1);
InputStream is2 = rs.getBinaryStream(1);
int i=0;
while((i=is2.read())!=-1){
foStream.write(i);
}
}
}
Reading the image from data base:

try{
con =
if(con != null){
}
else
ResultSet rs = st.executeQuery("select * from empblob");
while(rs.next()){
int eno = rs.getInt(1);
System.out.println("eno: "+eno);
InputStream is = rs.getBinaryStream(2);
FileOutputStream fos = new FileOutputStream("myphoto.jpg");
int i = is.read();
while(i !=-1){
fos.write(i);
i = is.read();
}
}
}
}
}
How to work with multiple image files (BLOB) :

package jdbc;
throws ClassNotFoundException,SQLException,
IOException{
"jdbc:oracle:thin:@localhost:1521:xe
", "system",
"manager");
con.prepareStatement("insert into studentsbaj
values(?,?,?)");
System.out.println("enter student image
path");
String sphoto = scan.next();
File f = new File(sphoto);

ps.setInt(1, sid);
ps.setBinaryStream(3, fis, (int)f.length());
System.out.println(count+".record inserted");
studentsbaj");
while(rs.next()){
int sid1 = rs.getInt(1);
String sname1 = rs.getString(2);
System.out.println(sid1+"\t"+sname1);
FileOutputStream fos =
new
FileOutputStream("C:\\Users\\Ramchandar\\Desktop\\"+s
name1+".jpg");
int i = 0;
while((i= is.read())!=-1){
fos.write(i);
}
}
}
}
How to convert image format from one type to another type:

Create blob table in db:
Create table empblob (eno number(5), ephoto blob);
Commit;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
public class JdbcProgram9{
throws SQLException, IOException{
/*PreparedStatement ps =
con.prepareCall("insert into empblob values(?,?)");
File f = new File("mypic.gif");
ps.setInt(1, eno);
ps.setBinaryStream(2, fis,(int)f.length());
System.out.println(count);
*/
while(rs.next()){
BufferedImage img =ImageIO.read(is);
FileOutputStream fos =
new FileOutputStream("emp-"+rs.getInt(1)+".png");
ImageIO.write(img, "png", fos);
System.out.println("image created");
}
}
}
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
public class JdbcProgram9{
IOException{
/*PreparedStatement ps = con.prepareCall("insert into
empblob values(?,?)");
File f = new File("anni 012.jpg");
ps.setInt(1, eno);
ps.setBinaryStream(2, fis,(int)f.length());

System.out.println(count);*/
while(rs.next()){
BufferedImage img =ImageIO.read(is);
FileOutputStream fos = new
FileOutputStream("mypic15.bmp");
ImageIO.write(img, "bmp", fos);

System.out.println("image created");
}
}
}
ImageIO is one final class is used to read and write image

information within the less time.
BufferedImage is used to store the image information.
Creating table by using CLOB:

Create table sbaj2to4clob (sid number(5), sname varchar2(15),
sage number(3), sfile clob);
How to insert text file into DataBase:
import java.io.FileReader;

try{
con =
if(con != null){
established");
}
else
established");
con.prepareStatement("insert into empclob values(?,?)");
File f = new File("MyFile");
FileReader fr = new FileReader(f);
System.out.println("enter eno ");
ps.setInt(1, eno);
ps.setCharacterStream(2, fr, (int)f.length());
int i = ps.executeUpdate();
System.out.println(i +" inserted");
}
catch(Exception e){
}
}
}
public static void main(String[] args)throws
ClassNotFoundException, SQLException,
IOException{
", "system","annie");
"insert into sbaj2_4c
values(?,?,?)");
boolean flag=true;
int totalrecords=0;
while(flag) {
System.out.println("how many text files
do you want to insert");
int nofiles = scan.nextInt();
for(int i=1;i<=nofiles;i++) {
System.out.println("enter student
id");
System.out.println("enter student
name");
System.out.println("enter file
path");
String filepath = scan.next();
File f = new File(filepath);
ps.setInt(1, sid);
ps.setCharacterStream(3,fr,
(int)f.length() );

totalrecords=totalrecords+count;
}
System.out.println("do you want insert
text file again if yes type y if no type n");
String choice = scan.next();
if(choice.equalsIgnoreCase("y")) {
flag = true;
}
else if(choice.equalsIgnoreCase("n")) {
flag = false;
}
}
System.out.println("you totaly insert
"+totalrecords+" records......");
}
}
How read the text file From Database:
To read textual file information from database we should follow the

Following steps:
a. Reading the data from db to ResultSet.
b. Reading file information form resultset to FileReader object.
c. Creating File and FileWriter object to create new textual
File.
d. Finally reading the data from FileReader and copied into
FileWriter.
import java.io.FileWriter;
import java.io.Reader;

try{
con =
if(con != null){
}
else
ResultSet rs = st.executeQuery("select * from empclob");
while(rs.next()){
Reader r = rs.getCharacterStream(2);
FileWriter fw = new FileWriter("ramfile.doc");
int i=0;
i=r.read();
while(i!=-1){
fw.write(i);
i=r.read();
}
fw.flush();
}
}
catch(Exception e){
}
}
}
Read the text files from database by using preparedstatement:
IOException{
/*Statement st = con.createStatement();
sbaj2_4c");*/
con.prepareStatement("select * from sbaj2_4c");
while(rs.next()) {
int sid = rs.getInt(1);
String sname = rs.getString(2);
FileWriter fw = new
FileWriter("C:\\Users\\Ramchandar\\Desktop\\"+sname+s
id+".txt");
int i=0;
while((i=r.read()) !=-1) {
fw.write(i);
fw.flush();
}
}
con.close();
}
}
How to specific file from table in jdbc:
IOException{
con.prepareStatement("select * from sbaj2_4c where
sid=?");
System.out.println("enter student id for
selecting the file");
int id = scan.nextInt();
ps.setInt(1, id);
while(rs.next()) {
int sid = rs.getInt(1);
String sname = rs.getString(2);
FileWriter fw = new
FileWriter("C:\\Users\\Ramchandar\\Desktop\\"+sname+s
id+".txt");
int i=0;
while((i=r.read()) !=-1) {
fw.write(i);
fw.flush();
}
}
con.close();
}
}
How to insert multiple file into database in jdbc:
package jdbc;
IOException{
", "system",
"manager");
con.prepareStatement("insert into course
values(?,?,?)");
System.out.println("How many records do you
want to insert");
int records = scan.nextInt();
int count = 0;
for(int i=1;i<=records;i++){
System.out.println("ENTER COURSE NAME");
String cname = scan.next();
System.out.println("ENTER FACULTY
NAME");
String fname = scan.next();
System.out.println("ENTER COURSE DETAILS
FILE PATH");
String cfpath = scan.next();
ps.setString(1,cname);
ps.setString(2, fname);
File f = new File(cfpath);
ps.setCharacterStream(3, fr,
(int)f.length());
count = count+ps.executeUpdate();
}
inserted");
}
}
How to work with Array type of data in JDBC:
create type mytype1 as VARRAY(3) of NUMBER;

/
Type created.
SQL> create table mytype1tab (eno number,marks mytype1);

Table created.
SQL> commit;
Commit complete.
SQL> insert into mytype1tab values(101,mytype1(11,22,33));

1 row created.
SQL> select * from mytype1tab;

ENO MARKS
101 MYTYPE1(11, 22, 33)
SQL> select * from mytype1tab;
ENO MARKS
101 MYTYPE1(11, 22, 33)
102 MYTYPE1(55, 66, 77)
Inserting array type of data in db in jdbc:
import java.sql.BatchUpdateException;
import ram.factory.ConnectionFactory;
public class Demo {
public static void main(String[] args) throws Exception {
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe"
,"system","manager");
int count = st.executeUpdate("insert into mytype1tab
values(102,mytype1(55,66,77))");
}
}
Reading the Array type of data from jdbc:

import java.sql.Array;
public class Demo {
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","system","manager")
;
ResultSet rs = st.executeQuery("select * from mytype1tab");
while(rs.next()){

Array arr = rs.getArray(2);
System.out.println("arr: "+arr);
ResultSet rs1 = arr.getResultSet();
while(rs1.next()){
System.out.println("arrr: "+rs1.getInt(2));
}
}
}
}
How to insert ARRAY type data db by using preaparedstatement:

public class Demo {

public static void main(String[] args) throws ClassNotFoundException, SQLException, IOException {
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","system","manager");
PreparedStatement ps = con.prepareStatement("insert into rt values(?,?)");
ps.setInt(1, 222);
oracle.sql.ArrayDescriptor ad = oracle.sql.ArrayDescriptor.createDescriptor("MYTYPE",
con);
//MYTYPE must be in capital letters.
oracle.sql.ARRAY a = new oracle.sql.ARRAY(ad, con, new Integer[]{11,22,33});
ps.setArray(2, a);
}
package jdbc;

Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localh
ost:1521:xe","system","manager");
"insert into sajtype values(?,?)");
System.out.println("Ener student
identification number");
ps.setInt(1, sid);
oracle.sql.ArrayDescriptor ad =
oracle.sql.ArrayDescriptor.createDescriptor("AJTYPE",
con);
int ia[] = new int[3];

System.out.println("enter student marks");
for(int i=0;i<3;i++){
ia[i] = scan.nextInt();
}
oracle.sql.ARRAY a = new oracle.sql.ARRAY(ad,
con, ia);
ps.setArray(2, a);
int count= ps.executeUpdate();
}
}
How to create object type data in oracle:
SQL> create type myobj as OBJECT (cityname varchar2(10),

statename varchar2(10));
/
Type created.
SQL> create table myobjtab (eno number,addr myobj);
Table created.
SQL> commit;
Commit complete.
SQL> insert into myobjtab values(101,myobj('hyd','tel'));
1 row created.
SQL> select * from myobjtab;
ENO ADDR(CITYNAME, STATENAME)

101 MYOBJ('hyd', 'tel')
How to insert object type of data in jdbc:
import java.sql.Array;
public class Demo {
Connection con =
;
int count = st.executeUpdate("insert into myobjtab
values(101,myobj('vizag','ap'))");
}
}
How to read object type of data from jdbc:

import java.sql.Struct;
public class Demo {
Connection con =
;
ResultSet rs = st.executeQuery("select * from myobjtab");
while(rs.next()){
int eno= rs.getInt(1);
Struct addr = (Struct) rs.getObject(2);
Object[] obj = addr.getAttributes();
for(Object obj1: obj){
System.out.println("obj1: "+obj1);
}
}
}
}
How to Create Connection Factory in JDBC:
import java.sql.Driver;
public class ConnectionFactory {
private Properties myProperties;
private Driver driver;
private String driverName;
private String url;
private String userName;
private String password;
private FileInputStream fis;
private static ConnectionFactory connectionFactory=null;
ConnectionFactory(){
try{
fis = new FileInputStream("MyProperties.properties");
myProperties = new Properties();
myProperties.load(fis);
driverName = myProperties.getProperty("driver");
driver = (Driver)Class.forName(driverName).newInstance();
url = myProperties.getProperty("url");
userName = myProperties.getProperty("user");
password = myProperties.getProperty("password");
throw new RuntimeException("problem in connection
development");
}
}
public static Connection getConnection() throws
SQLException{
if(connectionFactory == null)
connectionFactory = new ConnectionFactory();
return connectionFactory.driver.connect(connectionFactory.url,
connectionFactory.myProperties);
}
}
public class TestDemo {
public static void main(String[] s) throws SQLException{
Connection con = ConnectionFactory.getConnection();
if(con!=null){
}
else
ResultSet rs = st.executeQuery("select * from empram");
while(rs.next()){
System.out.println(rs.getInt("eno")
+"\t"+rs.getString("ename")+"\t"+rs.getInt("sal")
+"\t"+rs.getString("dept"));
}
}
}
Types Of ResultSet:
1. Forward ResultSet(TYPES_FORWARD_ONLY)
2. Scrollable ResultSet(
TYPES_SCROLL_SENSITIVE
TYPES_SCROLL_INSENSITIVE
)
3. Scrollable and Updateable ResultSet
(CONCUR_UPDATABLE).
4. Scrollable and Readonly Resultset(CONCUR_READ_ONLY).
TYPES_FORWARD_ONLY ResultSet is suitable for reading the data

from the table from top to bottom, but not suitable for reading the
data from the table from bottom to top.
The above statement not providing any information to Statement
object for creating particular ResultSet type.
So by statmenet object will creates forward only ResultSet.
If we want to read the from top to bottom as well as bottom to top,
we should go for either TYPES_SCROLL_SENSITIVE or
TYPES_SCROLL_INSENSITIVE result set.
TYPES_SCROLL_SENSITIVE ResultSet can have the capability to

know whether the database is updated or not where as
TYPES_SCROLL_INSENSITIVE ResultSet can’t have that capability.
How to create SCROLL_SENSITIVE ResultSet:

Statement st =
con.createStatement(ResulSet.TYPE_SCROLL_SENSITIVE)
How to create SCROLL_INSENSITIVE ResultSet:

Statement st =
con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE)
How to create Read only ResultSet:

Statement st =
con.createStatement(ResultSet.CONCUR_READ_ONLY);
How to create updateable ResultSet:

Statement st =
con.createStatement(ResultSet.CONCUR_UPDATEABLE);
Program on Sensitive ResultSet
Meanwhile of reading the data from table from java application, if

any modifications[update] happens, those modification are effected
or refelected to ResultSet, that type of resultset is called Sensitive
ResultSet otherwise we or consider as Insensitive ResultSet.
By default oracle thin driver not support, to work with this resultset
sensitive.
We should write column names instead of ‘*’.
We should write rs.refreshRow() in while loop.

public static void main(String[] s) throws
SQLException,
InterruptedException, ClassNotFoundException{
"jdbc:oracle:thin:@localhost:1521:xe","s
ystem","ram");
Statement st =
con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);
sid,sname,sage,scourse from sathyaaj11to01");
System.out.println("program under execution");
int cnt=0;
while(rs.next()){
rs.refreshRow();
if(cnt==0)
System.out.println(rs.getInt(1)+"\t"+rs.getString(2)+"\t
"+rs.getInt(3)+"\t"+rs.getString(4));
cnt++;
}
}
}
How to update row in database by Updatable ResultSet object:
With out using any update, delete, insert query we can able to place
the data into db server table by using UpdatableResultSet.
There are two ways to update the data in the table.

a. By using query.
Update sbaj2_4 set sname=’sailu’ where sno=102;
b. By using updateRow().
ResultSet object must be ResultSet.Concur.UPDATABLE

if(con!=null){
}
else
Statement st =
con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.
CONCUR_UPDATABLE);
eno,ename,sal,dept from empram");
while(rs.next()){
}
rs.first();
rs.updateInt(3, 2500);
rs.updateRow();
System.out.println("=======================");
rs.beforeFirst();
while(rs.next()){
}
}
}
From the java application if we want to update the data which is
available in database in two ways.
a. by writing bellow query
update sbajemp set esal=5000 where eid=104;
b. by using updateInt(-,-).
updateInt(-,-) logic itself generate query for updating the data
in db.
Whenever we use updateInt(-,-) for updating done use * symbol for

reading the data
Like select * from sbajemp (invalid)
We need to write the following manner
Select eid,ename,esal,dept from sbajemp;
How to print the data from database in both direction by using

ResultSet Object:

if(con!=null){
}
else
Statement st =
CONCUR_READ_ONLY);
while(rs.next()){
}
System.out.println("==========================");
while(rs.previous()){
}
}
}
Whenever we use relative(), first we need to check whether

ResultSet object cursor position, the cursor shouldn’t in beforeFirst
and afterLast position.

if(con!=null){
}
else
Statement st =
CONCUR_READ_ONLY);
while(rs.next()){
}
}
rs.first();
rs.relative(2);
rs.last();
rs.relative(-1);
}
}
WHENEVER WE WORKING WITH UPDATEABLE RESULTSET DON’T
USE ‘*’ SYMBOL, WE MUST AND SHOULD USE COLUMN NAMES,
ORDER OF THE COLUMNS ARE VERY MUCH IMPORTANT TO UPDATE
AND INSERT THE RECORDS IN DB SERVER TABLE.
How to delete the record from database by using Updateable

ResultSet object:
We can delete the data from database from our java application in
two ways.
a. By using following query.
Delete from sbajemp where eid = 107;
b. By using deleteRow().
deleteRow() itself writing the query for delete record from
db.
For reading purpose don’t we use * symbol, we need to write

column names.

if(con!=null){
}
else
Statement st =
CONCUR_UPDATABLE);
while(rs.next()){
}
}
rs.first();
rs.relative(2);
rs.last();
rs.relative(-1);
rs.last();
rs.deleteRow();
rs.beforeFirst();
while(rs.next()){
}
}
}
How to insert the record into database by using ResultSet Object:
we can insert record into database in two ways from our java
applicaton.
a. By using the following query
Insert into sbajemp values(103,’uma’,9500,’hr’);
b. By using insertRow().

if(con!=null){
}
else
Statement st =
CONCUR_UPDATABLE);
while(rs.next()){
}
}
rs.first();
rs.relative(2);
rs.last();
rs.relative(-1);
rs.last();
rs.deleteRow();
rs.beforeFirst();
while(rs.next()){
}
rs.moveToInsertRow();//not writing this statement
we //will get exception no current row
rs.updateString(2, "pritam");
rs.updateString(4, "faculty");
rs.insertRow();
rs.beforeFirst();
while(rs.next()){
}
}
}
Write a program on updatableResultSet for updating all employee

salaries with dynamic values:
package jdbc;
Statement st =
con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet rs =
st.executeQuery("select eno,ename,esal,deptno from
sbaj6to8");
while(rs.next()){
System.out.println(rs.getInt(1)+"\t"+rs.getString(2)+"\t"+
rs.getInt(3)+"\t"+rs.getInt(4));
}
System.out.println("------------------");
rs.beforeFirst();
while(rs.next()){
System.out.println("update "+rs.getInt(1)+" employee
salary");
int salary = scan.nextInt();
rs.updateInt(3, salary);
rs.updateRow();
}
rs.beforeFirst();
while(rs.next()){
}
con.close();
System.out.println("program completed");
}
}
How to update date data by using updatable result set:

package jdbc;
",
Statement st =
con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE
,
sid,sname,jd from stddate");
while(rs.next()){
System.out.println(rs.getInt(1)+"\t"+rs.getString(2)+
"\t"+
rs.getDate(3));
}
System.out.println("---------------------");
/*java.util.Date d = new java.util.Date();
java.sql.Date sd = new
java.sql.Date(d.getTime());*/
System.out.println("enter day");
int day = scan.nextInt();
System.out.println("enter month");
int month= scan.nextInt();
System.out.println("enter year");
int year = scan.nextInt();
java.sql.Date(year,month,day);
rs.beforeFirst();
rs.next();
rs.updateString(2, "ram");
rs.updateDate(3, sd);
rs.updateRow();
rs.beforeFirst();
while(rs.next()){
"\t"+
rs.getDate(3));
}
con.close();
}
}
Methods in ResultSet (updateable):
Statement st =
con.createStatement(
ResultSet.TYPE_SCROLL_SENSITIVE,
ResutlSet.CONCUR_UPDATABLE);
ResultSet rs = st.executeQuery
("select eid,ename,esal,dept from sbajemp");
rs.last() : cursor pointing to last record of the table.
rs.first() : cursor pointing to first record of the table.
rs.next() : forward the controle from non-record area to
record area.
rs.beforeFirst(): cursor is pointing to non-record area
which is avilable before first record.
rs.afterLast() : cursor is pointing to non-record area
which is avilable after last record.
rs.moveToInsertRow(): it is used for move our cursor for
inserting new record.
rs.insertRow(): used to place the record into table.
rs.updateXxx(): used to update old data with new data.
rs.deleteRow(): used to delete the record from the table.
rs.isClosed():
rs.close():
rs.isAfterLast():
rs.isBeforeFirst():
rs.isFirst():
rs.isLast():
rs.relative();
rs.absolute()
What is the difference between abosolute(-) and relative(-):
Whenever we use absolute(-) no need to bother about cursor

current position, but if we want interact with relative(-) method our
should be poiting to any one of the record in the table.
relative(-) always moving forward and backward from the current
record where as absolute(-) always moving from either top to
bottom or bottom to top of the table.
There is one common point between absolute(-) and relative(-) that
is if record is not avialble in given location both the methods raises
exhausted ResultSet.

ClassNotFoundException,SQLException{
Connection con =
DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe"
,
"system","annie");
Statement st =
con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
System.out.println("SID\tSNAME\tSAGE\tSFEE");
sbaj2to4");
rs.first();
rs.beforeFirst();
/*System.out.println(rs.getInt(1)+"\t"+rs.getString
(2)+"\t"+
rs.getInt(3)+"\t"+rs.getInt(4));//
Exhausted Resultset
*/
System.out.println(rs.isBeforeFirst());//true
rs.last();
rs.afterLast();
/*System.out.println(rs.getInt(1)+"\t"+rs.getString
(2)+"\t"+
rs.getInt(3)+"\t"+rs.getInt(4));// Exhausted
Resultset
*/
System.out.println(rs.isAfterLast());//true
rs.first();
System.out.println("-----"+rs.isFirst());
rs.last();
System.out.println("======"+rs.isLast());
rs.relative(-3);
/*rs.relative(4);
rs.getInt(3)+"\t"+rs.getInt(4));//exhausted ResultSet
*/
rs.absolute(-3);
rs.absolute(3);
rs.afterLast();
rs.absolute(3);
rs.afterLast();
/*rs.relative(-2);
rs.getInt(3)+"\t"+rs.getInt(4));*/
rs.last();
rs.relative(-2);
rs.beforeFirst();
rs.absolute(7);
System.out.println(rs.isClosed());//false
con.close();
System.out.println(rs.isClosed());//true
}
}
DataBaseMetaData:
It is one JDBC API object, used for getting the details about
database name, version, driver name, version, database username,
URL etc…..
We can develop this object by using Connection object.

try{
con =
if(con != null){
established");
}
else
established");
DatabaseMetaData dbmd = con.getMetaData();
System.out.println(dbmd.getDatabaseProductName());
System.out.println(dbmd.getDatabaseProductVersion());
System.out.println(dbmd.getDatabaseMajorVersion());
System.out.println(dbmd.getDatabaseMinorVersion());
System.out.println(dbmd.getUserName());
System.out.println(dbmd.getDriverName());
System.out.println(dbmd.getDriverVersion());
}
catch(Exception e){
}
}
}
Connection Pooling:
As we know that opening and closing connection to data base
is very costlier job and it requires more resources and time
consume.
This is will effect to performance of the system.
As a programmer, we want to reduce the number of hits to data

base for opening and closing the connection.
Connection Pool:
It is a collection of database connections managed to be

available for application objects.
The system, which manages this set of connections objects is

known as Connection pool Manager.
To develop connection pooling we required jdbc 2.0 api.
It includes on abstraction, in the form of one abstraction in the form
javax.sql.DataSource to
getConnection() of Database allows us to collect the

Connection from connection pool through connection pool manager.
This connection object obtained by the application in the case

is a logical connection.
import javax.sql.PooledConnection;
import oracle.jdbc.pool.OracleConnectionPoolDataSource;

SQLException{
//Creating Connection Pool Manager
OracleConnectionPoolDataSource ocp = new
OracleConnectionPoolDataSource();
//Setting properties to pool manager to create db connections
//Driver name not required the reason is
//OracleConnectionPoolDataSource is designed for OracleDriver
ocp.setURL("jdbc:oracle:thin:@localhost:1521:xe");
ocp.setUser("system");
ocp.setPassword("manager");
//getting the pooled connection

PooledConnection pc = ocp.getPooledConnection();
//get the logical connection

Connection con = pc.getConnection();
ResultSet rs = st.executeQuery("select * from empn");
while(rs.next()){
System.out.println(rs.getInt(1)+"...."+rs.getString(2));
}
}
}
Programmatic proof about connection pooling:
MyPooledManager.java:
public class MyPooledManager {

public static OracleConnectionPoolDataSource getManager()
OracleConnectionPoolDataSource ocp = new
OracleConnectionPoolDataSource();
ocp.setURL("jdbc:oracle:thin:@localhost:1521:xe");
ocp.setUser("system");
ocp.setPassword("manager");
return ocp;
}
JdbcDemo1.java:

public static void main(String[] args) throws SQLException{
OracleConnectionPoolDataSource ocp =
MyPooledManager.getManager();
PooledConnection pc = ocp.getPooledConnection();
System.out.println("jdbcdemo1- con: "+con.hashCode());
ResultSet rs = st.executeQuery("select * from sbaj6to8");
while(rs.next()){
System.out.print(rs.getInt(1)+" ");
System.out.print(rs.getString(2)+" ");
}
System.out.println("====================");
JdbcDemo2.getMyConnection(pc);
}
}
JdbcDemo2.java:

public static void getMyConnection(PooledConnection pc)
System.out.println("jdbcdemo2- con: "+con.hashCode());
ResultSet rs = st.executeQuery("select * from sbaj6to8");
while(rs.next()){
}
}
}
How to communicate with mysql database:
If we want to communicate with different databases from our

application we required multiple logics.
These logics are different from one database to another database.
So java is not providing the logics to communicating with databases.
Database vendors itself provides logic to communicating or provides
services to java.
But database vendors not using their own specification, all database
vendors must be followed by the specifications which are given by
the java.
Following the specification is nothing but provides the logic or

implementation.
Database vendors provides the logic or implementation in the form
of jar files like bellow
Oracle Vendors provides the following driver like:
ojdbc6.jar:
---------------
Driverracle.jdbc.driver.OracleDriver
url:  jdbc:oracle:thin:@localhost:1521:xe
username system
password  manger
mysql-connector.jar
-----------------------------
Drivercom.mysql.jdbc.Driver
url jdbc:mysql://localhost:3306/ram
username:root
password: root
To work with mysql database we need to the following steps:
1. First install mysql database in our machine.

2. Set classpath with mysql-connector.jar file
3. Create our own database in mysql.
4. Use our own database
5. Create table to do the curd operations.
6. Developing program jdbc program.
How create our own database in mysql:
Syntax: Create database database_name;
Create database ram;
How to use our own database:
Syntax: use database_name;
use ram;
How to create table in mysql:
Create table mytab(eno int(5) , ename varchar(10));

Commit;
How to insert the data into our own table:
Insert into mytab values(101, ‘ram’);
public class JDBCDemoProg1 {

Class.forName("com.mysql.jdbc.Driver");
Connection con =
DriverManager.getConnection("jdbc:mysql://localhost:3306/ram1",
"root","root");
if(con != null){
}
else
ResultSet rs = st.executeQuery("select * from mytab");
while(rs.next()){
}
int i = st.executeUpdate("insert into mytab

values(102,'varun')");
System.out.println("i: "+i);
con.close();
}
}
How work with both the database from the same program with
different table names:
public class Demo {
SQLException{
System.out.println("enter your driver name");
String driverName = scan.next();
System.out.println("enter your db url");
String url = scan.next();
System.out.println("enter your db username");
String username = scan.next();
System.out.println("enter your db password");
String password = scan.next();
System.out.println("");
Class.forName(driverName);
url,username,password);
if(driverName.equals("oracle.jdbc.driver.OracleDriver
")){
ResultSet rs = st.executeQuery("select *
from sbaj6to8");
while(rs.next()){
+"\t"+rs.getInt(4)+"\t"+rs.getInt(4));
}
}
else{
stdtable");
while(rs.next()){
System.out.println(rs.getInt(1)+"\t"+rs.getString(2))
;
}
}
}
}
How work with both the database from the same program:
public class Demo {
public static void main(String[] s)
System.out.println("enter driver name");
String driver = scan.next();
System.out.println("enter url");
String url = scan.next();
System.out.println("enter username");
String user = scan.next();
System.out.println("enter password");
String password = scan.next();
Connection con =
sbajtab");
System.out.println("SID\tSNAME\tSAGE");
while(rs.next()){
}
}
}
How to communicating multiple databases by using same java

application and .properties files:
Oracledb.properties:
driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@localhost:1521:xe
username=system
password=annie
mysqldb.properties:
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/sbaj9to11
username=root
password=root
JdbcDemo.java:
//How to communicating with multiple databases and
table for fetching the data, from our java appn by
using .properties:
throws ClassNotFoundException, SQLException,
IOException{
System.out.println("which database do you
required to"
+ " communicate\n1.Oracle
2.Mysql");
int dbtype = scan.nextInt();
switch(dbtype) {
case 1: FileInputStream fis =
new
FileInputStream("src/oracledb.properties");
p.load(fis);//read datafrom fis in
the form key-value
String driver =
p.getProperty("driver");
String user =
p.getProperty("username");
String password =
p.getProperty("password");
Connection con =
Statement st =
con.createStatement();
System.out.println("st : "+st);
ResultSet rs =
st.executeQuery("select *
from sbaj9to11");
while(rs.next()) {
"\t"+
}
break;
case 2: FileInputStream fis1 =
new
FileInputStream("src/mysqldb.properties");
Properties p1 = new Properties();
p1.load(fis1);//read datafrom fis in
the form key-value
String driver1 =
p1.getProperty("driver");
String url1 = p1.getProperty("url");

String user1 =
p1.getProperty("username");
String password1 =
p1.getProperty("password");
Class.forName(driver1);
Connection con1 =
DriverManager.getConnection(url1,user1,password1);
Statement st1 =
con1.createStatement();
System.out.println("con1: "+con1);
System.out.println("st1 : "+st1);
ResultSet rs1 =
st1.executeQuery("select *
from stdtab");
System.out.println("rs1: "+rs1);
while(rs1.next()) {
System.out.println(rs1.getInt(1)+"\t"+rs1.getString(2
));
}
}
}
}
In the above we are writing lot of duplicate or
boilerplate of code. To avoiding that problem we
should the bellow code.
Oracledb.properties:
username=system
password=annie
mysqldb.properties:
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/sbaj9to11
username=root
password=root
JdbcDemo.java
//How to communicating with multiple databases and
table
// for fetching the data, from our java appn:
throws ClassNotFoundException, SQLException,
IOException{
System.out.println("which database do you
required to"
+ " communicate\n1.Oracle
2.Mysql");
int dbtype = scan.nextInt();
FileInputStream fis = null;
if(dbtype == 1) {
fis = new
FileInputStream("src/oracledb.properties");
}
else if(dbtype==2) {
fis = new
FileInputStream("src/mysqldb.properties");
}
p.load(fis);//read datafrom fis in the form
key-value
String user = p.getProperty("username");
Connection con =
System.out.println("st : "+st);
switch(dbtype) {
case 1: ResultSet rs=st.executeQuery("select
* from sbaj9to11");
while(rs.next()) {
"\t"+
}
break;
case 2: ResultSet rs1
=st.executeQuery("select * from stdtab");
System.out.println("rs1: "+rs1);
while(rs1.next()) {
System.out.println(rs1.getInt(1)+"\t"+rs1.getString(2
));
}
}
}
}
How insert Date related information int database:
Create table in database like bellow.
create table sbajkit(sno number(5), sname varchar2(15),sage

number(3),jd Date);
QueryDemo.java:
package kit.aj.date;
public class QueryDemo {

static final String INSERTQUERY = "insert into sbajkit values(?,?,?,?)";
}
In the bellow program we create Date object of util package and
collect the current system date and timings by using following code
Java.util.Date d1 = new java.util.Date();
Later we convert this information into one long value like
d1.getTime();
Later we are creating Date object of sql package and sending this
long value to constructor of Date class of sql package.
This constructor will convert that entire value into the following
format
“year-month-date”.
How to insert date data in oracle database by Statement Object:
package jdbc;
import java.text.SimpleDateFormat;
import java.util.Date;
"jdbc:oracle:thin:@localhost:1521:XE","system","manager");
//Date d = new Date("01/01/2000");
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("dd/MMM/YY");
String s =sdf.format(d);
System.out.println(s);
/*int count =
st.executeUpdate("insert into stddate values(104,'ram','01-jan-
2000')");*/
int count =
st.executeUpdate("insert into stddate values(104,'ram','"+s+"')");
}
}
JdbcDateDemo:
public class JdbcDateDemo {

PreparedStatement ps = con.prepareStatement(QueryDemo.INSERTQUERY);
System.out.println("enter student Name");

System.out.println("enter student age:");

java.util.Date d1 = new java.util.Date();

System.out.println(d1);
java.sql.Date d2 = new java.sql.Date(d1.getTime());
ps.setInt(1,sno);
ps.setInt(3, sage);
ps.setDate(4, d2);
int updatecount = ps.executeUpdate();
System.out.println("updatecount: "+updatecount);
}
}
package jdbc;

","system","manager");
boolean b = st.execute(
"create table emptable (eid number, ename
varchar2(15),ejd date)");
System.out.println("table created: "+b);
"insert into emptable
values(?,?,?)");
int eid = scan.nextInt();
ps.setInt(1, eid);
java.sql.Date(d.getTime());
ps.setDate(3, sd);
}
}
import java.sql.Date;
public class JdbcDateDemo {
con.prepareStatement(QueryDemo.INSERTQUERY);

System.out.println("enter student Name");

System.out.println("enter student age:");

byte month = scan.nextByte();
byte day = scan.nextByte();
Date d2 = new Date(year,month,day);
ps.setInt(1,sno);
ps.setInt(3, sage);
ps.setDate(4, d2);
System.out.println("updatecount: "+updatecount);
}
}
Date d2 = new Date(year,month,day);
Whenever we with above statement we need follow this rule
that is
actual year - 1900.
for example if we want enter 1997, we need to enter 97.
the reason whenever we enter year internally the above constructor
add 1900 for the given year.
//How to insert date data into table by using

java.text.SimpleDateFormat class
package com.ram;
import java.text.ParseException;
public class JdbcDemo{
ParseException{
"system","annie");
String s = "12-12-1987";
SimpleDateFormat sdf = new
SimpleDateFormat("dd-MM-yyyy");
java.util.Date ud = sdf.parse(s);
java.sql.Date sd = new java.sql.Date(ud.getTime());
"insert into stddate values(?,?,?)");
ps.setInt(1, sid);
ps.setDate(3, sd);
}
}
In the above “yyyy” should be in small case.
How to insert multiple date data into table dynamically by using

java.text.SimpleDateFormat class
package com.ram;
ParseException{
"system","annie");
con.prepareStatement(
System.out.println("How many records do you want
insert");
int records = scan.nextInt();
for(int i=1;i<=records;i++) {
int month = scan.nextInt();
int day = scan.nextInt();
String s = day+"-"+month+"-"+year;
SimpleDateFormat sdf = new

SimpleDateFormat("dd-MM-yyyy");
java.util.Date ud = sdf.parse(s);
java.sql.Date sd = new java.sql.Date(ud.getTime());

ps.setInt(1, sid);
ps.setDate(3, sd);
}
}
}
In the abogve SimpleDateFormat constructor pattern String patten
should be matched like bellow other wise we will get
ParseException.
Valid combination:
SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
Invalid Combination:
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
package com.ram;
ParseException{
"jdbc:oracle:thin:@localhost:1521:xe","sy
stem","annie");
String s = "2015-5-5";
java.sql.Date sd = java.sql.Date.valueOf(s);
ps.setInt(1, sid);
ps.setDate(3, sd);
}
}
Drawbacks of ResultSet:
a.It is not extends java.io.Serializable interface.
b.Ihis object unable to travel throughout the
network.
c.By default ResultSet is forward and read only
mode.
d.If we want make our ResultSet as updateable and
scrollable programmer itself declare ResultSet
mode.
e.If we want to work ResultSet programmer should
create Connection and Statement objects.
f.It is not developed on top Bean Mechanizam (No
setters and getters).
RowSet:
JdbcRowSet:
1. It is connected rowset.
2. Whenever we work with JdbcRowSet the database
connection should be in connective mode.
3. It is implements java.io.Serializable interface.
4. It can travel throught the networks.
5. By default it is scorable and read only and updatebale also.
6. It will having one implementation class which is given by the
Oracle db server that is OralceJdbcRowSet.
import oracle.jdbc.rowset.OracleJDBCRowSet;
public class Check {
OracleJDBCRowSet jrs = new OracleJDBCRowSet();
jrs.setUrl("jdbc:oracle:thin:@localhost:1521:xe");
jrs.setUsername("system");
jrs.setPassword("manager");
jrs.setCommand("select * from sbaj11to01");
jrs.execute();
while(jrs.next()){
System.out.println(jrs.getInt(1)+"\t"+
jrs.getString(2)+"\t"+jrs.getInt(3)+"\t"+jrs.getInt(4)
+"\t"+jrs.getString(5));
}
System.out.println("----------------------");
while(jrs.previous()){
System.out.println(jrs.getInt(1)+"\t"+
jrs.getString(2)+"\t"+jrs.getInt(3)+"\t"+jrs.getInt(4)
+"\t"+jrs.getString(5));
}
}
}
package jdbc;
import java.sql.ParameterMetaData;
import javax.sql.rowset.JdbcRowSet;
import javax.sql.rowset.RowSetProvider;

Exception{
// Class.forName("oracle.jdbc.driver.OracleDriver");
//JdbcRowSet js = new OracleJDBCRowSet();
JdbcRowSet js =
RowSetProvider.newFactory().createJdbcRowSet();
js.setUrl("jdbc:oracle:thin:@localhost:1521:xe");
js.setUsername("system");
js.setPassword("manager");
js.setCommand("insert into sbaj4to6
values(102,'sam',2000)");
js.execute();
}
}
Program on JdbcRowSet with dynamic values with
Scanner class:

throws SQLException, ClassNotFoundException{
//JdbcRowSet js =
/*RowSetFactory rf =
RowSetProvider.newFactory();
JdbcRowSet js = rf.createJdbcRowSet();
*/
OracleJDBCRowSet oc = new OracleJDBCRowSet();
oc.setUrl("jdbc:oracle:thin:@localhost:1521:xe");
oc.setUsername("system");
oc.setPassword("manager");
oc.setCommand("insert into sbaj6to8
values(?,?,?,?)");
System.out.println("enter some employee id");
System.out.println("enter some employee
name");
sal");
deptno");
int deptno = scan.nextInt();
oc.setInt(1, eno);
oc.setString(2, ename);
oc.setInt(3, esal);
oc.setInt(4, deptno);
oc.execute();
}
}
Program on JdbcRowSet with dynamic values with out
Scanner class:
package jdbc;
public class JdbcDemo1{

SQLException,
/*RowSetFactory rf =
RowSetProvider.newFactory();
JdbcRowSet js = rf.createJdbcRowSet();*/
//JdbcRowSet js =
OracleJDBCRowSet js = new OracleJDBCRowSet();

js.setCommand("update sbaj6to8 set deptno=? where

eno=?");
js.setInt(1, 555);
js.setInt(2, 101);
js.execute();
System.out.println("--------------------");
}
}
Program jdbcRowSet for Select query:
package jdbc;
SQLException{
OracleJDBCRowSet oc=
new OracleJDBCRowSet();
oc.setCommand("select * from sbaj6to8");
oc.execute();
while(oc.next()){
System.out.println(oc.getInt(1)+"\t"+oc.getString(2)+
"\t"+oc.getInt(3)+"\t"+oc.getInt(4));
}
}
}
Program on JdbcRowSet for update the data:
package jdbc;
import oracle.jdbc.
rowset.OracleJDBCRowSet;
SQLException{
OracleJDBCRowSet oc=
new OracleJDBCRowSet();
oc.setCommand("update sbaj6to8 set esal=5000 where
eno=101");
oc.execute();
System.out.println("====================");
}
}
How to insert records into database table without
using query by using JdbcRowSet:
JdbcRowSet js =
js.setPassword("annie");
js.setCommand("select sid,sname,sage,sfee from
sbaj4to6");
js.execute();
while(js.next()){
System.out.println(js.getInt(1)+"\t"+js.getString(2)+"\t"
+js.getInt(3)+"\t"+js.getInt(4));
}
js.moveToInsertRow();
js.updateInt(1, 203);
js.updateString(2, "akhil3");
js.insertRow();
js.moveToCurrentRow();
}
}
How to update data in the database table by using
JdbcRowset:
JdbcRowSet js =
js.setCommand("select sid,sname,sage,sfee from sbaj4to6
where sid=101");
js.execute();
js.next();
js.updateRow();
}
}
How to delete data from database table with

jdbcrowset:
JdbcRowSet js =
js.setCommand("select sid,sname,sage,sfee from sbaj4to6
where sid=101");
js.execute();
js.next();
js.deleteRow();
}
}
CachedRowSet:
It is disconnected rowset.
Without database physical connection we can populate

cachedrowset with data, whenever our application
interact with database, that data will effected to
database table.
By default its readonly, scrollable, updateble.
Whenever we inserting data into table we should write

two extra methods, those are
moveToInsertRow()
insertRow()
moveToCurrentRow()
acceptChanges()
Whenver we delete row from table we should write
extra method like
deleteRow()
acceptChanges()
Whenver we update row from table we should write
extra method like
updateRow()
acceptChanges()
package jdbc;
import javax.sql.rowset.CachedRowSet;
import oracle.jdbc.rowset.OracleCachedRowSet;

Exception{
CachedRowSet js =
RowSetProvider.newFactory().createCachedRowSet();
js.setCommand("insert into sbaj4to6
values(103,'mani',3000)");
js.execute();
}
}
Program on cachedrowset for reading the data:
package jdbc;

Exception{
CachedRowSet js =
js.setCommand("select * from sbaj6to8");
js.execute();
while(js.next()){
System.out.println(js.getInt(1)+"\t"+js.getString(2)+
"\t"
+js.getInt(3)+"\t"+js.getInt(4));
}
}
}
Program on cachedrowset for inserting records without using query:
package jdbc;
import javax.sql.RowSetMetaData;

CachedRowSet js =
/*js.setCommand("select eno,ename,esal,deptno from
sbaj6to8");*/
js.setCommand(“select * from sbaj6to8”);
js.execute();
js.next();
System.out.println("-------------");
js.moveToInsertRow();
js.updateString(2, "akhil");
js.insertRow();
js.moveToCurrentRow();
js.acceptChanges();
/*RowSetMetaData rmd =
(RowSetMetaData)js.getMetaData();
System.out.println(rmd.getColumnCount());
System.out.println(rmd.getColumnLabel(1));
System.out.println(rmd.getColumnClassName(1));*/
}
}
Program cachedrowset for update the record without using query:

package jdbc;

CachedRowSet js =
js.setCommand("select eno,ename,esal,deptno from
sbaj6to8 where eno=101");
js.execute();
js.next();
js.updateRow();
js.acceptChanges();
}
}
Program on cached rowset for deleting row without using query:

package jdbc;

CachedRowSet js =
js.setCommand("select eno,ename,esal,deptno from
sbaj6to8");
js.execute();
js.next();
js.relative(2);
js.deleteRow();
js.acceptChanges();
System.out.println("--------------------");
}
}
Whenever we working with UpdateableResulstSet in select query we

need to write column name individually, but don’t use “*” symbol.
But whenever we working with CachedRowSet, we can able to write
both individual column name and “*” symbol.
WebRowSet:
It is mainly design for working web applications.
If we want place database table recods into xml file(write records
information into xml) and if we want read records form xml file, then
we should use WebRowSet.
package jdbc;
import oracle.jdbc.rowset.OracleWebRowSet;
Exception{
OracleWebRowSet js = new OracleWebRowSet();
js.setCommand("select * from sbaj4to6");
js.execute();
File f = new File("D:\\jsp\\jdbc\\ors.xml");

FileWriter fw = new FileWriter(f);
js.writeXml(fw);
StringWriter sw = new StringWriter();
js.writeXml(sw);
System.out.println(sw.toString());
fw.flush();
}
}
JoinRowSet:
This rowset will helps us to join the records of two table

into a single record based on some condition[column].
To work with this rowset we should first take the support

of CachedRowSet .
Steps to work with JoinRowSet:
1.Create object for CachedRowSet.

2.Provies database details(url,username,password)
to CachedRowset.
3.Add query to select the data
4.Add mached column for joins records of tables.
5.Create one more object of CachedRowSet.
6.Provies database details(url,username,password)
to CachedRowset.
7.Add query to select the data
8.Add mached column for joins records of tables.
9.Create object for JoinRowset.
10. Finallly add above two CachedRowSet to
JoinRowSet.....
SQL> create table student(sid number(5),sname

varchar2(15),
sage number(5),sfee number(5),scourse
varchar2(15));
SQL> insert into student
values(101,'ram',30,5000,'datascience');
values(102,'sam',35,6000,'devopps');
values(103,'varun',25,4000,'digmar');
SQL> create table marks(sid number(5),sname

varchar2(15),
cj number(3),aj number(3),oracle number(3));
SQL> insert into marks values(101,'raj',50,50,50);
SQL> insert into marks values(102,'sam',60,60,60);
SQL> insert into marks values(103,'vani',80,80,80);
SQL> commit;
import oracle.jdbc.rowset.OracleJoinRowSet;

Exception{
OracleCachedRowSet crs1= new
OracleCachedRowSet();
crs1.setUrl("jdbc:oracle:thin:@localhost:1521:xe");
crs1.setUsername("system");
crs1.setPassword("ram");
crs1.setCommand("select
sid,sname,sage,sfee,scourse from student");
crs1.setMatchColumn(2);
crs1.execute();

crs2.setPassword("ram");
crs2.setCommand("select
sid,sname,cj,aj,oracle from marks");
crs2.execute();
OracleJoinRowSet rs = new OracleJoinRowSet();
rs.addRowSet(crs1);
rs.addRowSet(crs2);
while(rs.next()){
}
}
}
The data which is available in JoinRowSet that is
always in the form of String only, no need represent
datatype for reading separately.
package jdbc;
import oracle.jdbc.rowset.OracleJoinRowSet;

Exception{
crs1.setPassword("abc");
crs1.setCommand("select eno,ename,esal from
sbaj6to8");
crs1.execute();

crs2.setPassword("abc");
crs2.setCommand("select sno,sname,sfee from
sbaj4to6");
crs2.execute();
OracleJoinRowSet rs = new OracleJoinRowSet();
rs.addRowSet(crs1);
rs.addRowSet(crs2);
while(rs.next()){
//System.out.println(rs.getString(6));
}
}
}
Program on FilteredRowSet with

javax.sql.rowset.Predicate interface:
import javax.sql.RowSet;
import javax.sql.rowset.Predicate;
import oracle.jdbc.rowset.OracleFilteredRowSet;
class Filter1 implements Predicate{
private String colName;
public Filter1 (String colName){
this.colName=colName;
}
@Override
public boolean evaluate(RowSet rs) {
System.out.println("evaluate method");
try{
CachedRowSet crs = (CachedRowSet)rs;
String object = crs.getString(colName);
if(object!=null &&
(object.charAt(0)=='R')||(object.charAt(0)=='r')){
return true;
}
else return false;
}
return false;
}
@Override
public boolean evaluate(Object value, int column)
throws SQLException {
// TODO Auto-generated method stub
return false;
}
@Override
public boolean evaluate(Object value, String
columnName) throws SQLException {
// TODO Auto-generated method stub
return false;
}
}
Class.
forName("oracle.jdbc.driver.OracleDriver");
OracleFilteredRowSet oc = new OracleFilteredRowSet();
oc.setCommand("select * from sbaj6to8");
oc.setFilter(new Filter1("ename"));
oc.execute();
while(oc.next()){
System.out.println(oc.getInt(1)+"
"+oc.getString(2)+" "+oc.getInt(3));
}
}
}
ResourceBundle in JDBC:
ResourceBundle is on predefine abstract class available in java.util

package.
We can’t object for ResourceBundle class directly.
We should go for factory method like getBundle(-).
getBundle(-) alllws String value. This string value belongs to file
name. Here don’t write file extention. The reason ResourceBundle
itself add extention like “.properties” to our file name.
for example if our file is
“db.properties”  we need to write “db” only. (Mandatory)
Db.properties:
username=system
password=abc
package jdbc;
import java.util.ResourceBundle;

IOException,SQLException{
/*FileInputStream fis = new
FileInputStream("src/db.properties");
p.load(fis);
String username = p.getProperty("username");
Connection con =
DriverManager.getConnection(url,username,password);
System.out.println("con: "+con);*/
ResourceBundle rd =
ResourceBundle.getBundle("db");
String driver = rd.getString("driver");
String url = rd.getString("url");
String username = rd.getString("username");
String password = rd.getString("password");
Connection con =
System.out.println("================");
}
}
WITHOUT TRY AND CATCH:

public class FirstJdbcDemo{

throws IOException{
FileWriter fw = new FileWriter("myfile.txt");
fw.write("dad");
fw.write(32);
fw.write(new char[] {'m','o','m'});
fw.flush();
fw.close();
System.out.println("---------------");
}
}
WITH TRY AND CATCH

FileWriter fw =null;
try {
fw = new FileWriter("myfile.txt");
fw.write("mom");
fw.write(32);
fw.write(new char[] {'d','a','d'});
fw.flush();
}
catch(IOException e) {
}
finally {
if(fw!=null) {
try {
fw.close();
} catch (IOException e) {
}
}
}
}
}
WITH TRY WITH RESOURCE --> FILES

IOException {
try(FileWriter fw = new
FileWriter("myfile1.txt");) {
fw.write("java");
fw.write(32);
fw.write("ram");
fw.flush();
}
}
}
================================
import java.io.BufferedWriter;

IOException {
try(
FileWriter fw = new
FileWriter("myfile2.txt");
BufferedWriter bw = new
BufferedWriter(fw)
) {
bw.write("java");
bw.write(32);
bw.write("ram");
bw.flush();
}
}
}
WITH TRY WITH RESOURCE --> DATABASE
SQLException {
try(
"jdbc:oracle:thin:@localhost:1521:xe","system","annie
");
sbaj4to6");
){
while(rs.next()) {
System.out.println(rs.getInt(1)+"\t"+
rs.getString(2)+"\t"+
}
}
}
}
TRY WITH RESOURCE ON DATABASE ADVANCED PROGRAM
import java.sql.*;
public class Test{
"jdbc:oracle:thin:@localhost:1521:xe", "system","manager"
);
Statement st = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet rs =st.executeQuery("select * from sbaj6to8");
try(con;st;rs){
while(rs.next()){
rs.getInt(3)+"\t"+rs.getInt(4)+"\t"+rs.getString(5));
}//while
}//try with resource
/* try {
}
*/
/* try {
ResultSet rs1 = st.executeQuery("select * from sbaj6to8");
*/
try {
while(rs.next()){
+"\t"+rs.getInt(3)+"\t"+rs.getInt(4)+"\t"+
rs.getString(5));
}
}
} //main
}//class
Q) Once we close Connection are we able to work with its
related Statement and ResultSet objects or not?
A) No. The reason once we close connection object then
automatically its related Statement and ResultSet objects are
also closed.
import java.sql.*;
public class Test {
ResultSet rs = null;
try{
st = con.createStatement(
ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE
);
rs = st.executeQuery("select * from sbaj6to8");
while(rs.next()){
rs.getInt(3)+"\t"+rs.getInt(4)+"\t"+rs.getString(5));
}
}
}
finally{
try {
System.out.println("our connection successfully closed");
con.close();
System.out.println("finally catch block");
}
}
/*System.out.println(
"How to find whether connection was closed or not");
try {
}*/
/*try {
rs.first();
// TODO Auto-generated catch block
}*/
try {
ResultSet rs1 = st.executeQuery("select * from
sbaj6to8");
// TODO Auto-generated catch block
}
}
}
How to work with JavaBean in Jdbc to

communicating with database:
Student.java:
package com.dto;
import java.io.Serializable;
public class Student implements Serializable{
private int sid;
private String sname;
private int sage;
private int sfee;
private String scourse;
public Student(){}
public Student(int sid, String sname, int sage, int
sfee, String scourse) {
super();
this.sid = sid;
this.sname = sname;
this.sage = sage;
this.sfee = sfee;
this.scourse = scourse;
}
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public int getSage() {
return sage;
}
public void setSage(int sage) {
this.sage = sage;
}
public int getSfee() {
return sfee;
}
public void setSfee(int sfee) {
this.sfee = sfee;
}
public String getScourse() {
return scourse;
}
public void setScourse(String scourse) {
}
}
Test.java:
import com.dto.Student;
import com.dto.Check;
public class Test{
SQLException {
System.out.println("Enter student id");
System.out.println("enter Student name");
System.out.println("enter student course");
String scourse = scan.next();
//Student s = new
Student(sid,sname,sage,sfee,scourse);
Student s = new Student();
s.setSid(sid);
s.setSname(sname);
s.setSage(sage);
s.setSfee(sfee);
s.setScourse(scourse);
Check.insert(s);
}
}
Check.java:
package com.dto;
public class Check {

static public void insert(Student obj)throws
SQLException{
ps.setInt(1, obj.getSid());
ps.setString(2, obj.getSname());
ps.setInt(4, obj.getSfee());
ps.setInt(3, obj.getSage());
ps.setString(5, obj.getScourse());
}
}
Working with auto generated keys in jdbc:
To work with above feature first we should install mysql,SQL

Server,DB2. This feature is not working oracle.
1. create database in mysql

create database ram;
2. use mysql
use ram;
3. create studentdetails table
mysql> create table studentdetails(sid int AUTO_INCREMENT
PRIMARY KEY, name varchar(15));
4. Create JDBCDemo.java file like bellow

Class.forName("com.mysql.jdbc.Driver");
"jdbc:mysql://localhost:3306/ram","r
oot","root");
if(con != null){
System.out.println("connection
established");
}
else
System.out.println("connection not
established");
/*int i = st.executeUpdate(
"insert into studentdetails
values(101,'ram')",
Statement.RETURN_GENERATED_KEYS);*/
int i = st.executeUpdate(
"insert into studentdetails(name)
values('sam')",
Statement.RETURN_GENERATED_KEYS);
ResultSet rs = st.getGeneratedKeys();
rs.next();
con.close();
}
}
Servlets:
----------
From java 1.2 onwards after introducing Servlets, Jsp concepts
into java,
we have three flavour in java.
1. Java2SE/ J2SE
2. Java2EE/ J2EE
3. Java2ME/ J2ME
2 represents version number.
From java 1.5 onwards, sun micro system delete the 2 for
representation and start calling directly as
1. JavaSE / JSE
2. JavaEE / JEE
3. JavaME / JME
JSE:
----
1. Java Stanadard Edition.
2. It is used to develop Standalone applications.
3. It is installable software.
4. Standalone applications may be CUI, GUI.
5. CUI we can develop through commandprompt.
6. GUT we can develop through Browsers (windows/Frame).
7. Standalone resource are sharable by the only one person at
a time,
that means data is not sharable between multiple client or
enduser at a time.
8. we required command prompt to compile and execute the
programs by using javac, java commands.
9. We required JDK software intallation.
10. JDK contains both compiler and JVM.
11. We are always using command prompt for giving the data
to program and getting response from program and
print the data (output) on command prompt by
using System.out.println() statements.
12. To work with JSE programs we required JDK API.
13. We save our .java files and .class files any folder and in
any directory.
14. we can compile and execute the program from any where in
our machine.
JEE:
-----
1. Java Enterprise Edition.(Java2 Platfrom Enterprise Ediition)
2. It is not installable software.
3. We can develop web, distributed, enterprise application.
4. These application resources can be sharable between
multiple user at a time through web in throughout
world.
5. To develop applications in JEE, we required JDK software
installation and JEE API.
6. To compile the program we required commandprompt and
javac command. This command given by JDK
software.
7. To execute the program we required Browsers( google
chrome, Mozilla firefox, Internet Explorer, Safari,
Opera Mini) and Servers(Apache tomcat, Glass Fish, web
logic..)-
8. We are always view the data or content on browsers only
either static or dynamic.
9. To print the data on browser, we use out.println()
statements.
10. We are always save our .class file in specific
folder that is "webapps".
11. To provide response to all the enduser, that means to
execute program and giving response all the endusers,
with in the same time we required servers. ( Apache Tomcat,
GlassFish, Weblogic,JBoss).
Software Technology:
------------------------
1. Technology will provides some rules and guide lines.
2. Rules are comming in the form interface.
3. Guide line are comming in the form of classes.
4. The combination of interface and classes simply we can
called as API.
5. These technology are usefull for developing technology
based software.
6. Here JDBC, SERVLETS, JSP are technologies.
7. Apache Tomcat, GlassFish, JBoss, Weblogic all are
technology based softwares.
Need of web application:

-----------------------------
By using JSE, we can able to develop standablone applications,
means the applications are running under only one desktop and
those applicastion services will be access by only one end user at a
time.(limited people can access).
ex: all corejava programs
JDBC programs, Socket promming etc....
If we want provides all the services or resources of any application
throughout the world we should choose webapplications.
WebApplication:
------------------
It is one type of applications running through web or running
under the servers for provides resources to as.l the end-user
through out world at a time is called web application.
we can develop web applications we have three technologies.
1. Java
2. Asp.Net
3. PHP
Web application always uses one http protocol for making

communication between client to server.
php technology we are using to develop websites,the number of

pages of website are less than 10 pages and number requests
comming to that website is low.
note: php suitable for small-scale applicatons.
Asp.net technology is used for developing small business

applications of around pages lessthan 20 and numbe requests
comming to applications are medium.
note: Asp.net is used for medium-scale applications.
Java technology is used for developing ecommerce applications,
banking application etc... These are having multiple pages like
morethan 30 and number of request also more.
note: Java is used for large-scale applications.
After arival of jquery and angular-js , JAVA TECHNOLOGY is suitable

for all type of applications.
Webapplication means request and response will be happend

through http protocol.
these web applications we can also called thin client- thick server.
thin client means only browser is sufficient no need of any extra
software configurations. Thick server means we required extra
software installation process.
Types of web applications:

------------------------------
Mainly web applications are two types.
1. static web applications
2. dynamic web applications
static web applications means the content or response of the web

application is common for all the enduser is called static web
application.
To develop any static web applications we required static web

components.
A language or technology is used to develop for web applications is
called web component.
a. HTML
b. java script
c. css
d. ajax
ex: www.nareshit.com
www.java4s.com
Dynamic web applications means the content or response of the web

application is changing from one enduser to another enduser is
called dynamic web applications.
To develop dynamic web applications we required the following web
components
a. Servlets
b. Jsp
c. Php
d. Asp.Net
ex: www.gmail.com
www. facebook.com
If we want to develop the standalone applications we required JSE

API, to compile the program we required compiler, we will get that
component by using "javac" tool. To executing the program we
required jvm, we will get that component by using "java" tool.
In the same manner to develop the web application we requied JEE

API, to compile the web application we required compiler, we will
get the component by using "javac" too by installation of JDK
software.
But to execute the program we required server softwares.
These server softwares are developing by the third party vendors.

These server softwares are implementing on top of specifications
given by JEE API through java software.
Java software provides rules and guidelines through technology wise

like Servlet, Jsp.
These rules are followed by the third party vendors and developing
technology based software like Tomcat, Apache web server, Glass
Fish,
weblogic etc.....
loosely coupling and runtime polymorphisam:

-----------------------------------------------------
interface Sim{
public abstract void call();
public abstract void sms();
}
class Vodafone implements Sim{

public void call(){
System.out.println("call connection through vodafone");
}
public void sms(){
System.out.println("sms delivered your charges are:
1/-");
}
}
class Idea implements Sim{

public void call(){
System.out.println("waiting from network signal");
}
public void sms(){
System.out.println("There is no sms offer");
}
}
class Mobile{
public static void main(String[] s1){
Sim s = new Vodafone();
s.call();
s.sms();
//loosely coupling
s = new Idea();
s.call();
s.sms();
}
}
---------------------------------------------------------------------------------
Q)what is the difference between web application and web site?
site means memory/location which is holds applications.
In general, every body feels like both are same but there is a
small difference between web site and web application.
Website is the collection of web applications. It will provide different

services to
different endusers. Every application having one unique service.
Webapplication is the collection of web components to provides

services to end
user.
ex: www. nareshit. com

nareshit web site having multiple or collection of webapplications
like course details, faculty details, course timings, new batches,
special batches
etc......
Before deploy program related to web in internet we can called as

web application , after deply web program in the internet we can
called as website.
---------------------------------------------------------------------------------
-----------
JEE:
-----
It is one type of flavour/edition in java from 1.2
It is a technology.
It will provide specifications(rule and guide lines).
Rules comming in the form of interface
Guide lines comming in the form classes.
It is the combination following specifications.
1. Protocols specifications.
2. Servlet specifications.
3. jsp specifications.
4. EJB specifications.
5. Middleware services specifications.
For above spefications are implemented/provide services by the

same
organizations/company (oracle) or other third party vendor
companies.
ServerName Third Party Vendor Name

---------------- ------------------------------
Apache Tomcat Apache Foundations
Web Sphere IBM
GlassFish Oracle
Web logic BEA (Oracle)
Server functionalities:
--------------------------
1. getting client request.
2. loading/deploy the web components (loading the bytecode)
3. creating instances(object).
4. processing the request
5. if required communicating with files, database, any middileware
services
6. generating response
7. handover response to client
8. destroying the instances.
9. undeploy the web components.
Q) What is JEE Technology based servers?

A) The Server, which is implemented on top JEE specifications or
rules is called
JEE technology based servers.
Types of Servers:
--------------------
Mainly Servers are two types.
1. Web Server.
2. Application Server.
WebServer:
A server which will provide services to/implementation for/
logic for servlet specifications and jsp specifications and protocol
specifications.
ex: Apache Tomcat.
It will support web protocols like http, https, smtp ....
Application Server:
A server which will provide services to/implementation for/
logic for
all specifications given by JEE Technology is called Applications
Server.
What is WebComponent:
It is reusable object for providing services to end user.(servlet,
jsp, ejb..)
What are the mandatory setps for developing web project?
1. Browsers:
a) Mozilla Firefox.
b) Opera Mini.
c) Safari
d) Google Chrome
e) Internet explorer etc...
2. Web Components:
a) Servlets
b) Jsp
c) html
d) css
e) java script
f) images
g) .property files
3. Servers
a) Apache Tomcat
b) Weblogic
c) Websphere
d) Glassfish
e) JBoss
Typs of websites:
--------------------
there two types websites.
1. Informative websites
2. service oriented websites.
The websites will provides only static information for all the
endusers is called informative websites.
The websites will provides different dynamic web content to

different endusers based on input or request.
JEE technology based WebServer:

A server which is using jee specification and providing
implementations or services to enduser is called jee based webser.
Internals of webserver:
----------------------------
WebServer mainly contains the following implementatios.
1. Http protocol implementation classes.
2. Servlet implementations classes
3. jsp implementation classes
4. Servlet container
5. Jsp container
6. Middleware services implementation classes.
Whenever enduser make a reuest to project(servlet

component) for services the following steps will happen.
1. Our request will be handover to http protocol, it will carry
that request and handover to httpprotocol implementation classes.
2. Httpimplementation classes will handover that request to
Servlet container.
3. Servlet container will uses the servlet implementation
classes.
4. By using the functionalities of servlet implementation
classes Servlet container will processing(executing) our request.
5 & 6. After process the request we will get appropriate
response that will be handover to again httpprotocol implementation
classes by servlet container.
7. Finally that response will be display on the browser (handover
to enduser).
whenever enduser making a request to jsp page the following

steps will happen.
a. Our request will be handover to http protocol, it will carry
that request and handover to httpprotocol implementation classes.
b. Httpimplementation classes will handover that request to
Servlet container.
c. Servlet container will calls jsp container.
d. Jsp container will uses the jsp implementation classes.
e. By using jsp implementation classes container will process
the jsp page
g. That response will be handover to http implementation
classes.
h. Finally the response will hadover to enduser (display content
on browser).
Jee technology based Application Server:

A server which will provides services or implementation for all
the specifications gen JEE is application server.
class Servlet{
String servletName = "welcomeservlet";
private Servlet(){}
//static Servlet obj = new Servlet();
static Servlet obj = null;
static Servlet getObjectForServlet(){
//return new Servlet();
if(obj == null){
obj = new Servlet();
return obj;
}
else
return obj;
}
}
class Container{
public static void main(String[] s){
/*Servlet s1 = new Servlet();
System.out.println(s1.servletName);
Servlet s2 = new Servlet();
*/
Servlet s1 = Servlet.getObjectForServlet();
Servlet s2 = Servlet.getObjectForServlet();
System.out.println(s1.hashCode()+"...."+s2.hashCode());
}
}
If we want to generate a dynamic content or dynamic response to

enduser we have following technologies like
CGI
Servlet
Jsp.
Common Gateway Interface:

CGI will provides a separate process/address for each and
every request to generate appropriate dynamic response.
Here we are facing the one main problem like context
switching, that means to providing the services for different client
simultaneously, CGI will shift the controle frome one process to
another process for that CGI will take more time.(time consuming
process).
More resources are utilize.
Platform dependent.
Poor in performance
To avoiding above problems java provides one special web
component that is SERVLET.
Servlet:
---------
servelt is one technology will provides dynamic response to
enduser.
For providing response to enduser servlet container will uses
one separate thread.
Servlet will work on multithread mechanisam.
That provides response with in the less time, that means
performance of an application is more.
servlet concept developed on top of java technology.
So it is the platform independency concept.
Thread is a light weight process, uses less memory.
Servlet will reponse to all the enduser equally.
Definition:
-------------
Servlet is one JEE web technology, is used to generate dynamic
web content.
Servlet is one JEE Web technology, is used to create single
instance-multiple response process.
Servlet is one JEE Web technology, will increases services of
web and application servers.
Servlet is one JEE Web technology, will provices rules and
guide lines to develop our own web components.
Servlet is one class (userdefine)it is used to extends new
features.
If we work with Servlets we required one predefine .jar file

that servlet-api.jar file, it is comes with web or application server.
How to download apache tomact server:

-----------------------------------------------
Goto google, type apache tomcat, click on search button.
click first link which is available in our paint image.
In new tab apache tomact home page will come. Left side of that
page we have download link and different versions.
Click on any one type of version.
In the body of the browser we have binary distributions, under that

we can download the either installable apache tomcat and
extractable apche tomcat.
Whenever we work with eclipse we required installable apache

software, whenever we work with “webapps” folder(without
eclipse) directly either we required installable apache tomcat
software.
How to install apache tomcat installable software:
----------------------------------------------------------
After downloading the apache tomcat software, double click on
software.
click on yes
click on next
click on IAgree
click on next
change port nummbers
server shutdown port number : 7892
http connector port number : 7890
AJp connector port number : 7891
username: ram
password: ram
click on next
select our JRE folder location
click on next
select destination location for installation
like C:\Program Files\Apache Tomcat Foundation\Tomcat 8.0
click install
UNSELECT
run apache tomcat
show read me
click Finish.
-----------------------------------------
Download any latest eclipse software and placed into one folder.
right click on zip file and click on extract here.
open eclipse folder, click on .exe (application) (which is in round

shape), create one folder and select that folder as workspace(to
save our programs in harddisk) location, click on launch.
How to add server to eclipse and developing first dynamic web

project:
File-->new-->other-->web-->dynamic web project -->next-->

give the name for project: FirstProgramSer
click new Runtime: select apachetomcat version 8.0
select web module : 3.0
next
browse tomcat installation location
oks
select installation jre like jre1.8.0_20
click on finish. Click on finish.
Firstprogram in servlet with Eclipse:
------------------------------------------
1. Install Eclipse in our system.
2. Develop one Dynamic web project.
Goto File-->select new-->click on others
--->goto Web folder-->select Dynamic web project
--->click on next
--->enter project name : FirstProgramSer
--->select Dynamic web module version: 2.5
--->click on Finish.
3. Install Apache Tomcat Server.
4. place servlet-api.jar file in buildpath/classpath.
right click on our project-->select buildpath
-->click on configure build path-->click on add external jars
-->goto apache tomcat(tomacat1.7)/lib-->select servlet-api.jar file
-->click on open--->click ok.
5. Create ourown servlet class.

Extract our project---> extract java resources-->right click on src
-->new --->click on class-->Type class name and package name
-->click on finish.
type bellow code:
WelcomeServlet.java:
-------------------------
import java.io.PrintWriter;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class WelcomeServlet extends GenericServlet{
@Override
public void service(ServletRequest request,
ServletResponse response)
throws ServletException,IOException{
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<body>");
out.println("<marquee>Hello welcome first program</marquee>");
out.println("</body>");
out.println("</html>");
}
}
6. Develop web.xml file:
extract our project-->extract WebContent-->extract WEB-INF
and check web.xml file, if available use it. If not available create
web.xml in the following manner.
right click on WEB-INF-->select new -->select othersselect
generalclick on File-->given name as web.xml--> click on finish
button.
Type bellow code in that web.xml file:

<web-app>
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>WelcomeServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hs</url-pattern>
</servlet-mapping>
</web-app>
7. Run the project.
right click on the project-->run as ---> Run on Server

---->choose an existing server -->click finish.
8. check server console in the eclipse for our tomcat is
properlly loading or not and check port number.
If any problem in loading those problem are shown in the
eclipse console
9. Open browser and send request to server by using
the following url.
http://localhost:portnumber/projectname/urlmappingname
http://localhost:1111/FirstProgramSer/hs
10. Check browser body for output, if any problem error will be
display on browser.
Q) Is it mandatory to declare Servlet class as public?

A: Yes. For compiling Servlet program, there is no problem, but
executing Servlet Program we required “public”. The reason is
Servlet Container will create object for our class, once we write
Servlet class as public then only that call will visible to Servlet
Container and creating object for that class.
Q) Is it mandatory to declare service (-,-) as public?

A: Yes. That is the principal of method overriding concept; sub class
method access modifier must be same as super class method access
modifier or increasable.
Q) Can we change service () return type?
A: No. Sub class method return type must be same super class
method return type.
Q) Is it mandatory to write throws ServletException, IOException?

A: No. But our logic required or demands definitely we need to write.
Q) What is meaning of "out" variable and can we change or not?

A: It is just reference variable, if we want we can change the
variable name also.
Q) Can we change service () name to other method?

A: No. We need to use same method name, Servlet container only
recognize the method name like service (). Sub Class Override
method must be same as super class method.
Q) What is functionality of out.println ()?

A: It will add response/information into ServletResponse object and
carry that response/information from web server to browser and
print that information/response on browser body.
Q) What is use of resp.setContentType ("text/html")?

A) This method is used to setting content-type HTTP response
header to provide, information to the browser about the type of
content we are sending.
This is also called MIME. (Multipurpose Internet Mail Extension).
text/html
text/plain
text/xml
application/msword
application/pdf
application/vnd.ms-excel
application/jar
application/javascript
application/json (javascript object notation)
applicaiton/zip
application/gzip
application/octet-stream
multiport/form-data
video/quicktime
video/avi
video/mp4
audio/mp4
image/gif
image/jpeg
image/png
Q) can we create morethan one web.xml file for one
project?
A) No.
Q) How many web.xml files are using for configure
morethan one servelet?
A) only one.
Q) How can we configure morethan one servlet details in
one
web.xml file?
A) by using mutliple <servlet> and <servlet-mapping>
tag.
Q) Can we write <url-pattern> content without '/' or '*' ?
A) No, server not starts.
Q) Can we write same <url-pattern> content for both
servlets?
A) Yes no problem server starts. but we are unable send
request
for servlet the reason servletcontainer will
ambiguous.
Q) Can we more than one servlet class in one ".java" file?
A) NO. Every servlet and its constructor should be public,
within the
one .java file we can create morethan one "public" class..
Usage of web.xml in Servlet:
It is descriptive file.
It provides or talks about Servlet mapping details and
registration details.
By using these details only Servlet Container will select one

appropriate Servlet class (user define class).
In web.xml we have one root tag that is <web-app>
<web-app> contains two main tags those are
1. <servlet>
2. <servlet-mapping>
<servlet> will provide details about Servlet_Class.
<servlet-mapping> will provide details about servlet URL

names/alias names nothing but Servlet mapping details.
<servlet-name> will talks about Servlet registration name.
<servlet-class> will talks about actual Servlet class name.
<url-pattern> will talks about public URL name.

Servlet registration name and public URL name can be
anything.
Whenever end user send request, from request container will
read public URL name and comparing with <url-pattern>
content/element.
If both are matched, container will read name/element from
<servlet-name> of <servlet-mapping> later container will
match this name/element with <servlet-name> element of
<servlet>.
If both are matched, container will read Servlet Class Name

from <servlet-class> later container will create object for that
select class.
Internal flow of First Servlet program:

1. Whenever request is sending by the end user, that request will
be read by the web server
2. and handover to http protocol implementation classes.
3. That request will be handover to Servlet Container.

4. Servlet container internally uses Servlet implementation
classes.
5. Servlet container creates ServletContext object
6. Servlet container creates Thread Object
7. Servlet Container creates ServletRequest object with input

data.
8. Servlet Container creates ServletResponse object created with

empty.
9. ServletContainer creates PrintWriter Object
10. ServletContainer creates ServletConfig object
11. ServletContainer will loads bytecode of our class and

executes static loading and initailization phases.
12. Servlet Container creates Servlet (WelcomeServlet) object

or instance and non-static loading phase and initilization phase
and executes constructor.
13. By using Servlet instance, ServletContainer will inject

ServletConfig into init(-) and executes.
14. By using servlet instance, Servlet container calls service

method by passing ServletRequest object and ServletResponse
15. service (-,-) of our own Servlet class (WelcomeServlet)

will be executing.
16. With the support of PrintWriter Output/response will be

placed into ServletResponse object..
17. Generates response in the form html page.

18. Handover html form (response) to http implementation
classes.
19. Finally output will be printed on the browser.

20. Destory the Thread object
21. Destroy ServletRequest object.
22. Destroy ServletResponse object.
Note: Servlet object (WelcomeServlet) is created only one time.

That object will be useful for providing response to all end users.
Servlet architecture depends one design pattern that is Singleton
Design Pattern. That Servlet is a singleton object.
As many requests are coming to our application, those many the

same servlet object will used by Servlet Container to provides
services to end users.
As many requests are coming to our application, those many times

new ServletRequest object and ServletResponse object will be
creating by Servlet container and after providing the response to end
user both the object will be destroy by the Servlet Container.
Generating Dynamic Response Ro Client:
DateServletDemo.java:
package com.kit.aj;
public class DateServletDemo extends GenericServlet{

@Override
ServletResponse response)throws ServletException,
IOException{
SimpleDateFormat sdf = new SimpleDateFormat("MMM-dd-YYYY
hh:mm:ss");
String date = sdf.format(d);
out.println("The Current Time Is: "+date);
}
Web.xml:
<web-app>
<servlet>
<servlet-name>date</servlet-name>
<servlet-class>com.kit.aj.DateServletDemo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>date</servlet-name>
<url-pattern>/date</url-pattern>
</servlet-mapping>
</web-app>
Servlet-Singleton:
Servlet Container always create single object for our servlet

class.
For multiple requests Servlet Container will uses only one
servlet object.
As many requests coming our application those many times

ServletRequest and ServletResponse object will be creating by the
servlet container.
SingletonServletDemo:
package com.aj.ram;
public class SingletonServletDemo extends

GenericServlet{
@Override
ServletResponse response)throws
ServletException,IOException{
PrintWriter pw = response.getWriter();
System.out.println("SingletoServletDemo Object:
"+this+"..."+this.hashCode());
System.out.println("Current Thread Object:
"+Thread.currentThread()+"..."+
Thread.currentThread().hashCode()
+"..."+Thread.currentThread().getName());
System.out.println("ServletRequest Object:
"+request+"..."+request.hashCode());
System.out.println("ServletResponse Object:
"+response+"..."+response.hashCode());
try {
} catch (InterruptedException e) {
}
pw.print("<html>");
pw.print("<body>");
pw.println("SingletoServletDemo Object:
"+this+"..."+this.hashCode());
pw.print("<br/>");
pw.println("Current Thread Object:
"+Thread.currentThread()+"..."+
Thread.currentThread().hashCode()
+"..."+Thread.currentThread().getName());
pw.print("<br/>");
pw.println("ServletRequest Object:
"+request+"..."+request.hashCode());
pw.print("<br/>");
pw.println("ServletResponse Object:
"+response+"...."+response.hashCode());
pw.print("</body>");
pw.print("</html>");
}
Web.xml:
<web-app>
<servlet>
<servlet-name>single</servlet-name>
<servlet-
class>com.aj.ram.SingletonServletDemo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>single</servlet-name>
<url-pattern>/single</url-pattern>
</servlet-mapping>
</web-app>
Servlet Execution Models:
Servlet execution depends two types of models.

1. Single Instance – Multi Thread Model.
In the above model servlet container will create only one
instance for our servlet class. The same instance/object will
provides services to all requests or multiple requests.
All requests are executing simultaneously by the single
instance.
2. Single Instance – Single Thread Model.

In above model servlet container will create multiple servlet
objects for multiple requests.
To obtain this feature we implements
javax.servlet.SingleThreadModel interface. It is marker or
tagling interface. It provides the permissions to develop
SIST model.
It doesn’t have any method.
For each and every request one new object will be creating,
that object used to processing the only one client request.
If keep on requests are increases, the number of objects will

be increases that will effects to performance of an
application.
No two threads working on same service () concurrently.
Whenever we implements SingleThreadModel interface
internally servlet container uses synchronized concept to
allow only one thread at a time to execute service ().
import javax.servlet.SingleThreadModel;
public class ServletModelDemo extends GenericServlet implements SingleThreadModel{

public void service(ServletRequest request, ServletResponse response)
out.println("<body>-");
try{
}
catch(InterruptedException e){
System.out.println("problem comes here");
}
out.println("Servlet Object: "+this.hashCode());
out.println("Thread Object: "+
Thread.currentThread().hashCode());
out.println("RequestObject: "+request.hashCode());
out.println("ResponseObject: "+response.hashCode());
}
<web-app>
<servlet>
<servlet-name>model</servlet-name>
<servlet-class>ServletModelDemo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>model</servlet-name>
<url-pattern>/model</url-pattern>
</servlet-mapping>
</web-app>
import javax.servlet.ServletConfig;
public void service(ServletRequest
request,ServletResponse response)
out.println("<body bgcolor='yellow'>");
out.println("<h1>THIS IS SERVLET
RESPONSE</H1>");
try{
System.out.println("try block");
out.println("current
object:"+this.hashCode());
out.println("thread
object :"+Thread.currentThread().hashCode());
out.println("ServletRequest:"+request);
out.println("ServletResponse:
"+response);
out.println("PrintWriter: "+out);
}
catch(InterruptedException ie){
ie.printStackTrace();
}
}
}
Execution: making request from two browsers:

Output:
current object:1558299375
thread object :1450446715
ServletRequest:org.apache.catalina.connector.RequestFacad
e@58b3ebc5
ServletResponse:
org.apache.catalina.connector.ResponseFacade@5c8c640b
PrintWriter:
org.apache.catalina.connector.CoyoteWriter@198ee1fe
ServletRequest:org.apache.catalina.connector.RequestFacad
e@24dbc169
ServletResponse:
org.apache.catalina.connector.ResponseFacade@7a976a0a
PrintWriter:
org.apache.catalina.connector.CoyoteWriter@28b3290d
RESPONSE</H1>");
try{
object:"+this.hashCode()+"<br/>");
out.println("thread
object :"+Thread.currentThread().hashCode()+"<br/>");
out.println("ServletRequest:"+request.hashCode()
+"<br/>");
"+response.hashCode()+"<br/>");
out.println("PrintWriter:
"+out.hashCode()+"<br/>");
out.println("Response time is: "+d);
}
}
}
}
Eclipse Browser:
THIS IS SERVLET RESPONSE

ServletRequest:770424710
ServletResponse: 231101396
PrintWriter: 1817374046
Response time is: Mon Nov 13 17:22:10 IST 2017
-----------------------------------------------------------------------
Outside of eclipse browser:
THIS IS SERVLET RESPONSE

ServletRequest:2020102986
ServletResponse: 1030406691
PrintWriter: 1321757788
Response time is: Mon Nov 13 17:22:13 IST 2017
import javax.servlet.ServletContext;
ServletConfig sconfig = null;

ServletContext scontext = null;
@Override
public void init(ServletConfig sc)throws ServletException{
sconfig = sc;
scontext = sconfig.getServletContext();
}
public void service(ServletRequest request,ServletResponse

response)
RESPONSE</H1>");
try{
object:"+this.hashCode()+"<br/>");
out.println("thread
object :"+Thread.currentThread().hashCode()+"<br/>");
out.println("ServletRequest:"+request.hashCode()+"<br/>");
"+response.hashCode()+"<br/>");
out.println("PrintWriter:
"+out.hashCode()+"<br/>");
out.println("ServletConfig:
"+sconfig+"<br/>");
out.println("servletContext:
"+scontext+"<br/>");
}
}
}
}
Servlet Life Cycle:

The activities which are doing by servlet container from loading to
destroy on servlet is called servlet life cycle.
There are 5 Life cycle phases available in Servlet.
1. Loading phase.
2. Instantiation phase.
3. Initialization phase.
4. Servicing phase.
5. Destroy phase.
Loading Phase:
Whenever end user sending request to servlet, first servlet
container will loads servlet class bytecode from secondary memory
to primary memory. In the meanwhile static variable and static block
static method are executing.
Instantiation phase:
In this phase servlet container will creates object for our own
servlet class. Meanwhile of object creation for our servlet class non-
static/instance variables, instance methods and instance blocks will
be executing and construcotr will be executing.
Initialization phase:
In above phase we don’t fill with initialization values in to
servlet object. That problem will be solved in this step. Servlet
container itself reading initialization values from web.xml file and
creates ServletConfig object and filled those initialization values and
calling the init (ServletConfig sc) by passing ServletConfig object.
Servicing phase:
Servlet container will creates ServletRequest object and
ServletResponse object and calling service (-,-) by passing request
and response objects by using servlet object witch is created in
instantiation phase.
Destroy phase:
In phase servlet object will be destroy by calling destroy().
Whenever our server shutdown or restart or project undeploy from
the server this phase be executing by the container.
We have 3 life cycle methods.

1. init (-)
2. service(-,-)
3. destroy()
The above methods automatically call by the container.
The methods which are calls by the container automatically are
called life cycle methods.
How many ways can we develop our own servlet class?

There are three ways.
1. By implementing javax.servlet.Servlet interface
2. By extends javax.servlet.GenericServlet class
3. By extends javax.servlet.HttpServlet class
GenericServlet:
What is the difference between init() and init(ServletConfig) of

GenericServlet?
init() is convience method to call GenericServlet init(ServletConfig)

method to initialize the ServletConfig object.If we overridden only
init() in our program internally our controle goes to GenericServlet
class init(ServletConfig) and initializing ServletConfig object and
calling init().
What is the difference between servlet constructor and

init(-)?
In servlet, constructor is design for only object creation by servlet
container, the reason is servlet container creating object for our
servlet class by using newInstance(), this method always required
public default or zero argument constructor not for initializing the
servlet. Whereas init(-) is useful for initailzing the servlet object
with specific values, which are mention in web.xml file….
package com.st.sc;
import java.io.*;
import java.sql.*;
import javax.servlet.*;
public class ReadServlet extends GenericServlet {
ServletConfig scfg = null;
public ReadServlet(){
System.out.println("ZERO ARGUMENT");
}
public ReadServlet(int fno ,int sno){
System.out.println("ARGUMENT CONSTRUCTOR");
}
public void service(ServletRequest request, ServletResponse

response )throws ServletException,IOException{
System.out.println("SERVICE METHOD");
}
What is difference between Lifecycle method Lifecycle call back

method?
A) The methods which are calling by servlet container automatically

are called lifecycle methods, the methods which are calling from
lifecycle methods are called lifecycle call back methods.
public abstract class GenericServlet{

ServletConfig cfg;
public void init(ServletConfig sc){
cfg = sc;
init();
}
public void init(){
}
ServletConfig getServletConfig(){
return cfg;
}
}
class MyServlet extends GenericServlet{
public void init(){}
public void service(-,-){
ServletConfig scfg = getServletConfig();
//in the above we are getting memory
}
}
If we are overriding init(ServletConfig), then controle not going

GenericServlet class init(ServletConfig) so servletcontainer not
initialize ServletConfig variable. so if we are calling
getServletConfig(), we are getting null value that will be effect to
NullPointerException
public abstract class GenericServlet{
ServletConfig cfg;
cfg = sc;
init();
}
public void init(){
}
ServletConfig getServletConfig(){
return cfg;
}
}
public void init(ServletConfig sc){}
//in the above we are not getting memory, we will null value
}
}
To overcome that problem we should call super.init(sc) from our
class init(ServletConfig) like bellow
super.init(sc);
}
//in the above we are getting memory
}
}
package com.ram.aj;
public class MyServlet extends GenericServlet{
/*@Override
public void init()throws ServletException{
System.out.println("this is myservlet init()");
}*/
/*@Override
System.out.println("this is myservlet
init(ServletConfig)");
}*/
@Override
super.init(sc);
}
@Override
response)
throws IOException,ServletException{
out.println("<body bgcolor='Yellow'>");
out.println("<H2><MARQUEE>THIS SECONDSERVLET
PROGRAM</MARQUEE></H2>");
String fno = scfg.getInitParameter("fno");
String sno = scfg.getInitParameter("sno");
int fn = Integer.parseInt(fno);
int sn = Integer.parseInt(sno);
out.println("The Result is: "+(fn+sn));
}
}
Web.xml
<web-app>
<servlet>
<servlet-name>ms</servlet-name>
<servlet-class>com.ram.aj.MyServlet</servlet-
class>
<init-param>
<param-name>fno</param-name>
<param-value>100</param-value>
</init-param>
<init-param>
<param-name>sno</param-name>
</init-param>
</servlet>
<servlet-mapping>
<url-pattern>/second</url-pattern>
</servlet-mapping>
</web-app>
One more approach to avoiding java.lang.NullPointerException:
Web.xml:
<web-app>
<servlet>
<servlet-class>com.ram.aj.MyServlet</servlet-
class>
<init-param>
</init-param>
<init-param>
</init-param>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
MyServlet.java:
package com.ram.aj;
public class MyServlet extends GenericServlet{
ServletConfig scfg;
@Override
scfg=sc;
}
@Override
response)
out.println("<H2><MARQUEE>THIS SECONDSERVLET
PROGRAM</MARQUEE></H2>");
String fno = scfg.getInitParameter("fno");
String sno = scfg.getInitParameter("sno");
int fn = Integer.parseInt(fno);
int sn = Integer.parseInt(sno);
out.println("The Result is: "+(fn+sn));
}
}
Each and every servlet having their own servletconfig object, one
servlet related config object data can’t shared by other servlet
object
FirstServlet.java:
package com.ram.aj;
public class FirstServlet extends GenericServlet{
@Override
response)throws ServletException, IOException{
ServletConfig sc = getServletConfig();
System.out.println(sc.getInitParameter("fno"));
System.out.println(sc.getInitParameter("sno"));
}
}
SecondServlet.java:
package com.ram.aj;
public class SecondServlet extends GenericServlet{
@Override
response)throws ServletException, IOException{
ServletConfig sc = getServletConfig();
System.out.println(sc.getInitParameter("fno"));
System.out.println(sc.getInitParameter("sno"));
}
}
Web.xml:
<web-app>
<servlet>
<servlet-name>first</servlet-name>
<servlet-class>com.ram.aj.FirstServlet</servlet-class>
<init-param>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>first</servlet-name>
<url-pattern>/first</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>second</servlet-name>
<servlet-class>com.ram.aj.SecondServlet</servlet-
class>
<init-param>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>second</servlet-name>
</servlet-mapping>
</web-app>
Developing our own servlet By implementing javax.servlet.Servlet
interface:
import javax.servlet.Servlet;
public class LifeCycleServletDemo implements Servlet{
static int a = m1();
static int m1(){
System.out.println("static m1 method");
System.out.println("a: "+0);
return 111;
}
static{
System.out.println("static blocks");
}
int b = m2();
int m2(){
System.out.println("non-static m2 method");
System.out.println("b: "+0);
return 222;
}
{
System.out.println("non-static blocks");
}
@Override
public void init(ServletConfig arg0) throws ServletException {
System.out.println("init method");
}
@Override
public ServletConfig getServletConfig() {
System.out.println("getServletConfig method");
return null;
}
@Override
public String getServletInfo() {
System.out.println("getServletInfo method");
return null;
}
@Override
public void service(ServletRequest arg0, ServletResponse arg1)
throws ServletException, IOException {
System.out.println("service method");
}
@Override
public void destroy() {
System.out.println("destroy method");
}
}
Drawback: The drawback of program is we are always overrides the
all the methods of javax.servlet.Servlet interface.
But when we work with Generic and HttpServlet we are not facing
this type problem.
web.xml:
<web-app>
<servlet>
<servlet-name>life</servlet-name>
<servlet-class>LifeCycleServletDemo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>life</servlet-name>
<url-pattern>/life</url-pattern>
</servlet-mapping>
</web-app>
<load-on-startup>:
Whenever end user make a request to servlet first time servlet

container will process the loading, instantiation, initialization later
service phases will executing.
But whenever any end user make a request to servlet in second

time, servlet container not executing loading, instantiation and
initialization phase, control directly goes to service () and given
response to end user that means second user will get response
within the less time comparing to first end user.
We can resolve above problem with support of <load-on-startup>.
This tag we can use within <servlet> and after <servlet-class>.
This tag always requires integer number, may be the number is 0 or

negative or positive integer.
If we are writing other than integer number like float and String and
char, Boolean values we will get SAXParseException and server is
not starting.
If there is any problem in xml we are always getting

SAXParseException.
Whenever we use <load-on-startup>, servlet container will do the

loading phase, instantiation and initialization phase before request
coming from end user.
The smallest integer value will give information to servlet container

to load that particular class first.
Negative values are not giving information to servlet container to

load that particular servlet class before request coming from end
user.
Two servlet classes <load-on-startup> tag values are same then

servlet container will take the decision to load any one of the servlet
class.
Example on <load-on-startup>:

static int m1(){
return 111;
}
static{
}
public FirstServlet() {
System.out.println("FirstServlet constructor");
}
int b = m2();
int m2(){
return 222;
}
{
}
@Override
System.out.println("-----------------------");
}
@Override
}
}

static int m1(){
return 111;
}
static{
}
public SecondServlet() {
System.out.println("SercondServlet constructor");
}
int b = m2();
int m2(){
return 222;
}
{
}
@Override
}
@Override
}
}

static int m1(){
return 111;
}
static{
}
}
int b = m2();
int m2(){
return 222;
}
{
}
@Override
}
@Override
}
}

static int m1(){
return 111;
}
static{
}
}
int b = m2();
int m2(){
return 222;
}
{
}
@Override
}
@Override
}
}
public class FifthServlet extends GenericServlet {

static int m1(){
return 111;
}
static{
}
public FifthServlet() {
System.out.println("fifthServlet constructor");
}
int b = m2();
int m2(){
return 222;
}
{
}
@Override
}
@Override
}
}
Web.xml:
<web-app>
<servlet>
<servlet-name>fs</servlet-name>
<servlet-class>FirstServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet>
<servlet-name>ss</servlet-name>
<servlet-class>SecondServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>ts</servlet-name>
<servlet-class>ThirdServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>fos</servlet-name>
<servlet-class>FourthServlet</servlet-class>
<load-on-startup>-2</load-on-startup>
</servlet>
<servlet>
<servlet-name>fifth</servlet-name>
<servlet-class>FifthServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/fs</url-pattern>
</servlet-mapping>
<servlet-mapping>
<url-pattern>/ss</url-pattern>
</servlet-mapping>
<servlet-mapping>
<url-pattern>/ts</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>fos</servlet-name>
<url-pattern>/fos</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>fifth</servlet-name>
<url-pattern>/fifth</url-pattern>
</servlet-mapping>
</web-app>
<web-app>
<servlet>
</servlet>
<servlet-mapping>
<url-pattern>/fs/ss/hai12</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>fis</servlet-name>
<servlet-class>FifthServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>fis</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

</web-app>
URL pattern and its types:
With support URL we can able to communicating with our required

servlet for getting proper dynamic response.
URL is provides security to our web component and also hides the
technology, which we were used in developing web component.
If the end user not understands the technology which I was used, he
is unable send virus or hacking programs.
That means simply we can say URL provides security from
unauthorized end users.
These three types:
1. Exact match url pattern.

2. Directory match url pattern.
3. Extension match url pattern.
Exact match url pattern.

Starts with ‘/’ followed by words or numeric’s or characters
and combinations and some of the special symbols also.
In web.xml
--------------
<url-pattern>/life</url-pattern>
From browser: /life (valid)

/life1(invalid)
In web.xml:
---------------
<url-pattern>/life123</url-pattern>
From browser: /life123(valid)

/life (invalid)
In web.xml:
--------------
<url-pattern>/life/mylife/123</url-pattern>
From browser: /life/mylife/123 (valid)

/life1/mylife(invalid)
In web.xml:
--------------
<url-pattern>/678ram</url-pattern>
Fromm browser: /678ram
In web.xml:
/life$
From browser:
/life$ (valid)
/life# (invalid)
Directory match url patten:
Start with / and ends with *
In web.xml:
---------------
<url-patten>/life/sb/*</url-pattern>
From browser: /life/sb
/life/sb/ram
/life/sb/sam
/life/sb/A.java
/life/sb/A.c
/sb/life/B.cpp(invalid)
/life/sb.c(invalid)
Extension match url pattern:
Starts with * and ends with .extension
In web.xml:
---------------
<url-patten>*.java</url-pattern>
From browser: /ram.java
/sam.java
/kiran.ram.java
/ram/sam.java
/ram/sa/123.java
/kiran.ram.javas (invalid)
‘*’ can be replaced with single word or multiple words but

extension must be match with “.java”.
How to develop different types of response:
public class MSWordServletDemo extends GenericServlet {
@Override
public void service(ServletRequest req,
ServletResponse res)throws ServletException,IOException{
res.setContentType("application/msword");
PrintWriter out = res.getWriter();
out.println("<table border='2'>");
out.println("<tr><th>FacultyName</th><th>Subjects</th></tr>");
out.println("<tr><td>Ram</td><td>AdvancedJava</td></tr>");
out.println("<tr><td>Ravi</td><td>Oracle</td></tr>");
out.println("<tr><td>SathishB</td><td>Spring</td></tr>");
out.println("<tr><td>Natraz</td><td>AllJavaCourses</td></tr>");
out.println("</table>");
}
}
public class MSExcelServletDemo extends GenericServlet {

@Override
res.setContentType("application/vnd.ms-excel");
}
}
public class XMLServletDemo extends GenericServlet{

@Override
res.setContentType("text/xml");
}
}
Web.xml:
<web-app>
<servlet>
<servlet-class>MSWordServletDemo</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/ms</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>xs</servlet-name>
<servlet-class>XMLServletDemo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xs</servlet-name>
<url-pattern>/xs</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>es</servlet-name>
<servlet-class>MSExcelServletDemo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>es</servlet-name>
<url-pattern>/es</url-pattern>
</servlet-mapping>
</web-app>
Execution: urls:
http://localhost:1111/ResponseTypes/ms
http://localhost:1111/ResponseTypes/xe
http://localhost:1111/ResponseTypes/es
How to develop welcome files in servlet:
Welcome files or Home pages are used to navigate the web pages of
website.
These are provides more flexibility to interact with website.
We can develop these files with the support of bellow tag.
<welcome-file-list>
<welcome-file>…….</welcome-file>
</welcome-file-list>
If we are not writing <welcome-file-list> in web.xml by default web

server will check whether index.hmtl is there or not, if exists that
index.html will treat as welcome that will be given to end user, if not
exists server will check index.jsp if exists server will treat that file
as welcome file and handover that file to end user as a welcome file
else normal browser will handover to end user.
If index.html and index.jsp already existed but programmer

explicitly mention <welcome-file> with one html file, if that file is
also existed first preference will give programmer choice nothing but
<welcome-file>html file.
We can place .html, .jsp and servlet as welcome pages.

<servlet>
<servlet-name>ws</servlet-name>
<servlet-class>com.aj.ser.WelcomeServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/ws</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>ws</welcome-file>
Whatever the order we placed the files in <welcome-file> in the
same order welcomes files selected.
We can place more one file in <welcome-file> as a welcome page.

But at a time only one page will treated as welcome page.
If we are not placing <welcome-file-list> by default control

Will check about index.html if not exist index.jsp.
In web.xml file servlet url pattern and .html file name is same then
first preference gives to Servlet only.
In web.xml file servlet url pattern and .jsp file name is same then
first preference gives to Servlet only.
<web-app>
<servlet>
<servlet-class>WelcomeFileServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/index.jsp</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</web-app>
In above web.xml servlet url name welcome file name same

In that time first preference will gives to servlet only not for
.jsp file. Between servlet and .html if same problem coming
container will give the preference to servlet only.
What is the difference between welcome servlet and default

servlet??
Welcome servlet will display as a home page to end user.

Whenever end user sending wrong url, container will display 404
Error on the browser, instead of printing 404 error, if we want to
display any standard servlet as a response to end user, we should go
for default servlet.
If we mention more welcome file names in web.xml file then, the
searing proces always from top to bottom.
public class WelcomeFileServlet extends GenericServlet{

@Override
public void service(ServletRequest req, ServletResponse
res)throws
res.setContentType("text/html");
out.println("welcome file servlet");
}
}
public class HelloServletDemo extends GenericServlet{

@Override
public void service(ServletRequest req, ServletResponse res)throws
out.println("hellow servlet");
}
}
<web-app>
<servlet>
<servlet-class>WelcomeFileServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/ws</url-pattern>
</servlet-mapping>

<welcome-file-list>
<welcome-file>ws</welcome-file>
</web-app>
If we want to work with default servlet delete <welcome-file-list>

and uncomment above code.
Important object of servlet:

ServletContext
ServletRequest
ServletResponse
PrintWriter
ServletConfig
Servlet object
HttpSession
The order of above objects creation will be depends on <load-on-

startup>.
With <load-on-startup>
1. ServletContext
2. ServletConfig
3. Servlet object
4.ServletRequest
5.ServletResponse
6.PrintWriter
7.HttpSession
Without <load-on-startup>
1. ServletContext
2.ServletRequest
3.ServletResponse
4.PrintWriter
5. ServletConfig
6. Servlet object
7.HttpSession
Scope Objects:
These are used for carrying the information from one request to
another or one servlet to another servlet or one client to another
client are called Scope objects.
We have three scope objects.
1. Request[ServletRequest]
2. Session[HttpSession]
3. Context (in Servlet)/application in jsp)
[ServletContext].
Example on Request Scope Objects:

If the response is handover to end user or browser
automatically the request scope object will destroyed.
To place the data into request scope object we required the
following method.
request.setAttribute(-,-)
To read the data from request scope object we required the
following method.
request.getAttribute(-)
import javax.servlet.RequestDispatcher;
public class AtmServlet extends GenericServlet {
@Override
request.setAttribute("accNo", 1234567);
RequestDispatcher rd =
request.getRequestDispatcher("/bs");
rd.forward(request, response);
}
}
public class BankServlet extends GenericServlet {
@Override
Integer accNo =
(Integer) request.getAttribute("accNo");
out.println("Account Number is: "+accNo);
}
}
<web-app>
<servlet>
<servlet-class>AtmServlet</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
<servlet-name>bs</servlet-name>
<servlet-class>BankServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/bs</url-pattern>
</servlet-mapping>
</web-app>
In the above program if we are sending request to AtmServlet we
are getting proper output only.
If we are sending request to BankServlet we will get null value.
Form the same browser in different window if we are sending
request to BankServlet, we will get null value again.
From the different browser, if we are sending request to
BankServlet, again we will get null value only.
The reason is once the response is commited(handover) to browser

the request scope object will be destroyed, that’s we are always
getting null value.
Session Object:
Whenever end user making request to Server, servlet container will

create request, response, session objects.
We can able to interface with request and response objects directly
but not session object.
To interact with session object we request the below syntax or code

HttpSession session = request.getSession();
For own browser, servlet container will create one session object.
The same session object content will be used by different servlets in
our application.
Once the browser is closed, automatically session object will be

destroyed.
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class AtmServlet extends HttpServlet {
@Override
public void service(HttpServletRequest request,
HttpServletResponse response)
session.setAttribute("accNo", 777777);
}
}
public class BankServlet extends HttpServlet {
@Override
Integer accNo =
(Integer) session.getAttribute("accNo");
}
}
Web.xml:
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Context Object:
public class AtmServlet extends GenericServlet {
@Override
ServletContext context = getServletContext();

context.setAttribute("accNo", 123456);
}
}
public class BankServlet extends GenericServlet {
@Override
ServletContext context = getServletContext();
Integer accNo =
(Integer) context.getAttribute("accNo");
}
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Html and Servlet communication:
1. Sending data directly from browser URL:

2. import java.io.IOException;
3. import java.io.PrintWriter;
4.
5. import javax.servlet.GenericServlet;
6. import javax.servlet.ServletException;
7. import javax.servlet.ServletRequest;
8. import javax.servlet.ServletResponse;
9.
10.
11. public class AddingServletDemo extends GenericServlet {
12. @Override
13. public void service(ServletRequest request,
14. ServletResponse response)
15. throws ServletException,IOException{
16. System.out.println("service method");
17. String firstNumber = request.getParameter("fno");
18. //case sensitive means url fno this fno must be match
19. String secondNumber = request.getParameter("sno");
20.
21. int fno = Integer.parseInt(firstNumber);
22. int sno = Integer.parseInt(secondNumber);
23.
24. int result = fno+sno;
25.
26. response.setContentType("text/html");
27. PrintWriter out = response.getWriter();
28. out.println("Result Is: "+result);
29. }
30. }
<web-app>
<servlet>
<servlet-name>add</servlet-name>
<servlet-class>AddingServletDemo</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/add</url-pattern>
</servlet-mapping>
</web-app>
From browser Side:
We need to enter data in the following format:
http://localhost:portnumber/projectname/url?
firstparamname=paramvalues&secondparamname=paramvalue&.......
http://localhost:1111/HtmlServletCommunication/add?fno=200&sno=150
Output in the browser is:

Result Is: 350
“add”  is URL name it must be match with <url-pattern> in web.xml.

“?”  is used for separate the URL from input parameter name.
“=”  is used for separate parameter name and value.
“&”  is used for separate one parameter to another parameter.
Note: don’t use any other special character and spaces in the
URL, if we type wrongly we get errors.
In the above approach end user unable type URL in the correct format.
To resolve this problem we should for html pages.
How to create .html pages in eclipse:

Right click on project WebContent folder  click on new  click
on file/click on others/ search by typing file  select File option
click on next  type file name like add.html  click on finish.
add.html:
<html>
<body>
<form action="./add">
Enter First Number : <input type='text' name='fno'/><br/>
Enter Second Number: <input type='text' name='sno'/><br/>
<input type='submit' value='ADD'/>
</form>
</body>
</html>
AddingServletDemo:
public class AddingServletDemo extends GenericServlet {

@Override
String firstNumber = request.getParameter("fno");
//case sensitive means url fno this fno must be match
String secondNumber = request.getParameter("sno");
int fno = Integer.parseInt(firstNumber);
int sno = Integer.parseInt(secondNumber);
int result = fno+sno;
out.println("Result Is: "+result);
}
}
<web-app>
<servlet>
<servlet-class>AddingServletDemo</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
From browser send request like bellow:
http://localhost:1111/HtmlServletCommunication/add.html
We will get add.html page
Later enter first number value is 500 and second number
value is 200 and click ADD button
After click on ADD button browser engine will convert above URL
into following manner
http://localhost:1111/HtmlServletCommunication/add?fno=500&sno=200
on browser we will get output like
Result Is: 700
In the above approach also there is one small drawback that is every time end user
click on back arrow button or end user will make new request from brower url to
add.html for entering new values for adding.
To avoiding above problem we should use hyperlink.

@Override
out.println("<a href='./add.html'>click me</a>");
}
}
In above approach end user every time click on “click me” hyperlink.
Sometimes may be end user not showing interest to click on hyperlink.
To resolve this problem we should add bellow code in the place of hyperlink
code.

@Override
//out.println("<a href='./add.html'>click me</a>");
request.getRequestDispatcher("./add.html");
rd.include(request, response);
}
}
In the above approach old values are not display in the text
fields.
Whatever values we entered in request, if we want to display
those values in the text field we need to write the following code
in the place of RequestDispatcher in the previous program.

@Override
out.println("Enter First Number: <input type='text' name='fno'
value='"+fno+"'/><br/>");
out.println("Enter Second Number: <input type='text' name='sno'
value='"+sno+"'/><br/>");
out.println("<input type='submit' value='add'>");
}
}
Add.html code and in servlet html related both are same. In above program if
the end user sending request to AddingServletDemo directly we face one
exception java.lang.NumberFormatException.
To overcome this problem we need to write the following code.

@Override

System.out.println("firstnumber: "+firstNumber);
System.out.println("secondnumber: "+secondNumber);
int result=0;
String a="null";
String b="null";
if( (firstNumber == null || secondNumber ==null) ||
(a.equals(secondNumber)) || (b.equals(secondNumber)) ){
firstNumber="";
secondNumber="";
}
else{
int fno = Integer.parseInt(firstNumber);//""
int sno = Integer.parseInt(secondNumber);//"200"
result = fno+sno;//300
}
out.println("<form action='./add'>");
out.println("Enter First Number: <input type='text' name='fno'
/></br>");
out.println("Enter second number: <input type='text'
name='sno' /></br>");
out.println("<input type='submit' value='add'/>");
out.println("</form>");
if(!(firstNumber.isEmpty())){
out.println("result: "+result);
}
}
}
If the end user not inserting any data into text fields and click on
Add button will get again java.lang.NumberFormatException
to resolve this problem, we can use HTML5 attribute like “required”
in text field declaration in AddingServletDemo.java file
we can re write the code as bellow.
out.println("<form action='./add'>");
out.println("Enter First Number: <input type='text'
required name='fno' /></br>");
out.println("Enter second number: <input type='text'
required name='sno' /></br>");
out.println("<input type='submit' value='add'/>");
Calculation Application:
cal.html:
<form>
<a href='./add.html'>ADDITION</a><br/>
<a href='./sub.html'>SUBTRACTION</a><br/>
<a href='./mul.html'>MULTIPLICATION</a><br/>
<a href='./div.html'>DIVISION</a><br/>
</form>
add.html:
<form action='./add'>
Enter First Number: <input type='text' name='fno'/><br/>
<input type='submit' value='add'/>
</form>
sub.html:
<form action='./sub'>
<input type='submit' value='sub'/>
</form>
mul.html:
<form action='./mul'>
<input type='submit' value='mul'/>
</form>
div.html:
<form action='./div'>
<input type='submit' value='div'/>
</form>
public class AddServlet extends GenericServlet{

@Override
public void service(ServletRequest req, ServletResponse res)
int i = Integer.parseInt(req.getParameter("fno"));
int j = Integer.parseInt(req.getParameter("sno"));
int k = i+j;
out.println("result is: "+k);
}
}
public class SubServlet extends GenericServlet{

@Override
int k = i-j;
}
public class MulServlet extends GenericServlet{

@Override
int k = i*j;
}
public class DivServlet extends GenericServlet{

@Override
int k = i/j;
}
}
<web-app>
<servlet>
<servlet-class>AddServlet</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
<servlet-name>sub</servlet-name>
<servlet-class>SubServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>sub</servlet-name>
<url-pattern>/sub</url-pattern>
</servlet-mapping><servlet>
<servlet-name>mul</servlet-name>
<servlet-class>MulServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>mul</servlet-name>
<url-pattern>/mul</url-pattern>
</servlet-mapping><servlet>
<servlet-name>div</servlet-name>
<servlet-class>DivServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>div</servlet-name>
<url-pattern>/div</url-pattern>
</servlet-mapping>
</web-app>
In the above we are unnecessarily using 4 servlet classes.

Then Servlet container will create objects that means,
Internally memory unnecessarily wasted to avoid this problem
we should go for the following approach.
Servlet API hierarchy:

Upto now we observed, servlet API
is using for carrying the data from browser
to server and server to browser.
For carrying input and output values
servlet technology supplying different
objects like bellow.
 servlet initialization values.
 request input values
 response output values
 attributes values
1. ServletContext and ServletConfig object
are meant for carrying the servlet
initialization values.
2. ServletRequest and HttpServletRequest
objects are meant for carrying request
input values.
3. ServletResponse and HttpServletResponse
meant for carrying response output values.
4. ServletRequest, HttpSession,
ServletContext objects are meant for carry
attribute values.
5. RequestDispatcher objects are meant
for making a communication between one
servlet to another servlet.
6. HttpSession and Cookie meant for
carrying a specific client session values.
ServletConfig: It will use to read the initialization values from

web.xml file. ServletConfig will read data in the form of key and
value pair combination.
To provide the initialization values from web.xml file

We need to use one new tag like <init-param>.
In this tag we have two sub tags.
1. <param-name>
2. <param-value>
<init-param> is the sub tag of <servlet>.
We can write multiple <init-param> tags in <servlet>
In the following program we are reading database details from

web.xml file by using ServletConfig object.
After that we are making communication with db and
inserting one record.
ServletConfig object is not only reading the data related to database

(driver,url,system,manager) but also we can able read any type of
data from web.xml file.
Servlet1.java
public class Servlet1 extends GenericServlet{
int a;
int b;
@Override
public void init(ServletConfig sc)throws
ServletException{
System.out.println("servlet1 intit method:
");
System.out.println("config: "+sc);
a =
Integer.parseInt(sc.getInitParameter("p1"));
b =
Integer.parseInt(sc.getInitParameter("p2"));
}
@Override
out.println("The Result is: "+(a+b));
}
}
Web.xml:
<web-app>
<servlet>
<servlet-name>s1</servlet-name>
<servlet-class>Servlet1</servlet-class>
<init-param>
<param-name>p1</param-name>
</init-param>
<init-param>
</init-param>
</servlet>
<servlet-mapping>
<url-pattern>/s1</url-pattern>
</servlet-mapping>
</web-app>
ServletConfifDemo.java
public class ServletConfigDemo extends GenericServlet {

@Override
String driver = sc.getInitParameter("driver");
String url = sc.getInitParameter("url");
String username = sc.getInitParameter("username");
String password = sc.getInitParameter("password");
try{
con = DriverManager.getConnection(url,username,password);
int count = st.executeUpdate("insert into empram
values(444,'nidhi',5757,'nw')");
}
catch(Exception e){
}
}
@Override
public void service(ServletRequest req,ServletResponse res)
if(con!=null){
out.println("connection created");
}
else{
out.println("connection not established");
}
}
}
Web.xml:
<web-app>
<servlet>
<servlet-name>sc</servlet-name>
<servlet-class>ServletConfigDemo</servlet-class>
<init-param>
<param-name>driver</param-name>
<param-value>oracle.jdbc.driver.OracleDriver</param-value>
</init-param>
<init-param>
<param-name>url</param-name>
<param-value>jdbc:oracle:thin:@localhost:1521:xe</param-value>
</init-param>
<init-param>
<param-name>username</param-name>
<param-value>system</param-value>
</init-param>
<init-param>
<param-name>password</param-name>
<param-value>manager</param-value>
</init-param>
</servlet>
<servlet-mapping>
<url-pattern>/sc</url-pattern>
</servlet-mapping>
</web-app>
In the above we are always placing same type of record
If we want place different types of records, we should
Go for following program.
<body bgcolor="pink">
<form action="./sc">
Enter Employee Number:
<input type="text" name="eno"/><br/>
Enter Employee Name :
<input type="text" name="ename"/><br/>
Enter Employee Salary:
<input type="text" name="esal"/><br/>
Enter Employee dept :
<input type="text" name="edept"/><br/>
<input type="submit" value="Enter"/>
</form>
</body>
ServletConfigDemo.java
public class ServletConfigDemo extends GenericServlet {

@Override
String username = sc.getInitParameter("username");
try{
con = DriverManager.getConnection(url,username,password);
}
catch(Exception e){
}
}
@Override
public void service(ServletRequest req,ServletResponse res)throws
int eno = Integer.parseInt(req.getParameter("eno"));
String ename = req.getParameter("ename");
int esal = Integer.parseInt(req.getParameter("esal"));
String edept = req.getParameter("edept");
if(con!=null){
try {
int count = st.executeUpdate("insert into empram
values("+eno+",'"+ename+"',"+esal+",'"+edept+"')");
}
}
else{
}
}
}
Web.xml:
<web-app>
<servlet>
<servlet-class>ServletConfigDemo</servlet-class>
<init-param>
</init-param>
<init-param>
</init-param>
<init-param>
</init-param>
<init-param>
</init-param>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
In above program we are passing initialization values to

single servlet individually at a time by using
<init-param> tag.
Whatever the data we are giving ServletConfigDemo

class that data will be not shared by the remaining servlet
classes.
If we want to provide a common data for all servlets

At a time, we need write those details in
<context-param>.
Whatever data we have in <context-param>, that

data will placed into ServletContext object, for
one project container will create only one
Servletcontext object, this object will be equally
shared by the all servlet class with in the project.
Program on ServletContext Object:
public class FirstServlet extends GenericServlet {

@Override
ServletContext sc1 = sc.getServletContext();
String driver = sc1.getInitParameter("driver");
String url = sc1.getInitParameter("url");
String username = sc1.getInitParameter("username");
String password = sc1.getInitParameter("password");
try{
Class.forName(driver);//NPE
con =
}
catch(Exception e){
}
}
@Override
public void service(ServletRequest req,ServletResponse
res)throws
int eno = Integer.parseInt(req.getParameter("eno"));
if(con!=null){
try {
int count = st.executeUpdate("insert into
empram values("+eno+",'"+ename+"',"+esal+",'"+edept+"')");
}
}
else{
}
}
}
public class SecondServlet extends GenericServlet {

@Override
ServletContext sc1 = sc.getServletContext();
String driver = sc1.getInitParameter("driver");
String url = sc1.getInitParameter("url");
String username = sc1.getInitParameter("username");
String password = sc1.getInitParameter("password");
try{
con =
}
catch(Exception e){
}
}
@Override
public void service(ServletRequest req,ServletResponse
res)throws
if(con!=null){
try {
empram");
while(rs.next()){
}
}
}
else{
}
}
}
<body bgcolor="pink">
<form action="./fs">
Enter Employee Number: <input type="text"
name="eno"/><br/>
Enter Employee Name : <input type="text"
name="ename"/><br/>
Enter Employee Salary: <input type="text"
name="esal"/><br/>
Enter Employee dept : <input type="text"
name="edept"/><br/>
<input type="submit"
value="Enter"/>
</form>
</body>
<web-app>
<context-param>
<param-value>oracle.jdbc.driver.OracleDriver</param-
value>
</context-param>
<context-param>
<param-
value>jdbc:oracle:thin:@localhost:1521:xe</param-value>
</context-param>
<context-param>
</context-param>
<context-param>
</context-param>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Program on ServletConfig getInitParameterNames():
Web.xml:
<web-app>
<servlet>
<servlet-class>SCServlet</servlet-class>
<init-param>
</init-param>
<init-param>
</init-param>
<init-param>
</init-param>
<init-param>
</init-param>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
SCServlet.java
import java.util.Enumeration;
public class SCServlet extends GenericServlet {

String[] s = new String[4];
int[] ia = new int[4];
@Override
public void init(ServletConfig sc )throws
ServletException{
Enumeration<String> e= sc.getInitParameterNames();
int i=0;
int j=0;
while(e.hasMoreElements()) {
s[i] = e.nextElement();
ia[j]=
Integer.parseInt(sc.getInitParameter(s[i]));
++i;
++j;
}
}
@Override
int total=0;
for(int i=0;i<ia.length;i++) {
total= total+ia[i];
}
out.println("<center><font size='6' color='black'>The Result
Is: "+(total)+"</center>");
}
}
Drawbacks of GenericServlet:
-----------------------------------
When ever client sending the request data, that data will be
attached to browser URL and visible to everyone so security
problem.
We cannot get http protocol specification like
 Security:
Whatever we entered in the .html file all the data will added to
browser url. So there is no security for securable data.
 Client state persistence.
 RequestHeader information.
 Session tracking
No redirecting process.
To overcome that problems we should go for HttpServlet
interface.
Http Protocol:
----------------
Http is a communication channel between web client (browser)
and web server (tomcat) for data exchanging.
Http is a stateless protocol.
The meaning of stateless protocol is once response is
committed, it(server) doesn’t remember old client (request).
If we are sending one more request to server, http will treat
the same client as new client.
If we are using http, every request will be treated as new
client.
Http is a specification.
That means it will provide rules and guidelines to web client
and web server.
Set of rules for web client development is called

Httpclientspecification.
Set of rules for httpserver development is called
httpserverspecification.
httpclientspecification describes the following responsibilities

to web client.
1. preparing http request with user input data.
2. sending the request to server.
3. reading output from httpresonse object and handover
to enduser.
httpserverspecification describes the follwing responsibilities
to httpserver
1. reading the data from webclient and converting into
httpservletrequest object.
2. finding the request resource.
3. and executing service(-,-) method by sending
httpservletrequest and response object.
4. preparing httpresonse object
5. finally handover to webclient.
Q) When should we use doGet(-,-), doPost(-,-), doPut(-,-),
doDelete(-,-) in Servlet?
1. doGet(-,-) is useful for reading webresource from

webserver.
2. doPost(-,-) is useful for placing/creating new resource in the
webserver.
3. doPut(-,-) is useful for updating webresource in webserver.
4. doDelete(-,-) is useful for delete the webresource from
webserver.
Note: by default these methods are not doing any operation on
webserver, based on queries or code only operations will perform.
In the above diagram if we are writing method=’ram’ by default

control goes to doGet(-,-) only.
Sample program on HttpServlet:

public class HttpServletDemo extends HttpServlet {
@Override
public void doPut(HttpServletRequest req,
HttpServletResponse res)
out.println("This http servlet program");
}
}
<web-app>
<servlet>
<servlet-class>HttpServletDemo</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
<body bgcolor='red'>
<form action="./hs" method='get'>
<input type='submit' value='click'/>
</form>
</body>
Why ServletContainer not calls doXxx()?
These method are specific to http protocol specifications.
If container calls doXxx() directly, then other protocol
requests cannot be processing.
Why servletcontainer not call protected service (HSReq,

HSres)?
The reason is these objects are stored in SReq, SRes
objects, so first public service(-,-) method will call by
ServletContainer to get HSReq, HSRes objects.
What is safe and unsafe methods in Servlet?

A) The methods, which are not modifying data on server is
called safe method, otherwise we can called as unsafe
methods.
Safe methods: Get,Head,Options,Trace
Un safe methods: Post,Put,Delete
Q) Who will call doXxx() methods?

A) protected service(HSR,HSR)
Servlet Container always calls first public service(-,-).
If not avialable it will calls protected service(-,-).
If not available it will doGet(-,-).
doPut(- ,-),doHead(- ,-),doDelete(- ,-),doOptions(- ,-),doTrace(
- ,-) methods will calls doGet(-,-).
How many way can we communicating with doPost()?

Only one way.
That is <form> method attribute.
Ex:
<form action=’./hs’ method=”POST”>
Whenever we writing like
<form action=’./hs’ method=’get/post’>
control goes to doGet(- ,-).
The main difference between doGet() and doPost()
is data will be add browser url bar.
there may be a change loss of security, to overcome
this problem we will go for doPost().
public class HttpServletDemo extends HttpServlet {
/*@Override
public void service (ServletRequest req,
ServletResponse res)
out.println("This is HttpServlet-public service");
}
@Override
protected void service (HttpServletRequest req,
out.println("This is HttpServlet-protected service");
}*/
@Override
protected void doGet (HttpServletRequest req,
out.println("This is HttpServlet-doGet()");
}
@Override
protected void doPost (HttpServletRequest req,
out.println("This is HttpServlet-doPost()");
}
}
//@WebServlet("/as")
public class AddServlet extends HttpServlet {
/*@Override
public void doPost (HttpServletRequest req,
int fno =
Integer.parseInt(req.getParameter("fno"));
int sno =
Integer.parseInt(req.getParameter("sno"));
out.println("This is HttpServlet-doPost <br/>");
out.println("Result: "+result);*/
@Override
public void doGet (HttpServletRequest req,
int fno =
Integer.parseInt(req.getParameter("fno"));
int sno =
Integer.parseInt(req.getParameter("sno"));
out.println("This is HttpServlet-doGet() <br/>");
out.println("Result: "+result);
Enumeration headerNames =
req.getHeaderNames();
while(headerNames.hasMoreElements()){
String headerName = (String)
headerNames.nextElement();
out.println(headerName+"<br/>");
String headerValue =
req.getHeader(headerName);
out.println(headerValue+"<br/>");
}
}
}
fno: <input type='text' name="fno"/>
sno: <input type='text' name="sno"/>

</form>
</body>

<form action="./hs" method='get/put' >
</form> -->
</body>


</form>
</body> -->

<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>

How to print the database data in table format in servlet:
Input.html:
<html>
<body bgcolor='yellow'>
<form action='./db' method='GET'>
<input type='submit' value='EMPLOYEEDETAILS'/>
</form>
<form action='./db' method='POST'>
<input type='submit' value='NEWRECORDS'/>
</form>
</body>
</html>
Web.xml:
<web-app>
<servlet>
<servlet-name>db</servlet-name>
<servlet-class>com.nit.ram.DBServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>db</servlet-name>
<url-pattern>/db</url-pattern>
</servlet-mapping>
</web-app>\
DBServlet.java:
package com.nit.ram;
public class DBServlet extends HttpServlet {
Connection con;
Statement st;
@Override
try{
con=DriverManager.getConnection(
"jdbc:oracle:thin:@localhost:1521:xe", "system", "manager");
st=con.createStatement();
}catch(ClassNotFoundException c){
System.out.println("----------------");
c.printStackTrace();
}catch(SQLException c){
System.out.println("****************");
c.printStackTrace();
}
}
@Override
public void doGet(HttpServletRequest request,HttpServletResponse
response)throws ServletException,IOException{
out.println("<body bgcolor='pink'>");
out.println("<tr><th>EID</th><th>ENAME</th><th>ESAL</th></tr>");
try {
employee");
while(rs.next()){
out.println("<tr><td>"+rs.getInt(1)+"</td><td>"+
rs.getString(2)+"</td><td>"+rs.getInt(3)+"</td></tr>");
}
System.out.println("^^^^^^^^^^^^^^^^^^^^^");
}
}
@Override
public void doPost(HttpServletRequest request,HttpServletResponse
try {
int count=st.executeUpdate(
"insert into employee values(106,'raj',6500)");
out.println(count+".Record Inserted.......");
System.out.println("#########################");
}
}
}
Differences between doGet() and doPost()?
doGet():
1. It is design for getting the data from server
2. Data will visible in brower url.
3. We can not send secure data.
4. We can send only limited data.
5. We can send only 1024 characters data
6. We can’t upload files the reason is url supports only
characters but not binary format data
7. We have four approaches to work with doGet().
a. By default browser
b. By method=’get’
c. Writing data directly in URL.
d. By using HyperLink.
doPost():
1. It is design for uploading the data into server
2. Data will not visible in brower url.
3. We can send secure data.
4. We can send unlimited data.
5. There is no limitation for data sending.
6. We can upload files
7. We have only one approaches to work with doPost().
a. By method=’get’
Write a program to communicating doGet() by using hyperlink:

Test.html:
<html>
<form>
<a href='./rd'>CLICK_HERE</a>
</form>
</body>
</html>
RequestDemo.java
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class RequestDemo extends HttpServlet{
@Override
public void doPost(HttpServletRequest
request,HttpServletResponse
out.println("<h2>THIS IS REQUESTDEMO DOGET
METHOD</H2>");
}
}
Working Servlet without Eclipse:
1. Download apache tomcat software.
2. Install the appache tomcat.
Develop project structure as bellow.
develop Add.html File:

--------------------------
<html>
<body bgcolor="Red">
<form action="./as" method="Get">
Enter First Number: <input type="text" name="fno"/>
Enter Second Number: <input type="text" name = "sno"/>
<input type="submit" value="add"/>
</form>
</body>
</html>
and save into folder like ServeltDemo(ProjectFolder)
develop AddServlet.java file:

--------------------------------
public class AddServlet extends HttpServlet{
@Override
public void doGet(HttpServletRequest req,
HttpServletResponse res)throws
int fno = Integer.parseInt(req.getParameter("fno"));
int sno = Integer.parseInt(req.getParameter("sno"));
out.println("Result is: "+result);
}
}
and saved into ServletDemo/WEB-INF/classes folder.
develop web.xml file:

==============
<web-app>
<servlet>
<servlet-name>as</servlet-name>
</servlet>
<servlet-mapping>
<url-pattern>/as</url-pattern>
</servlet-mapping>
</web-app>
and placed into ServletDemo/WEB-INF folder
open command prompt and set classpath for servlet-api.jar file

like bellow:
set classpath=.;C:\Program Files\Apache Software Foundation
\Tomcat 8.0\lib\servlet-api.jar;
compile the AddServlet.java program.

for this goto classes folder like bellow:
C:\Users\lenovo\Desktop> cd ServletDemo (enter)
C:\Users\lenovo\Desktop\ServletDemo>cd WEB-INF (ender)
C:\Users\lenovo\Desktop\ServletDemo\WEB-INF\cd classes
(enter)
C:\Users\lenovo\Desktop\ServletDemo\WEB-INF\classes>
javac AddServlet.java
we will get AddServlet.class file in the same classes folder.
Copy the entire our project (ServletDemo) and paste into

C:\Program Files\Apache Tomcat Foundations\Tomcat 8.0\
"webapps" folder.
goto Tomcat 8.0\bin folder and double click on startup

batchfile
and recongnize http port number in the server console like
http-nio-4445 at end of ther server console
open browser and send a request to server like bellow.

http://localhost:4445/ServerDemo/Add.html (enter)
enter first and second values add click on ADD button.
we will get output like Result: <value> based on your
input values.
Note: If we are working with any jar files placed those jar files
into WEB-INF/lib folder.
Servlet Collabaration or chainging or communication:
making a communication between one servlet to another

servlet is called servlet chaining.
1. creating one servlet object within the another servlet and

call service(-,-)
2. use getServlet() of ServletContext interface.(depricated)
3. RequestDispatcher
--> forward(-,-)
--> include(-,-)
ServletChainingDemo1.java
public class ServletChainingDemo1 extends GenericServlet{
@Override
public void init(ServletConfig sc )throws ServletException{
System.out.println("scd1 init method");
}
@Override
System.out.println("scd1 service method");
ServletChainingDemo2 sd = new
ServletChainingDemo2();
sd.service(req,res);
}
}
ServletChainingDemo2.java
public class ServletChainingDemo2 extends GenericServlet{
ServletConfig sc1 = null;

@Override
public void init(ServletConfig sc )
throws ServletException{
System.out.println("scd2 init method");
sc1 = sc;
}
@Override
System.out.println("scd2 service method");
if(sc1 == null){
System.out.println("config object not created by the container");
}
else
System.out.println("config object created by the container");
}
}
<web-app>
<servlet>
<servlet-name>sc1</servlet-name>
<servlet-class>ServletChainingDemo1</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/sc1</url-pattern>
</servlet-mapping>
<servlet>
<servlet-class>ServletChainingDemo2</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/sc2</url-pattern>
</servlet-mapping>
</web-app>
In the above approach container is not executing init(-) of second

servlet aswell as GenericServlet class, so we are unable workwith
SerlvetConfig object of second servlet, if we are calling
getServletConfig() of GenericServlet we will get null. To avoiding
above approach we should go for RequestDispatcher interface.

static{
System.out.println("static block-servlet1");
}
ServletContext sc1;
ServletConfig sc2;
@Override
ServletException{
System.out.println("init method-servlet1");
System.out.println("sc: "+sc);
sc1 = sc.getServletContext();
sc2=sc;
}
@Override
ServletResponse response){
System.out.println("service method-servlet1");
System.out.println("this: "+this.hashCode());
System.out.println("thread:
"+Thread.currentThread().getName());
System.out.println("request: "+request.hashCode());
System.out.println("response:
"+response.hashCode());
System.out.println("scontext: "+sc1);
System.out.println("sconfig: "+sc2);
System.out.println("==================");
Servlet2 obj = new Servlet2();
obj.service(request, response);
}
}

static{
System.out.println("static block-servlet2");
}
ServletContext sc1;
ServletConfig sc2;
@Override
ServletException{
System.out.println("init method-servlet2");
sc1 = sc.getServletContext();
sc2=sc;
}
@Override
ServletResponse response){
System.out.println("service method-servlet2");
System.out.println("this: "+this.hashCode());
System.out.println("thread:
"+Thread.currentThread().getName());
System.out.println("request: "+request.hashCode());
System.out.println("response:
"+response.hashCode());
System.out.println("scontext: "+sc1);
System.out.println("sconfig: "+sc2);
}
}
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
To avoiding this problem we should use one method that is

getServlet() of ServletContext interface.
With the help of this method will get automatic static loading
and initialization as well as non-static loading and initialization
phases and finally calls service method.
But it is deprecated in servlet version, if we writing program on top
of this method we will exception
ServletContext sct=req.getServletContext();
System.out.println("sct: "+sct);
SecondServlet ss =
(SecondServlet)sct.getServlet("./sc2");
System.out.println("ss: "+ss);
The above code is not use full in new servlet versions. To avoiding
above problems we have the best approach in Servlet concept that is
RequestDispatcher.
RequestDispatcher is use full for making a communication
between one servlet to another Servlet,.jsp,.html,.txt files. We can
achieve this object by using one method that is
getRequestDispathcer(-) of ServletRequest object finally.
We need to use two method like forward(-,-) and include(-,_

methods.
In above mechanisam only servlet2 response will added to browser

In the above mechanisam both Servlet one and two response will
add to browser.
With help of RequestDispatcher we can able to communicating with

the following resources.
1. Servlet.
2. JSP Files.
3. Html files.
4. Normal Text Files.
We can able access RequestDispatcher object by using

following syntax’s:
RequestDispatcher rd1 = request.getRequestDispatcher(-);
RequestDispatcher rd2 =
getServletContext().getRequestDispatcher(-);
Program on both forward(-,-) and include(-,-)
@Override
out.println("<h1>THIS IS SERVLET-1 RESPONSE</H1>");
out.println("<h1>S1-Request:"+request.hashCode()
+"</h1>");
out.println("<h1>S1-Response:"+response.hashCode()
+"</h1>");
request.getRequestDispatcher("./s2");
//rd.forward(request, response);
}
}
@Override
out.println("<body bgcolor='Green'>");
out.println("<h1>THIS IS SERVLET-2 RESPONSE</H1>");
out.println("<h1>S2-Request:"+request.hashCode()
+"</h1>");
out.println("<h1>S2-Response:"+response.hashCode()
+"</h1>");
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
@Override
System.out.println("servlet-1 init method");
}
@Override
System.out.println("servlet1 service method");
out.println("<H1>THIS IS SERVLET-1 SERVICE");
//RequestDispatcher rd = req.getRequestDispatcher("./s2");
//rd.forward(req, res);
//rd.include(req, res);
//RequestDispatcher rd1 = req.getRequestDispatcher("./hello.html");

//RequestDispatcher rd1 = req.getRequestDispatcher("./first.jsp");
RequestDispatcher rd1 = req.getRequestDispatcher("./second.txt");
rd1.forward(req, res);
out.println("<H1>THIS IS SERVLET-1 RESPONSE");
@Override
}
@Override
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Hello.html:
<h1>THIS IS HTML FILE</h1>
First.jsp
<h1>THIS IS JSP FILE</h1>
second.txt:
<h1>THIS IS NORMAL TEXT FILE</h1>
Rewrite the above Servlet1.java as bellow
@Override
public void init(ServletConfig sc)
throws ServletException{
}
@Override
RequestDispatcher rd = req.getRequestDispatcher("./s2");
//rd.forward(req, res);
rd.include(req, res);
RequestDispatcher rd1=req.getRequestDispatcher("./hello.html");
rd1.include(req, res);
/*RequestDispatcher rd2=req.getRequestDispatcher("./first.jsp");
rd2.forward(req, res);
RequestDispatcher rd3=req.getRequestDispatcher("./second.txt");
rd3.forward(req, res);*/
}
}
After writing the forward(-,-) in servlet don’t use forward(-,-).
If we are using forward(-,-), servletcontainer will raises exception.
If we are using include(-,-), servletcontainer will raises exception,

but the result is not commited browser.
But after writing include(-,-), we can able to write forward(-,-) or

include(-,-) methods again in the same servlet.
forward(-,-) not carrying the response information, whereas

include(-,-) will carrying the response information from either
servlet or html file or jsp file or normal text files.
sndRedirect(-):
This method is useful forwarding the request from one Servlet

to another webresource (Servlet/jsp) within the same project in
same Servlet or different projects in same server or different
projects in different server.
This method is available in HttpServletResponse object.
This method always making a new request to destination

webresource.
sendRedirect(-) not shares Request object information, only

sharing session and context object information.
Destination webresouce response always handover to browser

or enduser.
Source webcomponent(Servlet) will executes first later

destination Servlet.
This method contains only one parameter of String

type(destination webresource path).
public class Servlet1 extends HttpServlet{
@Override
//res.sendRedirect("https://www.google.com");
res.sendRedirect("./s2");

}
}

@Override
}
@Override
}
}
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Program on sendRedirect(-) for checking charing the request scope

object data sharable or not:
User.html:
<html>
<body bgcolor='wheat'>
<form action='./s1' method='get'>
Enter user Name: <input type = 'text'
name="uname"/>
<input type='submit' value='submit'/>
</form>
</body>
</html>
Servlet1.java
static{
System.out.println("servlet1-static block");
}
@Override
public void doGet(HttpServletRequest request,
HttpServletResponse response)throws
ServletException,
IOException{
String s1 = request.getParameter("uname");
request.setAttribute("uname", s1);
//request.getRequestDispatcher("./s2").forward(request,
response);
response.sendRedirect("./s2");
//response.sendRedirect("http://localhost:3016/SRD2/s
3");
}
}
Servlet2.java
static{
}
@Override
ServletException,
IOException{
String s1 = (String) request.getAttribute("uname");
out.println("<h1>THIS SERVLET-TWO RESPONSE");
out.println("End User Name Is: "+s1+"</h1>");
}
}
Web.xml:
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Program on sendRedirect(-) for checking charing the sesssion scope
User.html:
<html>
name="uname"/>
</form>
</body>
</html>
Servlet1.java
static{
}
@Override
ServletException,
IOException{
session.setAttribute("uname", s1);
3");
}
}
Servlet2.java:
static{
}
@Override
ServletException,
IOException{
String s1 = (String)
session.getAttribute("uname");
}
}
Web.xml:
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Program on sendRedirect(-) for checking sharing the context scope
User.html:
<html>
name="uname"/>
</form>
</body>
</html>
Servlet1.java
static{
}
@Override
ServletException,
IOException{
ServletContext sc = getServletContext();
sc.setAttribute("uname", s1);
3");
}
}
Servle2.java:
static{
}
@Override
ServletException,
IOException{
String s1 = (String)sc.getAttribute("uname");
}
}
Web.xm:
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Whenever we make request from one project Servlet to

another project Servlet through sendRedirct(-), no data
will be shared between both the servlets.
How share data between one project to another project:

Test1 project:
TestServlet1.java
public class TestServlet1 extends HttpServlet{

static{
System.out.println("testservlet1 loading");
}
@Override
//response.sendRedirect("./s3");
//response.sendRedirect("http://localhost:3016/Test
2/s2");
response.sendRedirect("https://www.google.com");
response.sendRedirect(http://localhost:3016/Test2/s2?
user=ram”);
out.println("THIS IS TESTSERVLET1 RESPONSE");
}
}
TestServlet3.java
static{
@Override
Web.xml:
<web-app>
<servlet>
<servlet-class>TestServlet1</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Test2 Project:
TestServlet2.java
static{
@Override
String username=request.getParameter("user");
out.println("username: "+username);
Web.xml:
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Multiple Project communication within the server by using

RequestDispatcher:
SquareServletProject:
SquareServlet.java:
package com.aj.rd;
public class SquareServlet extends HttpServlet{
@Override
HttpServletResponse
response)
out.println("<body bgcolor='cyan'>");
String num = request.getParameter("num");
int no = Integer.parseInt(num);
int square = no*no;
out.println("<h2>Square Of The Given Number
Is: "+square+"</h2><br/>");
ServletContext sct1 = getServletContext();
ServletContext sct2 =
sct1.getContext("/CubeServletProject");
sct2.getRequestDispatcher("/cs");
}
}
Web.xml:
<web-app>
<servlet>
<servlet-
class>com.aj.rd.SquareServlet</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<welcome-file-list>
<welcome-file>input.html</welcome-file>
</web-app>
Input.html:
<html>
<body bgcolor='orangered'>
<form action='./ss'>
Enter Number For Square and Cube:
<input type='text' name='num'/><br/>
<input type='submit' value='ENTER'/>
</form>
</body>
</html>
CubeServletProject:
CubeServlet.java:
package com.aj.rd;
public class CubeServlet extends HttpServlet{
@Override
HttpServletResponse
response)
String num = request.getParameter("num");
int no = Integer.parseInt(num);
int cube = no*no*no;
out.println("<h2>Cube Of The Given Number Is:
"+cube+"</h2><br/>");
}
}
Web.xml:
<web-app>
<servlet>
<servlet-name>cs</servlet-name>
<servlet-class>com.aj.rd.CubeServlet</servlet-
class>
</servlet>
<servlet-mapping>
<servlet-name>cs</servlet-name>
<url-pattern>/cs</url-pattern>
</servlet-mapping>
</web-app>
Note: Deploy both the projects at a time into server.
Do following changes in
Servlers/ApacheTomcat/context.xml fle in eclipse like
bellow
<Context crossContext=’true’>
</Context>
Program on HttpServletRequest about parameters:

If we have morethan one text field on top of same name and trying
to read all the values from all text field we should go for one method
like getParameterValues(-).
If we have only one text field on top of one name and trying to read
the data from that table we should prefer method like
getParameter(-).
First.html
<html>
<body bgcolor='pink'>
<form action="./s1">
Enter Name: <input type='text' name='name'/><br/>
<table>
<tr>
<td>Courses</td>
</tr>
<tr>
<td>Course1</td>
<td><input type='text' name="course" value=''/>
</tr>
<tr>
<td>Course2</td>
</tr>
<tr>
<td>Course3</td>
</tr>
<tr>
<td>Course4</td>
</tr>
</table>
<input type='submit' value='CLICK'/>
</form>
</body>
</html>
@Override
out.println("<H1>THIS IS SERVLET-1 SERVICE</H1><br/>");
String name = req.getParameter("name");
out.println("Name: "+name);
String[] s = req.getParameterValues("course");
for(String s1: s){
out.println(s1+"<br/>");
}
}
}
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>

@Override
out.println("<H1>THIS IS SERVLET-1 SERVICE</H1><br/>");
Enumeration e= req.getParameterNames();
while(e.hasMoreElements()){
String tfn = (String) e.nextElement();
String tfv = req.getParameter(tfn);
out.println(tfn+"...."+tfv);
}
}
}
<html>
Enter Name : <input type='text' name='name'/><br/>
Enter Age : <input type='text' name='age'/><br/>
Enter course: <input type='text' name='course'/><br/>
Enter fee : <input type='text' name='fee'/><br/>

</form>
</body>
</html>
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Program on getPrameterNames() and header information:

Without having any idea on text field names which are avialble in
.html file .jsp file, if we want to read text field names and its related
content better choose method like getParameterNames().
@Override
out.println("<H1>THIS IS SERVLET-1
SERVICE</H1><br/>");
Enumeration e= req.getParameterNames();
String tfn = (String) e.nextElement();
String tfv = req.getParameter(tfn);
out.println(tfn+"...."+tfv);
Enumeration<String> e1 = req.getHeaderNames();
while(e1.hasMoreElements()){
String headerName = e1.nextElement();
String headerValue = req.getHeader(headerName);
out.println(headerName+":::"+headerValue);
System.out.println(headerName+"::"+headerValue);
}
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
<html>
Enter Age : <input type='text' name='age'/><br/>
Enter course: <input type='text' name='course'/><br/>
Enter fee : <input type='text' name='fee'/><br/>

</form>
</body>
</html>
Program On getParameterMap():
This method will read the data like text filed name and its
values in the format of Map object from ServletRequest Object.
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class RequestDemo extends HttpServlet{
@Override

Map<String,String[]>map =request.getParameterMap();
Set<Map.Entry<String,String[]>> set = map.entrySet();
Iterator <Map.Entry<String,String[]>> it = set.iterator();
while(it.hasNext()){
System.out.println("---------------");
Map.Entry<String,String[]> ent= it.next();
out.println(ent.getKey()
+"..."+Arrays.toString(ent.getValue()));
}
Program on Attributes of HttpServletRequest Object:
@Override
out.println("<H1>THIS IS SERVLET-1
SERVICE</H1><br/>");

req.setAttribute("username",name);
req.getRequestDispatcher("./s2");
rd.forward(req, res);
}

@Override
String userName = (String) req.getAttribute("username");
out.println("UserName Is: "+userName);
}
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
<html>
<body bgcolor='Yellow'>
</form>
</body>
</html>
Session Tracking
What is Session?
It is a specific time period or interval to interact with server.
What is Session Tracking?
Recongnize client state at some particular period of time as a same

client is called Session Tracking.
HttpServlet is always working with HttpProtocol.
HttpProtocol is stateless protocol.
Every time this protocol will treat client as a new client.
To recognize client as a old client or same client we should
go for Session Tracking.
We can achieve session tracking by using the following four ways.
a. Cookie
b. Hidden Form Fields
c. URL Rewriting
d. HttpSession
Cookie:
It is a plain textual information.
It contains key and value.
It is useful recognize the client persistence(state).
Whenever we make request to server at first time only rquest

data are handover to server, but in the response we can add cookie
object in the form key-value pair combinations.
These are stored in browser cache.
Whenever client making second request, along with request

cookie object is also coming to server, then server will read that
cookie and finally recognize that client/request old client/request.
Cookies are two types.
a. Persisntence cookie.
b. Non-persistance cookie.
Non-Persistance cookie:
The cookie are available upto before closing browser are called
Non-persistance cookies.
Persistance cookie:
The cookies are available after closing the browser also

available upto enduser signout or logout is called persistence cookie.
This is simple technique and existed at client side.
The drawback of cookie is we can send only textual information.
Once browser side if we are disable the cookie we unable maintain

session tracking.
Programm on cookie:
import javax.servlet.http.Cookie;
@Override
out.println("In servlet1: "+name);

Cookie c = new Cookie("name", name);
res.addCookie(c);
out.println("<form action='./s2' method='get'>");
out.println("<input type='submit' value='click' >");
@Override

/*Cookie[] c = req.getCookies();
out.println("in servlet 2: "+c[0].getValue());
*/
}
<html>
</form>
</body>
</html>
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Program on cookie:
Index.html:
<html>
<body>
<form>
<a href="./login.html">Login</a><br/>
<a href="./los">LogoutServlet</a><br/>
<a href="./ps">ProfileServlet</a><br/>
<input type='submit' value="submit"/>
</form>
</body>
</html>
Login.html:
<html>
<form action="./ls">
Enter your name: <input type='text' ame='name'/><br/>
Enter your password: <input type='text'
name='password'/><br/>
</form>
</html>
Link.html:
<a href="./login.html">Login</a><br/>
<a href="./los">LogoutServlet</a><br/>
<a href="./ps">ProfileServlet</a><br/>
LoginServlet.java:
public class LoginServlet extends HttpServlet {
protected void doGet(HttpServletRequest request,

PrintWriter out=response.getWriter();
request.getRequestDispatcher("./link.html");
String name=request.getParameter("name");
String password=request.getParameter("password");
if(password.equals("naaz")){
out.print("<br/>You are successfully logged in!<br/>");
out.print("<br/>Welcome, "+name);
Cookie ck=new Cookie("name",name);
response.addCookie(ck);
}else{
out.print("<br/>sorry, username or password error!");
request.getRequestDispatcher("login.html").include(request,
response);
out.close();
LogoutServlet.java
public class LogoutServlet extends HttpServlet {

request.getRequestDispatcher("link.html").include(request,
response);
Cookie ck=new Cookie("name","");
ck.setMaxAge(0);
response.addCookie(ck);
out.print("<br/>you are successfully logged out!");
ProfileServlet.java
public class ProfileServlet extends HttpServlet {

request.getRequestDispatcher("link.html").include(request,
response);
Cookie ck[]=request.getCookies();
if(ck!=null){
String name=ck[0].getValue();
if(!name.equals("")||name!=null){
out.print("<br/><b>Welcome to Profile</b>");
out.print("<br/>Welcome, "+name);
}else{
out.print("<br/>Please login first");
request.getRequestDispatcher("login.html").include(request,
response);
out.close();
Web.xml:
<web-app>
<servlet>
<servlet-name>ls</servlet-name>
<servlet-class>LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/ls</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>los</servlet-name>
<servlet-class>LogoutServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>los</servlet-name>
<url-pattern>/los</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>ps</servlet-name>
<servlet-class>ProfileServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ps</servlet-name>
<url-pattern>/ps</url-pattern>
</servlet-mapping>
</web-app>
How to add multiple cookies to response object:
User.html:
<html>
<body bgcolor='cyan'>
<form action='./ts'>
Enter User Name: <input type='text'
name='username'/><br/>
Enter User password: <input type='text' name='password'/>
<input type='submit' value='login'/>
</form>
</body>
</html>
Web.xml:
<web-app>
<servlet>
<servlet-class>com.ram.aj.cookie.TestServlet</servlet-
class>
</servlet>
<servlet-mapping>
<url-pattern>/ts</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>ds</servlet-name>
<servlet-class>com.ram.aj.cookie.DisplayServlet</servlet-
class>
</servlet>
<servlet-mapping>
<url-pattern>/ds</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>user.html</welcome-file>
</web-app>
TestServlet.java
package com.ram.aj.cookie;
public class TestServlet extends HttpServlet{
@Override
public void doPost(HttpServletRequest request,
HttpServletResponse response )
String username = request.getParameter("username");
String password = request.getParameter("password");
Cookie c1 = new Cookie("user",username);
Cookie c2 = new Cookie("password",password);
response.addCookie(c1);
response.addCookie(c2);
pw.println("<body bgcolor='orangered'>");
pw.println("<h2>In TestServlet user is:
"+username+"<br/>");
pw.println("In TestServlet password is:
"+password+"</h2>");
pw.println("<form action='./ds'>");
pw.println("<input type='submit' value='clickme'/>");

pw.println("</form>");
pw.println("</body>");
}
@Override
doPost(request,response);
}
}
DisplayServlet.java:
package com.ram.aj.cookie;
public class DisplayServlet extends HttpServlet{
@Override
public void doPost(HttpServletRequest request,
Cookie[] c = request.getCookies();
System.out.println(c.length);
String username=null;
pw.println("<body bgcolor='red'>");
for(Cookie c1: c){
System.out.println(c1.getValue());
pw.println("<h2>In DisplayServlet user is:
"+c1.getValue()+"</h2>");
}
pw.println("</body>");
}
@Override
doPost(request,response);
}
}
Program on Cookie between more than two servlets:
Login.html:
<html>
<form action='./s1'>
Enter Student Name: <input type='text'
name='uname'/><br/>
Enter Student pawd:<input type='password'
name='upwd'/><br/>
<input type='submit' value='Login'/>
</form>
</body>
</html>
Servlet1.java:
package com.ram.proj1;
public class Servlet1 extends HttpServlet {
@Override
String name = request.getParameter("uname");
String pwd = request.getParameter("upwd");
out.println("hello "+name+" from servlet1<br/>");
Cookie c = new Cookie("uname", name);
response.addCookie(c);
System.out.println("request from servlet1: "+request);
System.out.println("response from servlet1: "+response);
out.println("<form action='./s2'>");
out.println("<input type='submit' value='click'>");
}
Servlet2.java:
@Override
Cookie[] c1 = request.getCookies();
if(c1==null){
out.println(" You are not recongized as same client");
else{
String name = c1[0].getValue();

out.println("Hellow.."+name+" You are recongized as same client
servlet2");
out.println("<form action='./s3'>");
out.println("<input type='submit' value='click'>");
Servlet3.java:
@Override
Cookie[] c1 = request.getCookies();
if(c1==null){
out.println(" You are not recongized as same
client......");
}
else{
String name = c1[0].getValue();
out.println("Hellow.."+name+" You are recongized as same

client.......Servlet3");
}
}
}
Web.xml:
<web-app>
<servlet>
<servlet-class>com.ram.proj1.Servlet1</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
In the above program we are always using same request and
response objects.
Program on hidden form fields:
User.html:
<html>
<form action='./fs'>
Enter Your Name: <input type='text'
name='name'/><br/>
Enter Your Password: <input
type='password' name='password'/><br/>
</form>
</body>
</html>
FirstServlet.java:
@Override

response)
String name = request.getParameter("name");
if(password.equals("suji")){
out.println("you are successfully loged in<br/>");
out.println("Mr. "+name);
out.println("<form action='./ss'>");
out.println("<input type='hidden' name='uname'

value='"+name+"'/>");
out.println("<input type='submit'
value='submit'/>");
else{
out.println("sorry your password incorrect....");
request.getRequestDispatcher("./user.html").include(request,
response);
SecondServlet.java
@Override

response)
String user = request.getParameter("uname");
out.println("Welcome mr: "+user+"<br/>");

request.getRequestDispatcher("./user.html").include(request,
response);
Web.xml:
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
How to disable cookies in browser:
 Go to right top most corner of browser and

click on three dot symbols.
 Go to settings.
 Click on advance settings.
 Goto private and security.
 Goto content settings.
 Click on cookies option. Then choose disable
mode.
User.html:
<html>
<body bgcolor='gold'>
<form action='./cs1'>
Enter Your Name:<input type='text'
name='uname'/><br/>
</form>
</body>
</html>
Web.xml:
<web-app>
<servlet>
<servlet-name>cs1</servlet-name>
<servlet-class>CookieServlet1</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/cs1</url-pattern>
</servlet-mapping>
<servlet>
<servlet-class>CookieServlet2</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/cs2</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>user.html</welcome-file>
</web-app>
CookieServlet1.java:
public class CookieServlet1 extends HttpServlet{
@Override
public void doGet(HttpServletRequest

response)
String name = request.getParameter("uname");
out.println("<center> WELCOME Mr. "+name);
Cookie c = new Cookie("uname",name);

response.addCookie(c);
out.println("<form action='./cs2'>");
out.println("<input type='submit'
value='submit'></center>");
CookieServlet2.java:
public class CookieServlet2 extends HttpServlet{
@Override
Cookie[] c= request.getCookies();
int i=0;
if(c!=null) {
while(i<c.length) {
out.println(c[i].getName()+"..."+c[i].getValue()+"<br/>");
i=i+1;
out.println("welcome mr. "+c[0].getValue());
else {
out.println("NO cookie information");
}
}
Hidden Form Filed:
o It is one HTML web component.

o It is not visible on browser. But it is internally stick or
attach with the browser.
o It will store the data.
o We can able to adding the data into this hidden form field
by using only “value” attribute.
o Syntax: <input type=’hidden’ name=’hff’ value=’kirn’/>
Program on hidden form fileds:
@Override

String username = req.getParameter("name");
out.println("In servlet1: "+username);
out.println("<form action='./s2' method='get'>");
out.println("<input type='hidden' name='hname'

value='"+username+"'/><br/>");
out.println("<input
type='submit'value='submit'/><br/>");

@Override
String username = req.getParameter("hname");
out.println("Servlet-Hidden: "+username);
}
<html>
Enter Name:<input type='text' name='name'/><br/>
</form>
</body>
</html>
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Program on url rewriting:
@Override

out.println("<a href='./s2?
name="+username+"'>visit</a>");
@Override
out.println("Servlet-Hidden: "+username);
}
}
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
<html>
</form>
</body>
</html>
@Override
HttpSession session = req.getSession();
session.setAttribute("enduser",username);
req.getRequestDispatcher("./s2");
@Override
HttpSession session = req.getSession();
String enduserName =
(String) session.getAttribute("enduser");
out.println("servlet2-session: "+enduserName);
}
}
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
<html>
</form>
</body>
</html>
Filter:
--> Is one java object(JEE).
--> Is one web component is usesd for
developing web application like servlet and jsp
--> It is one servlet container/server managed
java object.
--> Like Servlet, Filter is also having life cycle
methods.
like init(-)
destroy()
doFilter(-,-,-)
All the above methods are calling by ServletContainer.
Thats why we are calling filter is one servlet container
managed object.
It is acting as mediator between brower and servlet.

Usage:
Checks Logging details valid or not
(verification/validation)
Validation will talks about are we enter data or
not, where as verification talks about whatever the
data we enter those values are valid or not.
Checks whether end user valid or not(
Authentication)
Doing some common operations for all servlets.
Creating our Request and Response objects.
Types of Filters:
If we want to execute or process any logic before

servlet logic after servlet logic exectuion, we should
use filter.
Based on above pointer Filters are classified into two
types.
a. Pre Filter:
Before logic of servlet execution, filter logic will
be executes.
b. Post Filter:
After logic of servlet execution, filter logic will
be executes.
C. Pre-Post Filter:
Before and after servlet code execution, if we are
executing Filter code, that we consider as pre-
post filter.
In filter concept we have Three main import interfaces.

a. Filter: It is useful for developing web
applications.
b. FilterConfig: It is useful for reading the data
from web.xml file under <init-param> tags. Every
Filter object having their own Filter-Config
object
c. FilterChain: It is useful for making
communication between Filter to Servlet.
Both Filter and FilterChain interfaces having one

common method name is doFilter().
But Filter and FilterChain interface doFilter() method
functionalities are different from one to another.
What is difference between doFilter(-,-,-) of Filter

interface and doFilter(-,-) FilterChain interface:
doFilter(-,-,-) of Filter interface:

1. This is a life cycle method of Filter.
2. We should override this method in our filter
class.
3. Calling and execution every thing taken care by
servlet container by default.
4. It is having 3 parameters like ServletRequest,
ServletResponse, FilterChain.
5. Acutal logic like authentication, logging details
verification and writing common logic of all
servlets we need write in this method.
doFilter(-,-) of FilterChain interface:

1. This is a not life cycle method of FilterChain.
2. No need override this method in our filter class.
3. Servelt Container not calling and execute this
method by default, program should call.
4. It is having 2 parameters like ServletRequest,
ServletResponse.
5. This method is useful making communication
between filter to servlet.
Filter object always creating by Servletcontainer
meanwhile of loading the byte code from secondary
memory to primary memory.
Methods in FilterConfing interface:

1. getFilterName()
2. getInitParameter()
3. getInitParameterNames()
4. getServletContext()
Life cycle phases of Filter:
a. Loading phase: ByteCode loading

secondary memory to primary memory.
b. Instantiation phase: ServletContainer will
creating object for Filter.
c. Initializaiton phase: ServletContainer will
uses Filter object and calls init method and
injecting FilterConfig object.
Before starting Loading phase only Servlet
container will creates FilterConfig object.
d. Serviceing phase: In this phase Servlet
container will uses Filter object and calling
doFilter method and inject ServlerRequest,
ServletResponse, FilterChain object.
e. Destroying phase: Once we undeploy
project from servler, ServletContainer itself
calls destroy() and make that object eligible for
GarbageCollection.
The first three phases of Servlet, ServletContainer

directly not executes with the support of <load-on-
startup> tag, ServletContainer will execute first three
phases.
But in Filter no need to give any information to

ServletContainer to execute first three phases, while
deploy our filter project servletcontainer will get
details from web.xml file and executes first three
phases of a Filter. We we make a request doFilter(-,-,-)
is executing.
How to work filter without Servlet:

MyFilter.java
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
public class MyFilter implements Filter {
@Override
public void init(FilterConfig fc )throws
ServletException{
System.out.println("filter - init method");
}
@Override
public void doFilter(ServletRequest requst,
ServletResponse arg1, FilterChain arg2)
throws IOException, ServletException {
System.out.println("doFilter method");
}
@Override
public void destroy(){
System.out.println("destroy method-filter");
}
}
Web.xml:
<web-app>
<filter>
<filter-name>mf</filter-name>
<filter-class>MyFilter</filter-class>
</filter>
<filter-mapping>
<url-pattern>/mf</url-pattern>
</filter-mapping>
</web-app>
Program on Filter to provide response to browser:
Input.html:
<html>
<form action='./mf'>
<input type='submit' value='SUBMIT'/>
</form>
</body>
</html>
MyFilter.java:
public class MyFilter implements Filter{

@Override
public void init(FilterConfig fc) throws
ServletException{
System.out.println("Init Method of MyFilter
class");
}
@Override
public void doFilter(ServletRequest request,
ServletResponse response, FilterChain chain)
out.println("<body bgcolor='pink'><h2>");
out.println("doFiler Method of MyFilter
class");
out.println("</h2></body>");
}
@Override
System.out.println("destroy method of
MyFilter class");
}
}
Web.xml:
<web-app>
<filter>
</filter>
<filter-mapping>
</filter-mapping>
<welcome-file-list>
</web-app>
Program on FilterConfig object:
MyFilter.java:
FilterConfig fc=null;
@Override
public void init(FilterConfig fc )throws
ServletException{
System.out.println("filter - init method");
System.out.println("fc: "+fc);
this.fc = fc;
}
@Override
public void doFilter(ServletRequest requst,
ServletResponse response,
FilterChain chain)
System.out.println("doFilter method");
String fno = fc.getInitParameter("fno");
String sno = fc.getInitParameter("sno");
int i = Integer.parseInt(fno);
int j = Integer.parseInt(sno);
out.println("<body bgcolor='yellow'>The
Result is: "
+(i+j)+"</body>");
}
@Override
public void destroy(){
System.out.println("destroy method-filter");
}
}
Web.xml
<web-app>
<filter>
<init-param>
</init-param>
<init-param>
</init-param>
</filter>
<filter-mapping>
</filter-mapping>
</web-app>
Proramming on filter:
@Override
System.out.println("Filter destroy()");
}
@Override
public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {
System.out.println("Filter doFilter()");
out.println("file executing before servlet<br/>");
chain.doFilter(req, res);
out.println("file executing after servlet<br/>");
}
@Override
public void init(FilterConfig arg0) throws ServletException {
System.out.println("Filter init()");
public class MyServlet extends GenericServlet {
@Override
out.println("MyServlet is processing the request<br/>");
<web-app>
<servlet>
<servlet-class>MyServlet</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<filter>
</filter>
<filter-mapping>
</filter-mapping>
</web-app>
<form action="./ms">
</form>
@Override
}
@Override
String username = req.getParameter("username");
String password = req.getParameter("password");
if(password.equals("ramchandra")){
System.out.println("if");
}
else{
System.out.println("else");
RequestDispatcher rd = req.getRequestDispatcher("./test.html");
rd.include(req,res);
}

}
@Override
}
}
@Override
}<body bgcolor='yellow'>
Enter UserName: <input type='text' name='username'/><br/>
Enter Password: <input type='password' name='password'/><br/>
</form>
</body>
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<filter>
</filter>
<filter-mapping>
</filter-mapping>
</web-app>
Enter UserName : <input type='text' name='username'/><br/>
Enter Password : <input type='password' name='password'/><br/>
Enter Employee Id: <input type='text' name='eid'/><br/>
Enter Employee Name:<input type ='text' name='ename'/><br/>
Enter Employee Sal: <input type='text' name='esal'/><br/>
Enter Employee Dept: <input type='text' name="edept"/>
</form>
</body>

@Override
@Override
String username = req.getParameter("username");
String password = req.getParameter("password");
if(username.equals("yaane") &&
password.equals("ramchandra")){
else{
System.out.println("else");
RequestDispatcher rd = req.getRequestDispatcher("./test.html");
rd.include(req,res);
}
@Override
Connection con;
Statement st;
@Override
System.out.println("init method of myservlet");
String driver = sc.getInitParameter("driver1");
System.out.println("driver: "+driver);
String url = sc.getInitParameter("url1");
String username = sc.getInitParameter("username1");
String password = sc.getInitParameter("password1");
try {
con =
catch (ClassNotFoundException e) {
System.out.println("catch block-CNFE");
System.out.println("catch block-SQL");
@Override

int eid = Integer.parseInt(req.getParameter("eid"));
try {
int updatecount= st.executeUpdate("insert into

sbajemp values("+eid+",'"+ename+"',"+esal+",'"+edept+"')");
out.println("Number Of records inserted:

"+updatecount);
System.out.println("service-catch");
Or
Connection con;
//Statement st;
@Override
System.out.println("init method of myservlet");
String driver = sc.getInitParameter("driver1");
System.out.println("driver: "+driver);
String url = sc.getInitParameter("url1");
String username = sc.getInitParameter("username1");
String password = sc.getInitParameter("password1");
try {
con = DriverManager.
getConnection(url,username,password);
//st = con.createStatement();
}
catch (ClassNotFoundException e) {
System.out.println("catch block-CNFE");
System.out.println("catch block-SQL");
@Override
int eid = Integer.parseInt(req.getParameter("eid"));
try {
//int updatecount=
//st.executeUpdate("insert into sbajemp values(
//"+eid+",'"+ename+"',"+esal+",'"+edept+"')");
"insert into sbajemp values(?,?,?,?)");
ps.setInt(1, eid);
ps.setInt(3, esal);
ps.setString(4, edept);
out.println("Number Of records inserted: "+updatecount);
System.out.println("service-catch");
}
<web-app>
<servlet>
<init-param>
<param-name>driver1</param-name>
</init-param>
<init-param>
<param-name>url1</param-name>
</init-param>
<init-param>
<param-name>username1</param-name>
</init-param>
<init-param>
<param-name>password1</param-name>
</init-param>
</servlet>
<servlet-mapping>
</servlet-mapping>
<filter>
</filter>
<filter-mapping>
</filter-mapping>
</web-app>
FilterConfig object is created by servlet container meanwhile of loading

MyFilter.class file from secondary memory to primary memory.
Meanwhile creating FilterConfig object by container, it will <param-name>

and <param-value> information of <init-param> of <filter> in web.xml file.
Those values will be inject into FilterConfig object. Later that object will be
placed into init(FilterConfig fc) of MyFilter class.
We can read these values again form our application by using one method of
FilterConfig object that is getInitParameter(-).
Special scenario:
<web-app>
<filter>
<filter-name>first</filter-name>
</filter>
<filter-mapping>

<servlet-name>fms</servlet-name>
</filter-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<welcome-file-list>
<welcome-file>login.html</welcome-file>
</web-app>
html action attribute value and servlet-mapping tag url-pattern value not
match request is not forward to servlet, it will check filter url-pattern
value if match controle goes to only filter otherwise request not going
filter also.
html action attribute value and servlet-mapping tag url-pattern value

match then container will check filter-mapping tag url-pattern.
If not match only servlet execute if match first filter executing later
servlet executing.
If filter-mapping tag contains servlet-name then servlet tag servlet-name

and filter-mapping servlet-name should have same value.
If not only servlet executes otherwise first filter executes later servlet
executing.
<web-app>
<filter>
<filter-class>MyFilter1</filter-class>
</filter>
<filter>
<filter-name>second</filter-name>
</filter>
<filter-mapping>
</filter-mapping>
<filter-mapping>
</filter-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<welcome-file-list>
</web-app>
Filter execution order depend upon <filter-mapping> tag order in web.xml file
from top to bottom.
<web-app>
<filter>
</filter>
<filter>
</filter>
<filter-mapping>
</filter-mapping>
<filter-mapping>
</filter-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<welcome-file-list>
</web-app>
Container always gives first preference to <url-pattern> only later <Servlet-
name> in this time <filter-mapping> order not usefull.
How to make relation between multiple filter to Servlet individually:
<web-app>
<filter>
</filter>
<filter-mapping>
</filter-mapping>
<filter>
</filter>
<filter-mapping>
<url-pattern>/fms</url-pattern>
</filter-mapping>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet-mapping>
<url-pattern>/fms</url-pattern>
</servlet-mapping>
</web-app>
Listeners
Liserners are java objects.
These are listening or getting some information from

ServletContainer mean while of scope object creation by container
for doing some special operations in background.
This scope object creation information handover by Event classes to

listener.
Providing information about scope object is technically called as

EventSource
Here scope object means session,context,request.
Listeners will doing that operations by using EventHandlerClasses.
Programon listener:
public class TestServlet extends GenericServlet{

@Override
System.out.println("servlet1 servicece method");
ServletContext sc = req.getServletContext();
String name = (String) sc.getAttribute("name");
System.out.println("name: "+name);
}
}
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
public class ServletContextHandler implements ServletContextListener{
@Override
public void contextDestroyed(ServletContextEvent arg0) {
System.out.println("servletcontext is destroyed");
ServletContext sc = arg0.getServletContext();
sc.removeAttribute("name");
@Override
public void contextInitialized(ServletContextEvent arg0) {
System.out.println("servletcontext is created");
ServletContext sc = arg0.getServletContext();
sc.setAttribute("name", "ram");
}
<web-app>
<listener>
<listener-class> ServletContextHandler</listener-class>
</listener>
<servlet>
<servlet-class>TestServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/test</url-pattern>
</servlet-mapping>
</web-app>
Program on Listener with DB:
Web.xml:
<web-app>
<welcome-file-list>
<welcome-file>Testing.html</welcome-file>
<listener>
<listener-class>DBListener</listener-class>
</listener>
<servlet>
<servlet-class>SelectServlet</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<servlet>
<servlet-name>is</servlet-name>
<servlet-class>InsertServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>is</servlet-name>
<url-pattern>/is</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>us</servlet-name>
<servlet-class>UpdateServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>us</servlet-name>
<url-pattern>/us</url-pattern>
</servlet-mapping>
<servlet>
<servlet-class>DeleteServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/ds</url-pattern>
</servlet-mapping>
</web-app>
Testing.html:
<html>
<body bgcolor='black'>
<form action='./ss'>
<input type='submit' value='SELECT'/>
</form>
<form action='./is'>
<input type='submit' value='INSERT'/>
</form>
<form action='./us'>
<input type='submit' value='UPDATE'/>
</form>
<form action='./ds'>
<input type='submit' value='DELETE'/>
</form>
</body>
</html>
DBListener.java:
public class DBListener implements ServletContextListener {

Connection con= null;
@Override
public void contextInitialized(ServletContextEvent
event) {
System.out.println("initalized executing");
try {
ServletContext sc = event.getServletContext();
"jdbc:oracle:thin:@localhost:1521:xe"
,"system",
"annie");
sc.setAttribute("connection", con);
} catch (Exception e) {
System.out.println("=================");
}
}
@Override
public void contextDestroyed(ServletContextEvent
event) {
System.out.println("destroyed method
executing");
try {
if(con!=null) {
con.close();
}
}catch(Exception e) {
System.out.println("****************");
}
}
}
SelectServlet.java
public class SelectServlet extends GenericServlet {

@Override
ServletException,
IOException{
System.out.println("servlet service method");
try {
ServletContext sc =
request.getServletContext();
Connection con = (Connection)
sc.getAttribute("connection");
sbaj9to11");
while(rs.next()) {
out.println(rs.getInt(1)+"-----"+rs.getString(2)+"----"+
rs.getInt(3)+"----"+rs.getInt(4)+"<br/>");
}
}
}
}
InsertServlet.java:
public class InsertServlet extends GenericServlet {

@Override
ServletException,
IOException{
try {
ServletContext sc =
values(104,'annie',25,4000)");
out.println(count+"Record inserted......");
}
}
}
UpdateServlet.java:
public class UpdateServlet extends GenericServlet {
@Override
ServletResponse response)throws ServletException,
IOException{
try {
ServletContext sc = request.getServletContext();

"update sbaj9to11 set sname='vani' where sid=101");
out.println(count+".record updated");
DeleteServlet.java:
public class DeleteServlet extends GenericServlet {

@Override
ServletException,
IOException{
try {
ServletContext sc =
int count=st.executeUpdate(
"delete from sbaj9to11 where sid =
103");
out.println(count+".record deleted");
}
}
}
Program on FilterConfig interface:
FilterConfig config;
@Override
@Override
String myname = config.getInitParameter("myname");
out.println("myname: "+myname+"</br>");
@Override
public void init(FilterConfig fc)
throws ServletException {
config = fc;
@Override
}
<web-app>
<servlet>
</servlet>
<servlet-mapping>
</servlet-mapping>
<filter>
<init-param>
<param-name>myname</param-name>
<param-value>ramchandra</param-value>
</init-param>
</filter>
<filter-mapping>
</filter-mapping>
</web-app>
Program on ServletContextListener, ServletRequestListener,

HttpSessionListener:
ServletContextEventHandler.java:
package com.aj.lsnr;
public class ServletContextEventHandler
implements
ServletContextListener{
@Override
public void
contextDestroyed(ServletContextEvent sce) {
System.out.println("contextDestroyed
method");
ServletContext sct =
sce.getServletContext();
sct.removeAttribute("faculty");
}
@Override
public void
contextInitialized(ServletContextEvent sce) {
System.out.println("contextInitializedmethodm
starts");
sct.setAttribute("faculty",
"ramchandra");
ends");
}
}
ServletRequestEventHandler.java:
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
public class ServletRequestEventHandler
implements
ServletRequestListener{
@Override
public void
requestDestroyed(ServletRequestEvent sre) {
System.out.println("RequesttDestroyed
method-requst");
ServletRequest sr =
sre.getServletRequest();
sr.removeAttribute("fage");
}
@Override
public void
requestInitialized(ServletRequestEvent sre) {
System.out.println("RequestInitializedmethodm
starts-request");
ServletRequest sr =
sre.getServletRequest();
sr.setAttribute("fage", "30");
System.out.println("RequestInitializedmethodm
ends-request");
}
}
HttpSessionEventHandler.java”:
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import org.apache.catalina.SessionEvent;
public class HttpSessionEventHandler implements
HttpSessionListener{
@Override
public void sessionCreated(HttpSessionEvent
hse) {
System.out.println("sessioncreated
starts");
HttpSession hs = hse.getSession();
hs.setAttribute("fsal", "7000");
System.out.println("sessioncreated
ends");
}
@Override
public void
sessionDestroyed(HttpSessionEvent hse) {
System.out.println("sessiondestroyed");
HttpSession hs = hse.getSession();
hs.removeAttribute("fsal");
}
}
ReadListenerServlet.java:
/* aathor = "ram"
* version= 1.8
* insttute=nit
*/
public class ReadListenerServlet extends
HttpServlet{
@Override
request,
ServletException,
IOException{
System.out.println("doGet method");
getServletContext();
String facultyname =
(String)sct.getAttribute("faculty");
System.out.println("facultyname:
"+facultyname);
String fage =
(String)request.getAttribute("fage");
System.out.println("fage: "+fage);
HttpSession hs = request.getSession();
String fsal =
(String)hs.getAttribute("fsal");
System.out.println("fsal: "+fsal);
}
}
Web.xml:
<web-app>
<listener>
<listener-
class>com.aj.lsnr.ServletContextEventHandler</l
istener-class>
</listener>
<listener>
<listener-
class>com.aj.lsnr.ServletRequestEventHandler</l
istener-class>
</listener>
<listener>
<listener-
class>com.aj.lsnr.HttpSessionEventHandler</list
ener-class>
</listener>
<servlet>
<servlet-name>rls</servlet-name>
<servlet-
class>com.aj.lsnr.ReadListenerServlet</servlet-
class>
</servlet>
<servlet-mapping>
<servlet-name>rls</servlet-name>
<url-pattern>/rls</url-pattern>
</servlet-mapping>
</web-app>
How to develop dynamic web project without web.xml file:
To develop DWProject(to communicate with servlet) we required

mainly two components.
a. web.xml
b. Annotation
To communicating with servlet through annotation we required one

annotation like @WebServlet(“/url_name”);
In the above ‘/’ is mandatory.
Before ‘/’ don’t keep dot(.) operator.
Example:
<form action="./ts">
<input type="submit" value="go"/>
</form>
import javax.servlet.annotation.WebServlet;
@WebServlet("/ts")//@WebServlet(value=”/ts”)
public class TestServlet extends GenericServlet{
@Override
out.println("<h1>This is Test Servlet</h1>");
import javax.servlet.annotation.WebInitParam;
//@WebServlet("/rls")
//@WebServlet(value="/rls")
//@WebServlet({"/as","/ms"})
//@WebServlet(value={"/as1","/ms1"})
//@WebServlet("/*")
@WebServlet(loadOnStartup=1,
urlPatterns={“/as”,”/ms”}
//@WebServlet(urlPatterns={"/as","/ms"})
@WebServlet(value = "/rls", initParams = {
@WebInitParam(name = "faculty", value
= "Ramchandra"),
@WebInitParam(name = "age", value =
"...30!")
})
HttpServlet{
@Override
request,
ServletException,
IOException{
System.out.println("doGet
method......");
System.out.println("1.
"+getServletConfig().getInitParameter("faculty"
));
"+getServletConfig().getInitParameter("age"));
"+getServletContext().getInitParameter("faculty
"));
"+getServletContext().getInitParameter("age"));
}
}
Above InitParam only comes under ServletConfig
ReadListenerServlet.java:
//@WebServlet("/rls")
//@WebServlet(value="/rls")
@WebServlet(value = "/rls", initParams = {
@WebInitParam(name = "faculty", value
= "Ramchandra"),
@WebInitParam(name = "age", value =
"...30!")
})
HttpServlet{
@Override
request,
ServletException,
IOException{
method......");
"+getServletConfig().getInitParameter("faculty"
));
"+getServletConfig().getInitParameter("age"));
"+getServletConfig().getServletContext().getIni
tParameter("faculty"));
"+getServletConfig().getServletContext().getIni
tParameter("age"));
}
}
MyFilter.java:
import javax.servlet.annotation.WebFilter;
@WebFilter(urlPatterns = {"/rls"}, initParams = {
@WebInitParam(name = "user", value = "nit")})
public void init(FilterConfig config) throws

ServletException {
String username = config.getInitParameter("user");
System.out.println("username: "+username);
public void doFilter(ServletRequest request,

ServletResponse response,
FilterChain chain) throws IOException,

ServletException {
chain.doFilter(request,response);
}
public void destroy( ) {
Program @WebListener:
import javax.servlet.annotation.WebListener;
@WebListener
public class ServletContextEventHandler
implements
ServletContextListener{
@Override
public void
contextDestroyed(ServletContextEvent sce) {
System.out.println("contextDestroyed
method");
sct.removeAttribute("faculty");
}
@Override
public void
contextInitialized(ServletContextEvent sce) {
starts");
sct.setAttribute("faculty",
"ramchandra");
ends");
System.out.println("***********"+sct.getAttribu
te("faculty"));
}
}
ReadListenerServlet.java
@WebServlet(name= "ReadListenerServlet",
value="/rls")
HttpServlet{
@Override
request,
ServletException,
IOException{
method......");
getServletContext();
"+sct.getAttribute("faculty"));
}
}
DBOperations
DBOperation.html:
<html>
<a href='./Select.html'>SELECT</a><br/>
<a href='./Insert.html'>INSERT</a><br/>
<a href='./Delete.html'>DELETE</a><br/>
<a href='./Update.html'>UPDATE</a><br/>
</body>
</html>
Select.html:
<html>
<form action='./dos' method='get'>
Enter Employee Number: <input type='text'
required name='eid'/>
<input type='submit' value='SELECT'/>
</form>
</body>
</html>
Insert.html:
<html>
<form action='./dos' method='POST'>
required name='eid'/><br/>
Enter Employee Name : <input type='text'
required name='ename'/><br/>
Enter Employee Salary: <input type='text'
required name='esal'/><br/>
Enter Employee age : <input type='text'
required name='eage'/><br/>
<input type='submit' name='btn'
value='INSERT'/>
</form>
</body>
</html>
Delete.html:
<html>
<form action='./dos' method='post'>
Enter Employee Number: <input type='text' required
name='eid'/>
value='DELETE'/>
</form>
</body>
</html>
Update.html:
<html>
<form action='./dos' method='post'>
required name='eid'/>
Enter Employee Update Sal: <input type='text'
required name='esal'/>
value='UPDATE'/>
</form>
</body>
</html>
Web.xml:
<web-app>
<servlet>
<servlet-name>dos</servlet-name>
<servlet-class>DBOServletDemo</servlet-class>
<init-param>
<param-
value>oracle.jdbc.driver.OracleDriver</param-value>
</init-param>
<init-param>
<param-
value>jdbc:oracle:thin:@localhost:1521:xe</param-
value>
</init-param>
<init-param>
<param-name>user</param-name>
</init-param>
<init-param>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dos</servlet-name>
<url-pattern>/dos</url-pattern>
</servlet-mapping>
</web-app>
DBOServletDemo.java
public class DBOServletDemo extends HttpServlet{
@Override
String user = sc.getInitParameter("user");
System.out.println("driver :"+driver);
System.out.println("url :"+url);
System.out.println("user :"+user);
System.out.println("password:"+password);
try{
System.out.println("try of init");
con=DriverManager.getConnection(url,user,password);
System.out.println("catch block of init");
}
@Override
out.println("<body bgcolor='red' ><h1>");
try{
System.out.println("try of doGet");
"select * from employee1 where eid=?");
int eid = Integer.parseInt(request.getParameter("eid"));
ps.setInt(1, eid);
while(rs.next()){
out.println(rs.getInt(1)+"\t"+rs.getString(2)+
"\t"+rs.getInt(3)+"\t"+rs.getInt(4));
System.out.println("catch block of doget");
}
@Override
public void doPost(HttpServletRequest request, HttpServletResponse
String operation = request.getParameter("btn");
if(operation.equalsIgnoreCase("insert")){
String ename = request.getParameter("ename");
int esal = Integer.parseInt(request.getParameter("esal"));
int eage = Integer.parseInt(request.getParameter("eage"));
try {
System.out.println("try block of dopost-insert");
con.prepareStatement("insert into employee1 values(?,?,?,?)");
ps.setInt(1, eid);
ps.setInt(3, esal);
ps.setInt(4, eage);
int count=ps.executeUpdate();
out.println(count+".records inserted");
System.out.println("catch of dopost-insert");
}
else if(operation.equalsIgnoreCase("delete")){
try {
System.out.println("try block of dopost-delete");
PreparedStatement ps = con.prepareStatement("delete from

employee1 where eid=?");
ps.setInt(1, eid);
System.out.println(count+".records deleted");
System.out.println("catch block dopost-delete");
else if(operation.equalsIgnoreCase("update")){
int usal = Integer.parseInt(request.getParameter("esal"));
try {
System.out.println("try block of dopost-update");
PreparedStatement ps = con.prepareStatement("update employee1 set

esal=esal+? where eid=?");
ps.setInt(1, usal);
ps.setInt(2, eid);
System.out.println(count+".records updated");
System.out.println("catch block of dopost-update");
How to work with servlet without eclipse:

FirstCreate project structure like bellow.
Add.html:
<html>
<form action='./as' method='GET'>
Enter First Number: <input type='text'
name='fno'/><br/>
Enter Second Number: <input type='text'
name='sno'/><br/>
<input type='submit' value='ADD'/>
</form>
</body>
</html>
Web.xml:
<web-app>
<servlet>
</servlet>
<servlet-mapping>
<url-pattern>/as</url-pattern>
</servlet-mapping>
</web-app>
AddServlet.java:
public class AddServlet extends HttpServlet{

@Override
int i =
Integer.parseInt(request.getParameter("fno"));
int j =
Integer.parseInt(request.getParameter("sno"));
int result=i+j;
out.println("Result: "+result);
}
}
Login.jsp:
<html>
<form action='./ls'>
Enter Your UserName:<input type='text'
Enter your Password:<input type='password'
Supplier<input type='radio' name='radio'
value='supplier'/>
Consumer<input type='radio' name='radio'
value='consumer'/>
<input type='submit' value='submit'
</form>
</body>
</html>
LoginServlet.java:
package controller;
public class LoginServlet extends GenericServlet{
@Override
RequestDispatcher rd = null;
String username =
request.getParameter("username");
String password =
request.getParameter("password");
String role = request.getParameter("radio");
if(username=="" && password =="") {

out.println("please enter username and
password <br/>");
rd =
request.getRequestDispatcher("./Login.jsp");
}
else
if(username==""){
out.println("please enter
username<br/>");
rd =
}
else if(password==""){
out.println("please enter
password<br/>");
rd =
}
else if(username.equals("ICSI518")
&&
password.equals("Spring2018")){
if(role.equals("supplier")){
out.println("<h2>welcome
Supplier<br/>");
out.println("Your Login Time Is:"+new
java.util.Date()+"</h2>");
}
else if(role.equals("consumer")){
Consumer<br/>");
out.println("Your Login Time Is:"+new
java.util.Date()+"</h2>");
}
}
else{
out.println("Invalid username
and password<br/>");
rd =
}
}
Web.xml:
<web-app>
<servlet>
<servlet-
class>controller.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<welcome-file-list>
<welcome-file>Login.jsp</welcome-file>
</web-app>
Login.jsp:
<html>
<form action='./ls'>
Enter Your UserName:<input type='text'
Enter your Password:<input type='password'
Supplier<input type='radio' name='radio'
value='supplier'/>
Consumer<input type='radio' name='radio'
value='consumer'/>
<input type='submit' value='submit'
</form>
</body>
</html>
LoginServlet.java:
package controller;
import Model.CheckUserModel;
public class LoginServlet extends GenericServlet{

@Override

response)
String username = request.getParameter("username");
String role = request.getParameter("radio");
System.out.println("role: "+role+".....");
CheckUserModel model = new CheckUserModel();
model.setUsername(username);
model.setPassword(password);
model.setRole(role);
String result = model.check();
if(result.equals("please enter username and password"))

{
out.println("please enter username and password

<br/>");
rd = request.getRequestDispatcher("./Login.jsp");
else
if(result.equals("please enter username")){
out.println("please enter username<br/>");
rd =
else if(result.equals("please enter password")){
out.println("please enter password<br/>");
rd = request.getRequestDispatcher("./Login.jsp");
else
if(result.equals("supplier")){
Supplier<br/>");
out.println("Your Login Time Is:"+new java.util.Date()

+"</h2>");
else if(result.equals("consumer")){
Consumer<br/>");
out.println("Your Login Time Is:"+new java.util.Date()

+"</h2>");
}
else if(result.equals("Invalid username and

password")){
out.println("Invalid username and

password<br/>");
rd =
else if(result.equals("please select role")){
out.println("please select role<br/>");
rd =
CheckUserModel.java:
package Model;
public class CheckUserModel {
private String username;
private String password;
private String role;
public void setUsername(String username) {

this.username = username;
}
public void setPassword(String password) {

this.password = password;
}
public void setRole(String role){

this.role = role;
}
public String check(){
if(username=="" && password =="") {
return "please enter username and
password";
}
else if(username==""){
return "please enter username";
}
else if(password==""){
return "please enter password";
}
else if(username.equals("ICSI518")
&&
password.equals("Spring2018")){
if(role !=null){
if(role.equals("supplier")){
return "supplier";
}
else if(role.equals("consumer"))
{
return "consumer";
}
}else return "please select role";
}
else{
return "Invalid username and
password";
}
return "please select role";

}
}
Web.xml:
<web-app>
<servlet>
<servlet-
class>controller.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<welcome-file-list>
<welcome-file>Login.jsp</welcome-file>
</web-app>
Uploading the file By using Zoom api:

Copying the file or transfor the file from client machine to server
machine is called file uploading or content or resource uploading.
To work file uploading by using Servlet api is little bit difficult so we

are always depend upon third party provided api. That is java zoom
api.
To uploading file we required the following .jar files like
Cos.jar
uploadBean.jar
Struts.jar file
Copy above jar file into lib folder.
Above three jar files existed int uploadBean1.9.jar file.
MultiPartFormDataRequest:
It will encapsulate the request object and holds MIME types

based form data(upload files)
UploadBean:
It will specifies destination folder in Server machine to save

upload file and allows to complete file uploading.
UploadFile:
This class object holds the details of each upload file.
Upload.html:
<html>
<head>
<title>THIS IS UPLOAD FILE CONCEPT</title>
</head>
<h1>WELCOME TO OUR WEBSITE::UPLOAD.HTML </h1>
<form action='uplurl' method='Post'
enctype="multipart/form-data">
Choose First File: <input type='file' name='file1'/>
<br/>
Choose Second File: <input type='file' name='file2'/>
<br/>
<input type='submit' value="upload"/>
</form>
</body>
</html>
UplServlet.java:
package com.kit;
import java.util.Hashtable;
import javazoom.upload.MultipartFormDataRequest;
import javazoom.upload.UploadBean;
import javazoom.upload.UploadException;
import javazoom.upload.UploadFile;
public class UplServlet extends HttpServlet{
@Override

req,HttpServletResponse res)
PrintWriter pw =null;
MultipartFormDataRequest nreq=null;
UploadBean upb = null;
Hashtable ht = null;
Enumeration e = null;
pw=res.getWriter();
try {
nreq = new MultipartFormDataRequest(req);
upb = new UploadBean();
upb.setFolderstore("C:/store");
upb.setOverwrite(false);
upb.store(nreq);
ht=nreq.getFiles();
e=ht.elements();
UploadFile file = (UploadFile)e.nextElement();
pw.println("<br/>"+file.getFileName()+"
"+file.getFileSize());
}
} catch (UploadException e1) {
Web.xml:
<web-app>
<servlet>
<servlet-name>uplurl</servlet-name>
<servlet-
class>com.kit.UplServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>uplurl</servlet-name>
<url-pattern>/uplurl</url-pattern>
</servlet-mapping>
</web-app>
File Downloading:
Means downloading the file or resource from server system to

clinet system.
This downloading has been classified into two types.
a. Resource Downloading
Means downloading either audio file, video file, .jpeg file

or any other files.
b. Response/output downloading.
Means downloading response either html, msword, msexcel, xml

format and etc…… Whatever the programs we done upto now, those
are related to response/output downloading process.
Example on Resource Downloading for images:
Here aroundly we need to do 11 steps.
a. Creating ServletContext object by using method like

getServletContext().
b. By using ServletContext object we need to recognize path
the downloading file by using getRealPath(-).
c. Later handover that path java.io.File class constructor to
calculate the size or length of the file by using length() of
java.io.File class.
d. After findout the length/size of the file we need to handover
that size to setContentLengthLong(-) of response object.
e. By using ServletContext object we need to recongnize MIME
type by using getMimeType(-).
f. Later handover that MIME type to response object by using
setContentType(-).
g. We add response details to response header by using
setHeader(-,-).
h. Later creating InputStream object for reading the data from
downloading file by using getResourceAsStream(-).
i. Creating ServletOutputStream object by using response
object method like getOutputStream().
j. Reading the file data from InputStream object by using
read()and handover that data to ServletOutputStream object
for writing purpose.
k. Finally close all the connections.
Index.html:
<form action='./downloadurl'>
<input type='submit' value='download'/>
</form>
</body>
DownloadServlet.java:
package com.kit;
import javax.servlet.ServletOutputStream;
public class DownloadServlet extends HttpServlet{
@Override
ServletContext sc = null;
File file = null;
String path=null;
long length=0;
String mimeType=null;
ServletOutputStream sos=null;
InputStream is = null;
byte[] buffer = new byte[4096];
int bytesRead=0;
sc = getServletContext();
path=sc.getRealPath("/ram.jpeg");
file = new File(path);
length = file.length();
res.setContentLengthLong(length);
mimeType=sc.getMimeType("/ram.jpeg");
res.setContentType(mimeType);
res.setHeader("content-disposition",
"attachment;fileName=ram.jpeg");;
is=sc.getResourceAsStream("/ram.jpeg");
sos = res.getOutputStream();
while((bytesRead=is.read(buffer))!=-1){
sos.write(buffer,0,bytesRead);
}is.close();sos.close();
}
@Override
doPost(req,res);
}
}
Web.xml:
<web-app>
<servlet>
<servlet-name>downloadurl</servlet-
name>
<servlet-
class>com.kit.DownloadServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>downloadurl</servlet-
name>
<url-pattern>/downloadurl</url-
pattern>
</servlet-mapping>
</web-app>
How to data form .properties files in webapplication

to communicating with oracledatabase:
InputStream in =
sc.getResourceAsStream("/WEB-INF/db.properties");
GetData.html:
<a href='./gd'>GETDATA</a>
</body>
Web.xml:
<web-app>
<servlet>
<servlet-name>gs</servlet-name>
<servlet-class>com.nit.GetServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/gd</url-pattern>
</servlet-mapping>
</web-app>
GetServlet.java:
package com.nit;
public class GetServlet extends GenericServlet {

@Override
requst,ServletResponse response)
{
try {
InputStream is = sc.getResourceAsStream("WEB-
INF/db.properties");
p.load(is);
String driver=p.getProperty("driver");
String user=p.getProperty("user");
String password=p.getProperty("password");
Connection con =
ResultSet rs=st.executeQuery("select*from sbaj6to8");
while(rs.next()){
"\t"+rs.getInt(3)+"\t"+rs.getInt(4));
}
} catch (Exception e) { e.printStackTrace();
}
}
}
Db.properties:
user=system
password=manager
Without connection pooling:
user.html:
<form action='./gd'>
Enter username: <input type='text' name="un"/>
Enter password: <input type='text' name='psd'/>
</form>
</body>
=================
GetServlet:
package com.nit;
public class GetServlet extends GenericServlet {

@Override
{
try {
String username = request.getParameter("un");
String passwords=request.getParameter("psd");
if(LoginDao.validate(username, passwords)){
System.out.println("user valid");
}
else {
System.out.println("invalid user");
}
System.out.println("-----------------");
}
}
}
LoginDao:
package com.nit;
public class LoginDao {

public static boolean validate(String
username,String password){
PreparedStatement ps = null;
Connection connection = null;
boolean status = false;

try{
connection = DbUtil.getConnection();
ps = connection.prepareStatement("select * from login
where username=? and password=?");
ps.setString(1, username);
ps.setString(2, password);
rs= ps.executeQuery();
status = rs.next();
}
return status;
}
}
DbUtil.java:
package com.nit;
public class DbUtil {
public static Connection getConnection(){

try{
1:xe",
}
catch(Exception e){
}
return con;
}
}
web.xml:
<web-app>
<servlet>
<servlet-class>com.nit.GetServlet</servlet-
class>
</servlet>
<servlet-mapping>
</servlet-mapping>
</web-app>
Serverside connection pooling:

Right click META-INF of webcontent 
newfilefilename must be context.xml and write
bellow code.
<Context>
<Resource
name="jdbc/UsersDB"
auth="Container"
type="javax.sql.DataSource"
maxActive="100"
maxIdle="30"
maxWait="10000"
driverClassName="oracle.jdbc.driver.OracleDriver"
url="jdbc:oracle:thin:@localhost:1521:xe"
username="system"
password="manager"/>
</Context>
GetData.html:
<form action='./gd'>
Enter username: <input type='text'
name="un"/><br/>
Enter password: <input type='text'
name='psd'/><br/>
</form>
</body>
GetServlet.java:
package com.nit;
public class GetServlet extends HttpServlet {

@Override
request,HttpServletResponse response)
{
HttpSession session=request.getSession();
PrintWriter out =null;
try {
out = response.getWriter();
String username = request.getParameter("un");
String passwords=request.getParameter("psd");
session.setAttribute("user", username);
if(LoginDao.validate(username, passwords)){
System.out.println("user valid");
rd=request.getRequestDispatcher("./welcome.jsp");
}
else {
System.out.println("invalid user");
out.println("Your username and password
are invalid");
rd=request.getRequestDispatcher("./GetData.html");
}
System.out.println("-----------------");
}
}
}
LoginDao.java:
package com.nit;
public class LoginDao {

public static boolean validate(String
username,String password){
PreparedStatement ps = null;
Connection connection = null;
boolean status = false;

try{
connection = DbUtil.getConnection();
ps = connection.prepareStatement("select * from login
where username=? and password=?");
ps.setString(1, username);
ps.setString(2, password);
rs= ps.executeQuery();
status = rs.next();
}
return status;
}
}
Dbutil.java:
package com.nit;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;
public class DbUtil {

public static Connection getConnection(){
try{
/*Class.forName("oracle.jdbc.driver.Orac
leDriver");
1:xe",
"system","manager");*/
Context context = new InitialContext();
DataSource ds =
(DataSource)context.lookup("java:comp/env/jdbc/UsersD
B");
con = ds.getConnection();
}
catch(Exception e){
}
return con;
}
}
Context.xml under META-INF:
<Context>
<Resource
name="jdbc/UsersDB"
auth="Container"
type="javax.sql.DataSource"
maxActive="100"
maxIdle="30"
maxWait="100000"
driverClassName="oracle.jdbc.driver.OracleDriver"
url="jdbc:oracle:thin:@localhost:1521:xe"
username="system"
password="manager"/>
</Context>
Welcome.jsp:
<html>
<form>
<%String username =
(String)session.getAttribute("user"); %>
Your are Valid User mr:
<%=username %>.......
</form>
</body>
</html>
Web.xml:
<web-app>
<servlet>
<servlet-class>com.nit.GetServlet</servlet-
class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<welcome-file-list>
<welcome-file>GetData.html</welcome-file>
</web-app>
Logintable:
Create table login(username varchar2(20),password
varchar2(20);
Commit;
Insert into login values(‘ram’,’kiran’);
Commit;
Web application Deployment process:

We have three types of deploye process in servlets
1.Cold deployement: copy the project into tomcat
server webapps folder and finally start the
server.
2.Hot deployement: Start server first later deploy
our project into server.
3.Using Ide’s.
Cold Deployment:
First set classpath for Servlet-api.jar file.

Go to src folder and our Servlet program like bellow.
Javac AdditionServlet.java.
Copy .class file from src folder and paste into
classes folder of WEB-INF folder.
Copy the project and paste into tomcat webapps
folder.
And goto bin folder and start the server.
Open browser and send request to our application like
bellow.
http://localhost:9998/AdditionServler/add
::How to deploy war file into tomcat(CONSOLE

DEPLOYMENT)::
Create our servlet project.
Create war file like bellow.
C:\Users\Ramchadar\Desktop\AdditionServlet>
Jar –cf addition.war *
1. Go to Tomcat bin folder and start server
2. Open browser and type bellow url for tomcat
manager
http://localhost:9998
3. Click on Manager app button top right of the
homepage
4. Enter username and password.
5. Goto War file to deploy option.
6. Click on choose file and select .war file and click

on deploy button.
7. Click on war file name under path field.
8. Enter url(alias name).
Like bellow
http://localhost:9998/addition/add
in above link addition is not project name it is just

war file name.
How to provide security in tomcat by using BASIC and
DISET:
Extract Server folder in eclipse and extract Tomcat
v9.0 Server at localhost-config.
Open tomcat-users.xml file and add bellow code in side
<tomcat-users> tag.
Add this bellow code between <tomcat-users> tag
outside of the html comments.
<role rolename="clerk"/>
<user username="kiran" password="kiran"
roles="clerk"/>
FirstServlet.java:
package com.ram;
public class FirstServlet extends HttpServlet{
req,HttpServletResponse res) throws IOException{
out.println("this is successfull page<br/>");
out.println("<center><b>user name:
"+req.getRemoteUser()+"</b></center><br/>");
out.println("<center><b>auth type:
"+req.getAuthType()+"</b></center><br/>");
}
}
Web.xml:
<web-app>
<servlet>
<servlet-class>com.ram.FirstServlet</servlet-class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<security-constraint>
<web-resource-collection>
<web-resource-name>Authentication</web-
resource-name>
<http-method>GET</http-method>
</web-resource-collection>
<auth-constraint>
<role-name>clerk</role-name>
</auth-constraint>
</security-constraint>
<login-config>

<auth-method>DIGEST</auth-method>
<realm-name>myrealm</realm-name>
</login-config>
</web-app>
FORM:
Extract Server folder in eclipse and extract Tomcat

v9.0 Server at localhost-config.
Open tomcat-users.xml file and add bellow code in side
<tomcat-users> tag.
<role rolename="clerk"/>
<user username="kiran" password="kiran"
roles="clerk"/>
Login.jsp:
<html>
<blockquote>PLEASE ENTER USERNAME AND
PASSWORD</blockquote>
<form action="j_security_check" method='get'>
<table border='4'>
<tr>
<td>username</td>
<td><input type='text'
name='j_username'></td>
</tr>
<tr>
<td>password</td>
name='j_password'></td>
</tr>
<tr>
<td colspan='2' align='right'>
<input type='submit'
value='submit'/>
</td>
</tr>
</table>
</form>
</body>
</html>
Login_fail.jsp:
<html>
<blockquote>BOTH USERNAME AND PASSWORDS ARE NOT
MATCH</blockquote>
<a href='./login.jsp'>REENTER USERNAME AND
PASSWORD</a>
</body>
</html>
Edit.jsp:
<html>
<form>
<center><b>
<%
out.println("the username is:
"+request.getRemoteUser()+"<br/>");
%>
login sucessfull.....welcome to home
page</b></center>
</form>
</body>
</html>
Web.xml:
<web-app>
<servlet>
<jsp-file>/edit.jsp</jsp-file>
</servlet>
<servlet-mapping>
<url-pattern>/test2</url-pattern>
</servlet-mapping>
<security-constraint>
<web-resource-collection>
<web-resource-name>Authentication</web-
resource-name>
<url-pattern>/test2</url-pattern>
<http-method>GET</http-method>
</web-resource-collection>
<auth-constraint>
<role-name>clerk</role-name>
</auth-constraint>
</security-constraint>
<login-config>
<auth-method>FORM</auth-method>
<form-login-config>
<form-login-page>/login.jsp</form-login-
page>
<form-error-page>/login_fail.jsp</form-
error-page>
</form-login-config>
<realm-name>myrealm</realm-name>
</login-config>
</web-app>
Form Validations in Servlet:

Validation mean whether we/enduser fill the mandatory
details in form or not and checking filling value
formate is valid or not.
We can develop form validation in two ways.
a.Client side validation: writing validation logic
in html file by using javascript code is called
client side validation.
b.Server side validation: writing some validation
logic in Servlet and jsp is called server side
validation.
Input.html:
<html>
<head>
<script lang="javascript"
src="validation.js"></script>
</head>
<form action='voteurl' onsubmit="return
validate(this)">
person name: <input type='text'
name="pname"/>
<span id="nameErr"></span><br/>
person age : <input type='text' name="page"/>
<span id="ageErr"></span><br/>
<input type='hidden' value="no"
name="vflag"/><br/>
<input type='submit' value='check
eligibity'/>
</form>
</html>
Validation.js:
function validate(frm){
//frm.vflag.value="yes";
document.getElementById("nameErr").style="color:red";
document.getElementById("ageErr").style="color:red";
var name = frm.pname.value;
var age = frm.page.value;
if(name==""){
document.getElementById("nameErr").innerHTML="person
name is mandatory";
frm.pname.focus();
//alert("Name can't be blank");

return false;
}
if(age==""){
document.getElementById("ageErr").innerHTML="person
age is mandatory";
frm.page.focus();
//alert("age can't be blank");

return false;
}
else{
if(isNaN(age)){
//alert("age should be in numerics");
document.getElementById("ageErr").innerHTML="person
age is must be numeric";
frm.page.focus();
return false;
}
}
return true;
}
VoterServlet.java:
package com.ram;
public class VoterServlet extends GenericServlet{
@Override
String hvalue= request.getParameter("vflag");
System.out.println("hvalue: "+hvalue);
String name = request.getParameter("pname");
String age = request.getParameter("page");
System.out.println("name: "+name);
System.out.println("age: "+age);
int cage=0;
if(hvalue.equals("no")){
if(name==""){
out.println("person name is mandatory");
return;
}
if(age==""){
out.println("person age is mandatory");
return;
}
else {
try{
cage=Integer.parseInt(age);
out.println("person age should be in numerics");
}
}
}
else{
if(age!="")
cage = Integer.parseInt(age);
}
if(cage>=18){
out.println("You hava eligibity for voting");
}
else{
out.println("You doesn't have eligibity for voting");
}
}
}
Web.xml:
<web-app>
<servlet>
<servlet-class>com.ram.VoterServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/voteurl</url-pattern>
</servlet-mapping>
<welcome-file-list>
</web-app>
What difference between javascript and java:
Don’t compare these two languages, the reason both
are not programming language. But still if we want to
differenciate then we can give following information.
Java script is a scripting language, which is given
netscape, this is apply this language on
webapplications only,to execute javascript programs
we required java script engine.
Java is a programming language, which is given by
sunmicro systems, this is useful for developing all
type of applications, to execute the java programs we
required jvm.
Q) How many ways can able to doing validations?
A)There are four ways.
a. Only doing validation in browser or client
side:If browser supports scriprting code, validation
are happened at browser so we can improve performance
of server. If browser not supports scripting code,
then at server side, we are facing problems,
unnecessarly network calls are wasted.
b. only doing validation at server side:
If validation are valid then not a problem at
server side, if validation are failure unneccessarly
wasted network calss and server performance.
c. Doing validation at both client and server side:
Performance is going to reduce.
d.Doing validation at both client and server side
with information by using hidden form field.
1.If client side validation are successfully happen
then give the information to server for avoiding
validation at server side
2.If client side validation are failure then
provide information to server for doing
validations at server side.
How to disable javascript coding at browser side:
 Go to right top most corner of browser and

click on three dot symbols.
 Go to settings.
 Click on advance settings.
 Goto private and security.
 Goto content settings.
 Click on javascript option. Then choose disable
mode.
Security through programmatically by using Session
object:
login.html:
<center>
<form action="loginurl">
username: <input type="text"
name="tuname"><br/>
password: <input type="text"
name="tpwd"><br/>
</form>
</center>
</body>LoginServlet.java:
package com.ram.servlet;
public class LoginServlet extends HttpServlet{
HttpSession session =
req.getSession(true);
String un =
req.getParameter("tuname");//ram
String pw =
req.getParameter("tpwd");//ram
if(un != null && pw != null)
if(un.equals("admin")&&pw.equals("admin")) {
session.setAttribute("loggedin",
"ok");
req.getRequestDispatcher("./adminurl");
}
else {
req.getRequestDispatcher("login.html");
}
}
}
AdminServlet.java:
package com.ram.servlet;
public class AdminServlet extends HttpServlet{

HttpSession session = req.getSession(true);
String str =
(String)session.getAttribute("loggedin");//ok
if(str==null) {
req.getRequestDispatcher("/login.html");
}
else{
PrintWriter pw = res.getWriter();
pw.println("<font color=red size=7>from
adminservlet</font>");
pw.close();
}
}
}
Web.xml:
<web-app>
<servlet>
<servlet-
class>com.ram.servlet.AdminServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/adminurl</url-pattern>
</servlet-mapping>
<servlet>
<servlet-
class>com.ram.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/loginurl</url-pattern>
</servlet-mapping>
</web-app>
How read data from different form componenets in

Servlet:
Form.html:
<html>
<form action='./furl'>
<table border='5'>
<tr>
<td>Name:</td>
name='tname'></td>
</tr>
<tr>
<td>Age:</td>
<td>
<input type='password'
name='tage'/>
</td>
</tr>
<tr>
<td>Gender:</td>
<td><input type='radio' name='gen' value='M'
checked="checked"/>MALE
<input type='radio' name='gen' value='f'
>FEMALE
</td>
</tr>
<tr>
<td>Address</td>
<td><textarea name='taddress'
row='5' cols='25'>
Enter Address
</textarea></td>
</tr>
<tr>
<td>Marital Status</td>
<td><input type='checkbox'
name='ms' value='married'/>married
</td>
</tr>
<tr>
<td>Qualification</td>
<td><select name='qlfy'
size='2'>
<option
value='B.Tech'>Engg</option>
<option
value='MBBS'>Medical</option>
<option
value='B.A'>Arts</option>
</select>
</td>
</tr>
<tr>
<td>Courses:</td>
<td><select name='crs' size='3'
multiple='multiple'>
<option value="java">Java
pkg</option>
<option value=".net">.Net
pkg</option>
<option value="php">Php
pkg</option>
</select>
</td>
</tr>
<tr>
<td>Hobbies: </td>
<td><input type='checkbox'
name='hb' value='read' checked/> Reading
<input type='checkbox' name='hb'
value='singing' /> Singing
<input type='checkbox' name='hb'
value='playing' /> Playing
</td>
</tr>
<tr>
<td><input type='submit'
value="Register"/></td>
</tr>
</table>
</form>
</body>
</html>
FormServlet.java
public class FormServlet extends HttpServlet{

@Override
request,HttpServletResponse response)
out.println("<body bgcolor='wheat'>");
out.println("<form>");
out.println("name:
"+request.getParameter("tname")+"<br/>");
out.println("age :
"+request.getParameter("tage")+"<br/>");
out.println("gender:
"+request.getParameter("gen")+"<br/>");
out.println("adddress:
"+request.getParameter("taddress")+"<br/>");
out.println("marital status:
"+request.getParameter("ms")+"<br/>");
out.println("Qualification:
"+request.getParameter("qlfy")+"<br/>");
String crs[] =
request.getParameterValues("crs");
String hb[] =
request.getParameterValues("hb");
out.println("courses:
"+java.util.Arrays.toString(crs)+"<br/>");
out.println("hobbies:
"+java.util.Arrays.toString(hb)+"<br/>");
int age =
Integer.parseInt(request.getParameter("tage"));
String gender=request.getParameter("gen");
if(gender.equalsIgnoreCase("m")) {
if(age>12) {
out.println("you are boy");
}
if(age>=13 && age<=19) {
out.println("you are teenage boy");
}
if(age>=20) {
out.println("you are elder boy");
}
}else {
if(age>12) {
out.println("you are girl");
}
if(age>=13 && age<=19) {
out.println("you are teenage girl");
}
if(age>=20) {
out.println("you are elder girl");
}
}
}
}
Web.xml:
<web-app>
<servlet>
<servlet-name>furl</servlet-name>
<servlet-class>FormServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>furl</servlet-name>
<url-pattern>/furl</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>form.html</welcome-file>
</web-app>
JavaBean with servlet:

StudentVO.java
public class StudentVO implements Serializable{

private String sid;
private String sage;
private String sfee;
public String getSid() {
return sid;
}
public void setSid(String sid) {
System.out.println("sid: "+sid);
this.sid = sid;
}
return sname;
}
this.sname = sname;
}
public String getSage() {
return sage;
}
public void setSage(String sage) {
this.sage = sage;
}
public String getSfee() {
return sfee;
}
public void setSfee(String sfee) {
this.sfee = sfee;
}
return scourse;
}
}
}
StudentBO.java
public class StudentBO implements Serializable{

private int sid;
private int sage;
private int sfee;
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
return sname;
}
this.sname = sname;
}
public int getSage() {
return sage;
}
public void setSage(int sage) {
this.sage = sage;
}
public int getSfee() {
return sfee;
}
public void setSfee(int sfee) {
this.sfee = sfee;
}
return scourse;
}
}
}
StudentDTO.java
public class StudentDTO {

public void insert(StudentBO sbo){
try {
Connection con =
DriverManager.getConnection(
1:xe","system",
"manager");
ps.setInt(1, sbo.getSid());
ps.setString(2, sbo.getSname());
ps.setInt(3,sbo.getSage());
ps.setInt(4, sbo.getSfee());
ps.setString(5, sbo.getScourse());
inserted");
System.out.println("catch blcok in
dto");
}
}
}
FrontController.java:
public class FrontController extends GenericServlet{
@Override
ServletResponse
response) throws ServletException,
IOException {
String sid = request.getParameter("sid");
String sname = request.getParameter("sname");
String sage = request.getParameter("sage");
String sfee = request.getParameter("sfee");
String scourse =
request.getParameter("scourse");
StudentVO svo = new StudentVO();
svo.setSid(sid);
svo.setSname(sname);
svo.setSage(sage);
svo.setSfee(sfee);
svo.setScourse(scourse);
sct.setAttribute("svo", svo);
request.getRequestDispatcher("./bs");
StudentBO sbo =
(StudentBO)sct.getAttribute("sbo");
StudentDTO sdt = new StudentDTO();
sdt.insert(sbo);
}
}
BusineServlet.java:
public class BusinessServlet extends GenericServlet{

@Override
ServletResponse
response) throws ServletException,
IOException {
StudentVO svo = (StudentVO)
sct.getAttribute("svo");
String ss= svo.getSid();
System.out.println("ss: "+ss);
int sid = Integer.parseInt(ss);
String sname = svo.getSname();
int sage = Integer.parseInt(svo.getSage());
int sfee = Integer.parseInt(svo.getSfee());
String scourse = svo.getScourse();
StudentBO sbo = new StudentBO();
sbo.setSid(sid);
sbo.setSname(sname);
sbo.setSage(sage);
sbo.setSfee(sfee);
sbo.setScourse(scourse);
System.out.println("sct: "+sct.hashCode());
sct.setAttribute("sbo", sbo);
}
}
Stuentinfo.html:
<html>
<form action='./fc'>
Enter Your Id: <input type='text'
name='sid'/><br/>
Enter Your Name: <input type='text'
name='sname'/><br/>
Enter Your Age: <input type='text'
name='sage'/><br/>
Enter Your Fee: <input type='text'
name='sfee'/><br/>
Enter Your Course: <input type='text'
name='scourse'/>
<br/>
</form>
</body>
</html>
Web.xml
<web-app>
<servlet>
<servlet-name>fc</servlet-name>
<servlet-class>FrontController</servlet-
class>
</servlet>
<servlet-mapping>
<servlet-name>fc</servlet-name>
<url-pattern>/fc</url-pattern>
</servlet-mapping>
<servlet>
<servlet-class>BusinessServlet</servlet-
class>
</servlet>
<servlet-mapping>
</servlet-mapping>
<welcome-file-list>
<welcome-file>studentinfo.html</welcome-file>
</web-app>
Program on wrappers in servlet:
<html>
<body bgcolor='orange'>
<form action="loginurl"
method="post">
User name: <input type='text'
name="uname">@gmail.com<br/>
Password: <input type='password'
name="pwd"><br/>
</form>
</body>
</html>
Web.xml:
<web-app>
<welcome-file-list>
<welcome-file>login.html</welcome-
file>
<servlet>
<servlet-name>login</servlet-name>
<servlet-
class>com.nt.servlet.LoginServlet</servlet
-class>
</servlet>
<servlet-mapping>
<servlet-name>login</servlet-name>
</servlet-mapping>
<filter>
<filter-name>log</filter-name>
<filter-
class>com.nt.filter.LoginFilter</filter-
class>
</filter>
<filter-mapping>
<filter-name>log</filter-name>
</filter-mapping>
</web-app>
LoginFilter.java:
package com.nt.filter;
import java.io.*;
import javax.servlet.http.*;
import com.nt.wrappers.MyRequest;
import com.nt.wrappers.MyResponse;
public class LoginFilter implements Filter{
@Override
public void destroy() { }
@Override
public void doFilter(ServletRequest req ,
ServletResponse res, FilterChain chain)
throws IOException, ServletException
{
MyRequest mrequest = null;
MyResponse mresponse = null;
String output=null;
PrintWriter pw = null;
mrequest = new
MyRequest((HttpServletRequest)req);
mresponse = new
MyResponse((HttpServletResponse)res);
chain.doFilter(mrequest, mresponse);
output = mresponse.toString();
output= output+"NIT,Ameerpet";
pw=res.getWriter();
pw.print(output);
}
@Override
public void init(FilterConfig arg0) throws
ServletException { }
}
LoginServlet.java:
package com.nt.servlet;
import java.io.*;
import javax.servlet.http.*;
public class LoginServlet extends HttpServlet{
@Override
//PrintWriter pw = new PrintWriter(new
CharArrayWriter());
PrintWriter pw = res.getWriter();
String
uname=req.getParameter("uname");//ram@gmail.com
String pwd =
req.getParameter("pwd");//sam
System.out.println(uname+"...."+pwd);
if(uname.equals("ram@gmail.com")&&
pwd.equals("sam")){
pw.print("<h1
style='color:red'>Valid credentials</h1>");
}
else{ pw.print("<h1
style='color:red'>InValid credentials</h1>");
}
pw.print("<a
href='./login.html'>home</a>");
System.out.println("req object
classname: "+req.getClass());
System.out.println("res object
classname: "+res.getClass());
pw.close();
}
@Override
doGet(req,res);
}
}
MyRequest.java:
package com.nt.wrappers;
import
javax.servlet.http.HttpServletRequestWrapper;
public class MyRequest extends
HttpServletRequestWrapper{
private HttpServletRequest request;//un--
>ram pd -->sam
public MyRequest(HttpServletRequest
request) {
super(request);
this.request=request;
}
@Override
public String getParameter(String name){
String value =
request.getParameter(name);
if(name.equals("uname")){
if(!value.endsWith("@gmail.com")){
return value+"@gmail.com";
}
}
return value;
}
}
MyResponse.java:
package com.nt.wrappers;
import java.io.*;
import
javax.servlet.http.HttpServletResponseWrapper;
public class MyResponse extends
HttpServletResponseWrapper{
private HttpServletResponse response;
private CharArrayWriter writer;
public MyResponse(HttpServletResponse
response) {
super(response);
this.response=response;
writer = new CharArrayWriter();
}
@Override
public PrintWriter getWriter() throws
IOException{
PrintWriter pw = new
PrintWriter(writer);
return pw;
}
@Override
public String toString(){
return writer.toString();
}
}

ADV-JAVA by Ramchandra New (Update1)

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ADV-JAVA by Ramchandra New (Update1)

Uploaded by

Copyright:

Available Formats

ADVANCED JAVA

Java Software Editions or Modules or Flavors:

Java software classified into three modules

A. JSE Module / J2SE Module.

Java Standard Edition

Java 2 Platform Standard Edition

It is basic module for JEE and JME.

The reason is if we want develop JEE and JME

To work with JSE first we need to install one

JDK: Java Standard Edition Development Kit.

By using this software we can only compile and execute

The Last Version of JDK Version is JDK 11 / Java 11.

Mainly software versions are classified into two types.

Major Version: If we want to add new features to existing software

To resolve the bugs, we need to write bug resolve code for

With the help of JSE, we can develop the following applications.

Here Standalone Applications means, only one end user can be

We need install separately in all systems.

We don’t required any data connection.[internet]

Types of Standalone Applications:

A. Character User Interface Applications / Console Interaction

These types of applications are interacts with end user in the

Ex: If we want to read Employee related information, we need

By using these messages only end user can interact with

Some times may be face difficulty to interact with applications.

To avoiding these drawbacks java introduced one more type of

These are very user friendly applications.

Provide more Look and Feels.

These applications are provides more facilities to interact with

Every person who doesn’t have any idea on applications also

These type of applications can develop by using some of JSE

Networking applications or Socket Programming:

These applications are one type client and server applications.

Most of the peoples feel like client and server applications

We can develop client and server applications within the single

We can develop networking applications or socket application

We can develop these applications by using AWT and SWING

Q) Why should we learn JAVA Software?

There are lots of reasons we have to learn java software.

Java provides response to all the end users within the

Java Standard Edition comes into the picture in 3 Parts.

It will provide basic infrastructure or information to

Languages are provides basic syntax and procedures.

Syntax means don’t use keyword as class name, every

Like in every java program

1. Starts with documentation.

Programming language are supported to develop software

Ex: C, C++, Java, VC++, C# etc

Java provides basic information in the form of oops,

Rules we can develop with the support of interfaces and

Java provides different types of technologies like JDBC,

By using these specifications we can develop software’s.

For example JDBC is technology, which is used to develop

Technologies are not installable software’s. But

Every technology coming into the market in the form api

Package contains set of interface and class.

For Example JDBC interfaces are provides rules and

When ever, any third party vendor wants to develop

Working with the technology means working with

Working with JDBC technology means working with JDBC

Technologies are mainly classified into two types.

Open technologies are provides specifications to all third party