JavaServer
Pages
JavaServer Pages
(JSP) technology is the Java platform technology for delivering
dynamic content to web clients in a portable, secure and well-defined
way. The JavaServer Pages specification extends the Java Servlet API
to provide web application developers with a robust framework for
creating dynamic web content on the server using HTML, and XML
templates, and Java code, which is secure, fast, and independent of
server platforms. JSP has been built on top of the Servlet API and
utilizes Servlet semantics. JSP has become the preferred request
handler and response mechanism. Although JSP technology is going to
be a powerful successor to basic Servlets, they have an evolutionary
relationship and can be used in a cooperative and complementary
manner.
Servlets are
powerful and sometimes they are a bit cumbersome when it comes to
generating complex HTML. Most servlets contain a little code that
handles application logic and a lot more code that handles output
formatting. This can make it difficult to separate and reuse portions
of the code when a different output format is needed. For these
reasons, web application developers turn towards JSP as their
preferred servlet environment.
Evolution
of Web Applications
Over the last few
years, web server applications have evolved from static to dynamic
applications. This evolution became necessary due to some
deficiencies in earlier web site design. For example, to put more of
business processes on the web, whether in business-to-consumer (B2C)
or business-to-business (B2B) markets, conventional web site design
technologies are not enough. The main issues, every developer faces
when developing web applications, are:
1. Scalability - a
successful site will have more users and as the number of users is
increasing fastly, the web applications have to scale
correspondingly.
2. Integration of
data and business logic - the web is just another way to conduct
business, and so it should be able to use the same middle-tier and
data-access code.
3. Manageability -
web sites just keep getting bigger and we need some viable mechanism
to manage the ever-increasing content and its interaction with
business systems.
4. Personalization -
adding a personal touch to the web page becomes an essential factor
to keep our customer coming back again. Knowing their preferences,
allowing them to configure the information they view, remembering
their past transactions or frequent search keywords are all important
in providing feedback and interaction from what is otherwise a fairly
one-sided conversation.
Apart from these
general needs for a business-oriented web site, the necessity for new
technologies to create robust, dynamic and compact server-side web
applications has been realized. The main characteristics of today's
dynamic web server applications are as follows:
1.
Serve HTML and XML, and stream data to the web client
2.
Separate presentation, logic and data
3.
Interface to databases, other Java applications, CORBA, directory and
mail services
4.
Make use of application server middleware to provide transactional
support.
5.
Track client sessions
Java's
Role for Server Applications
Sun Microsystems,
having consulted many expert partners from other related IT
industries, has come out with a number of open APIs for the
technologies and services on server side. This collection of APIs is
named as Java 2 Enterprise Edition (J2EE). The J2EE specification
provides a platform for enterprise applications, with full API
support for enterprise code and guarantees of portability between
server implementations. Also it brings a clear division between code
which deals with presentation, business logic and data.
The J2EE
specification meets the needs of web applications because it
provides:
Rich interaction
with a web server via servlets and built-in support for sessions
available in both servlets and EJBs.
The use of EJBs to
mirror the user interaction with data by providing automatic session
and transaction support to EJBs operating in the EJB server.
Entity EJBs to
represent data as an object and seamless integration with the Java
data access APIs
Flexible
template-based output using JSP and XML
This family of APIs
mean that the final web page can be generated from a user input
request, which was processed by a servlet or JSP and a session EJB,
which represents the user's session with the server, using data
extracted from a database and put into an entity EJB. Thus, the Java
revolution of portable code and open APIs is married with an
evolution in existing products such as database, application, mail
and web servers. The wide availability of products to run Java
applications on the server has made this a fast-moving and very
competitive market, but the essential compatibility through
specifications, standard APIs and class libraries has held. This
makes server-side Java a very exciting area.
JavaServer
Pages - An Overview
The JavaServer Pages
1.2 specification provides web developers with a framework to build
applications containing dynamic web content such as HTML, DHTML,
XHTML and XML. A JSP page is a text based document containing static
HTML and dynamic actions which describe how to process a response to
the client in a more powerful and flexible manner. Most of a JSP file
is plain HTML but it also has, interspersed with it, special JSP
tags.
There are many JSP
tags such as:
JSP directive
denoted by <%@,
scriplets indicated
by <% ... %> tags and
directive includes
the contents of the file sample.html in the response at that point.
To process a JSP
file, we need a JSP engine that can be connected with a web server or
can be accommodated inside a web server. Firstly when a web browser
seeks a JSP file through an URL from the web server, the web server
recognizes the .jsp file extension in the URL requested by the
browser and understands that the requested resource is a JavaServer
Page. Then the web server passes the request to the JSP engine. The
JSP page is then translated into a Java class, which is then compiled
into a servlet.
This translation and
compilation phase occurs only when the JSP file is requested for the
first time, or if it undergoes any changes to the extent of getting
retranslated and recompiled. For each additional request of the JSP
page thereafter, the request directly goes to the servlet byte code,
which is already in memory. Thus when a request comes for a servlet,
an init() method is called when the Servlet is first loaded into the
virtual machine, to perform any global initialization that every
request of the servlet will need. Then the individual requests are
sent to a service() method, where the response is put together. The
servlet creates a new thread to run service() method for each
request. The request from the browser is converted into a Java object
of type HttpServletRequest, which is passed to the Servlet along with
an HttpServletResponse object that is used to send the response back
to the browser. The servlet code performs the operations specified by
the JSP elements in the .jsp file.
The
Components of JSPs
JSP syntax is almost
similar to XML syntax. The following general rules are applicable to
all JSP tags.
1. Tags have either
a start tag with optional attributes, an optional body, and a
matching end tag or they have an empty tag possibly with attributes.
2. Attribute values
in the tag always appear quoted. The special strings ' and "
can be used if quotes are a part of the attribute value itself.
Any whitespace
within the body text of a document is not significant, but is
preserved, which means that any whitespace in the JSP being
translated is read and preserved during translation into a servlet.
The character \ can
be used as an escape character in a tag, for instance, to use the %
character, \% can be used.
JavaServer Pages are
text files that combine standard HTML and new scripting tags. JSPs
look like HTML, but they get compiled into Java servlets the first
time they are invoked. The resulting servlet is a combination of HTML
from the JSP file and embedded dynamic content specified by the new
tags. Everything in a JSP page can be divided into two categories:
1.
Elements that are processed on the server
2.
Template data or everything other than elements, that the engine
processing the JSP engines.
Element data or that
part of the JSP which is processed on the server, can be classified
into the following categories:
1.
Directives
2.
Scripting elements
3.
Standard actions
JSP directives serve
as messages to the JSP container from the JSP. They are used to set
global values such as class declaration, methods to be implemented,
output content type, etc. They do not produce any output to the
client. All directives have scope of the entire JSP file. That is, a
directive affects the whole JSP file, and only that JSP file.
Directives are characterized by the @ character within the tag and
the general syntax is:
The three directives
are page, include and taglib.
Scripting elements
are used to include scripting code (Java code) within the JSP. They
allow to declare variables and methods, include arbitrary scripting
code and evaluate an expression. The three types of scripting element
are: Declaration, Scriptlets and Expressions.
A declaration is a
block of Java code in a JSP that is used to define class-wide
variables and methods in the generated class file. Declarations are
initialized when the JSP page is initialized and have class scope.
Anything defined in a declaration is available throughout the JSP, to
other declarations, expressions or code.
A scriptlet consists
of one or more valid Java statements. A scriptlet is a block of Java
code that is executed at request-processing time. A scriptlet is
enclosed between "<%" and "%>". What the
scriptlet actually does depends on the code, and it can produce
output into the output stream to the client. Multiple scriptlets are
combined in the compiled class in the order in which they appear in
the JSP. Scriptlets like any other Java code block or method, can
modify objects inside them as a result of method invocations.
An expression is a
shorthand notation for a scriptlet that outputs a value in the
response stream back to the client. When the expression is evaluated,
the result is converted to a string and displayed, An expression is
enclosed within <%= and %> "<%=" and "%>".
If any part of expression is an object, the conversion is done using
the toString() method of the object.
Standard actions are
specific tags that affect the runtime behavior of the JSP and affect
the response sent back to the client. The JSP specification lists
some standard action types to be provided by all containers,
irrespective of the implementation. Standard actions provide page
authors with some basic functionality to exploit; the vendor is free
to provide other actions to enhance behavior.
How
JSP and JSP Container function
A JSP page is
executed in a JSP container or a JSP engine, which is installed in a
web server or in a application server. When a client asks for a JSP
page the engine wraps up the request and delivers it to the JSP page
along with a response object. The JSP page processes the request and
modifies the response object to incorporate the communication with
the client. The container or the engine, on getting the response,
wraps up the responses from the JSP page and delivers it to the
client. The underlying layer for a JSP is actually a servlet
implementation. The abstractions of the request and response are the
same as the ServletRequest and ServletResponse respectively. If the
protocol used is HTTP, then the corresponding objects are
HttpServletRequest and HttpServletResponse.
The first time the
engine intercepts a request for a JSP, it compiles this translation
unit (the JSP page and other dependent files) into a class file that
implements the servlet protocol. If the dependent files are other
JSPs they are compiled into their own classes. The servlet class
generated at the end of the translation process must extend a
superclass that is either
1.
specified by the JSP author through the use of the extends attribute
in the page directive or
2.
is a JSP container specific implementation class that implements
javax.servlet.jsp.JspPage interface and provides some basic page
specific behavior.
Since most JSP pages
use HTTP, their implementation classes must actually implement the
javax.servlet.jsp.HttpJspPage interface, which is a sub interface of
javax.servlet.jsp.JspPage.
The
javax.servlet.jsp.JspPage interface contains two methods:
1.
public void jspInit() - This method is invoked when the JSP is
initialized and the page authors are free to provide initialization
of the JSP by implementing this method in their JSPs.
2.
public void jspDestroy() - This method is invoked when the JSP is
about to be destroyed by the container. Similar to above, page
authors can provide their own implementation.
The
javax.servlet.jsp.HttpJspPage interface contains one method:
public void
_jspService(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
This method
generated by the JSP container is invoked, every time a request comes
to the JSP. The request is processed and the JSP generates
appropriate response. This response is taken by the container and
passed back to the client.
JSP
Architecture
There are two basic
ways of using the JSP technology. They are the client/server
(page-centric) 2-tier approach and the N-tier approach (dispatcher).
The Page-Centric
Approach
Applications built
using a client-server (2-tier) approach consist of one or more
application programs running on client machines and connecting to a
server-based application to work. With the arrival of Servlets
technology, 2-tier applications could also be developed using Java
programming language. This model allows JSPs or Servlets direct
access to some resource such as database or legacy application to
service a client's request. The JSP page is where the incoming
request is intercepted, processed and the response sent back to the
client. JSPs differ from Servlets in this scenario by providing clean
code, separating code from the content by placing data access in
EJBs. Even though this model makes application development easier, it
does not scale up well for a large number of simultaneous clients as
it entails a significant amount of request processing to be performed
and each request must establish or share a potentially
scarce/expensive connection to the resource in question.
Page-view - This
basic architecture involves direct request invocations to a server
page with embedded Java code, and markup tags which dynamically
generate output for substitution within the HTML. This approach has
been blessed a number of benefits. It is very straightforward and is
a low-overhead approach from a developerment perspective. All the
Java code may be embedded within the HTML, so changes are confined to
a very limited area, reducing complexity drastically.
The big trade-off
here is in the level of sophistication. As the scale of the system
grows, some limitations begin to surface, such as bloating of
business logic code in the page instead of factoring forward to a
mediating Servlet or factoring back to a worker bean. It is a fact
that utilizing a Servlet and helper beans helps to separate developer
roles more cleanly and improves the potential for code reuse.
Page-view with bean
- This pattern is used when the above architecture becomes too
cluttered with business-related code and data access code. The Java
code representing the business logic and simple data storage
implementation in the previous model moves from the JSP to the
JavaBean worker. This refactoring leaves a much cleaner JSP with
limited Java code, which can be comfortably owned by an individual in
a web-production role, since it encapsulates mostly markup tags.
The Dispatcher
Approach
In this approach, a
Servlet or JSP acts as a mediator or controller, delegating requests
to JSP pages and JavaBeans. There are three different architectures.
They are mediator-view, mediator-composite view and service to
workers.
In an N-tier
application, the server side of the architecture is broken up into
multiple tiers. In this case, the application is composed of multiple
tiers, where the middle tier, the JSP, interacts with the back end
resources via another object or EJBs component. The Enterprise
JavaBeans server and the EJB provide managed access to resources,
support transactions and access to underlying security mechanisms,
thus addressing the resource sharing and performance issues of the
2-tier approach.
The first step in
N-tiered application design should be identifying the correct objects
and their interaction and the second step is identifying the JSPs or
Servlets. These are divided into two categories.
Front end JSPs or
Servlets manage application flow and business logic evaluation. They
act as a point to intercept the HTTP requests coming from the users.
They provide a single entry point to an application, simplifying
security management and making application state easier to maintain.
Presentation JSPs or
Servlets generate HTML or XML with their main purpose in life being
presentation of dynamic content. They contain only presentation and
rendering logic.
These categories
resemble to the Modal-View design pattern, where the front-end
components is the model and the presentation component the view. In
this approach, JSPs are used to generate the presentation layer and
either JSPs or Servlets to perform process-intensive tasks. The
front-end component acts as the controller and is in charge of the
request processing and the creation of any beans or objects used by
the presentation JSP, as well as deciding, depending on the user's
actions, which JSP to forward this request to. There is no processing
logic within the presentation JSP itself and it simply responsible
for retrieving any objects or beans that may have been previously
created by the Servlet and extracting the dynamic content for
insertion within static templates.
Benefits
of JSP
One of the main
reasons why the JavaServer Pages technology has evolved into what it
is today and it is still evolving is the overwhelming technical need
to simplify application design by separating dynamic content from
static template display data. Another benefit of utilizing JSP is
that it allows to more cleanly separate the roles of web
application/HTML designer from a software
developer.
The JSP technology is blessed with a number of exciting benefits,
which are chronicled as follows:
1. The JSP
technology is platform independent, in its dynamic web pages, its web
servers, and its underlying server components. That is, JSP pages
perform perfectly without any hassle on any platform, run on any web
server, and web-enabled application server. The JSP pages can be
accessed from any web server.
2. The JSP
technology emphasizes the use of reusable components. These
components can be combined or manipulated towards developing more
purposeful components and page design. This definitely reduces
development time apart from the At development time, JSPs are very
different from Servlets, however, they are precompiled into Servlets
at run time and executed by a JSP engine which is installed on a
Web-enabled application server such as BEA WebLogic and IBM
WebSphere.
Conclusion
JSP and Servlets are
gaining rapid acceptance as means to provide dynamic content on the
Internet. With full access to the Java platform, running from the
server in a secure manner, the application possibilities are almost
limitless. When JSPs are used with Enterprise JavaBeans technology,
e-commerce and database resources can be further enhanced to meet an
enterprise's needs for web applications providing secure transactions
in an open platform. J2EE technology as a whole makes it easy to
develop, deploy and use web server applications instead of mingling
with other technologies such as CGI and ASP. There are many tools for
facilitating quick web software development and to easily convert
existing server-side technologies to JSP and Servlets.
Many application
server vendors are aggressively deploying JSP within their products.
This results in developing robust e-commerce applications as JSP
provides XML functionality and scalability. By providing a clear
separation between content and coding, JSP solves many problems
attached with existing server-side applications.
JSP Architecture
JSP pages are
high level extension of servlet and it enable the developers to embed
java code in html pages. JSP files are finally compiled into a
servlet by the JSP engine. Compiled servlet is used by the engine to
serve the requests.
javax.servlet.jsp
package defines two interfaces:
JSPPage
HttpJspPage
These
interfaces defines the three methods for the compiled JSP page. These
methods are:
jspInit()
jspDestroy()
_jspService(HttpServletRequest
request,HttpServletResponse response)
In the compiled JSP
file these methods are present. Programmer can define jspInit()
and jspDestroy() methods, but the
_jspService(HttpServletRequest request,HttpServletResponse
response) method is generated by the JSP engine.
JSP Actions:
What is JSP
Actions?
Servlet container
provides many built in functionality to ease the development of the
applications. Programmers
can use these functions in JSP applications. The JSP Actions tags
enables the programmer to use these functions. The JSP Actions are
XML tags that can be used in the JSP page.
Here is the list
of JSP Actions:
jsp:include
The
jsp:include action work as a subroutine, the Java
servlet
temporarily passes the request and response to the specified
JSP/Servlet. Control is then returned back to the current JSP
page.
jsp:param
The
jsp:param action is used to add the specific parameter to
current request. The jsp:param tag can be used inside a jsp:include,
jsp:forward or jsp:params block.
jsp:forward
The
jsp:forward tag is used to hand off the request and response
to another JSP or servlet. In this case the request never return to
the calling JSP page.
jsp:plugin
In
older versions of Netscape Navigator and Internet Explorer;
different tags is used to embed applet. The jsp:plugin tag
actually generates the appropriate HTML code the embed the Applets
correctly.
jsp:fallback
The
jsp:fallback tag is used to specify the message to be shown
on the browser if applets is not supported by
browser.
Example:
<jsp:fallback>
<p>Unable to load
applet</p>
</jsp:fallback>
jsp:getProperty
The
jsp:getPropertyB is used to get specified property from the
JavaBean object.
jsp:setProperty
The
jsp:setProperty tag is used to set a property in the JavaBean
object.
jsp:useBean
The
jsp:useBean tag is used to instantiate an object of
Java Bean or it can re-use existing java bean object.
JSP
Tags:
Directives
In
the directives we can import packages, define error handling pages or
the session information of the JSP page.
Syntax
of JSP directives is:
<%@directive
attribute="value" %>
Where directive may
be:
page: page is used
to provide the information about it.
Example: <%@page
language="java" %>
include: include is
used to include a file in the JSP page.
Example: <%@ include
file="/header.jsp" %>
taglib: taglib is
used to use the custom tags in the JSP pages (custom tags allows us
to defined our own tags).
Example: <%@ taglib
uri="tlds/taglib.tld" prefix="mytag" %>
and attribute may
be:
language="java"
This
tells the server
that the page is using the java language. Current JSP specification
supports only java language.
Example: <%@page language="java"
%>
extends="mypackage.myclass"
This
attribute is used when we want to extend any class. We can use
comma(,) to import more than one packages.
Example: <%@page
language="java" import="java.sql.*,mypackage.myclass"
%>
session="true"
When
this value is true session data is available to the JSP page
otherwise not. By default this value is true.
Example: <%@page
language="java" session="true" %>
errorPage="error.jsp"
errorPage
is used to handle the un-handled exceptions in the page.
Example:
<%@page language="java" session="true"
errorPage="error.jsp" %>
contentType="text/html;charset=ISO-8859-1"
Use
this attribute to set the mime type and character set of the
JSP.
Example: <%@page language="java" session="true"
contentType="text/html;charset=ISO-8859-1" %>
Declarations
This
tag is used for defining the functions and variables to be used in
the JSP.
Syntax
of JSP Declaratives are:
<%!
//java codes
%>
JSP Declaratives
begins with <%! and ends %> with .We can embed any amount of
java code in the JSP Declaratives. Variables and functions defined in
the declaratives are class level and can be used anywhere in the JSP
page.
Example:
<%@page
contentType="text/html" %>
<html>
<body>
<%!
int
cnt=0;
private int getCount(){
//increment cnt and return the
value
cnt++;
return cnt;
}
%>
<p>Values
of Cnt are:</p>
<p><%=getCount()%></p>
<p><%=getCount()%></p>
<p><%=getCount()%></p>
<p><%=getCount()%></p>
<p><%=getCount()%></p>
<p><%=getCount()%></p>
</body>
</html>
Scriplets
In
this tag we can insert any amount of valid java code and these codes
are placed in _jspService method by the JSP engine.
Syntax
of JSP Scriptles are:
<%
//java codes
%>
JSP Scriptlets
begins with <% and ends %> .We can embed any amount of java
code in the JSP Scriptlets. JSP Engine places these code in the
_jspService() method. Variables available to the JSP
Scriptlets are:
request:
request
represents the clients request and is a subclass of
HttpServletRequest. Use this variable to retrieve the data
submitted along the request.
Example:
<%
//java codes
String userName=null;
userName=request.getParameter("userName");
%>
response:
response
is subclass of HttpServletResponse.
session:
session
represents the HTTP session object associated with the request.
out:
out is an
object of output stream and is used to send any output to the
client.
Other
variable available to the scriptlets are pageContext,
application,config and exception.
Expressions
We
can use this tag to output any data on the generated page. These data
are automatically converted to string and printed on the output
stream.
Syntax
of JSP Expressions are:
<%="Any
thing" %>
JSP Expressions
start with
Syntax of JSP
Scriptles are with <%= and ends with %>. Between these
this you can put anything and that will converted to the String and
that will be displayed.
Example:
<%="Hello World!" %>
Above code will display
'Hello World!'.
JSP
Date Example
<%@page
contentType="text/html" import="java.util.*" %>
<!--http://www.roseindia.net/jsp-->
<html>
<body>
<p> </p>
<div
align="center">
<center>
<table
border="0" cellpadding="0" cellspacing
="0"
width="460" bgcolor="#EEFFCA">
<tr>
<td
width="100%"><font size="6"
color
="#008000"> Date
Example</font></td></tr>
<tr>
<td
width="100%"><b> Current Date
and
time is: <font color="#FF0000">
<%=
new java.util.Date()
%>
</font></b></td>
</tr>
</table>
</center>
</div>
</body>
</html>
Accessing
database from JSP
Introduction
We
take a example of Books Database. This database contains a table
named books_details. This table contains three fields- id,
book_name& author. we starts from very beginning.
First we learn how to create tables in MySQl database after that we
write a html page for inserting the values in 'books_details'
table in database. After submitting values a table will be showed
that contains the book name and author name.
Database
The
database in example consists of a single table of three columns or
fields. The database name is "books" and it contains
information about books names & authors.
Start MYSQL prompt
and type this SQL statement & press
Enter-
MYSQL>CREATE
DATABASE
`books` ;
This will create
"books" database.
Now we create table a table
"books_details" in database
"books".
MYSQL>CREATE TABLE `books_details`
(
`id` INT( 11 ) NOT NULL AUTO_INCREMENT
,
`book_name` VARCHAR( 100 ) NOT NULL
,
`author` VARCHAR( 100 ) NOT NULL
,
PRIMARY KEY ( `id` )
) TYPE = MYISAM ;
This will create a table
"books_details" in database "books"
JSP
Code:
<%@
page language="java" import="java.sql.*" %>
<%
String
driver = "org.gjt.mm.mysql.Driver";
Class.forName(driver).newInstance();
Connection
con=null;
ResultSet
rst=null;
Statement
stmt=null;
try{
String
url="jdbc:mysql://localhost/books?user=
<user>&password=<password>";
con=DriverManager.getConnection(url);
stmt=con.createStatement();
}
catch(Exception
e){
System.out.println(e.getMessage());
}
if(request.getParameter("action")
!= null){
String
bookname=request.getParameter("bookname");
String
author=request.getParameter("author");
stmt.executeUpdate("insert
into books_details(book_name,
author)
values('"+bookname+"','"+author+"')");
rst=stmt.executeQuery("select
* from books_details");
%>
<html>
<body>
<center>
<h2>Books
List</h2>
<table
border="1" cellspacing="0" cellpadding="0">
<tr>
<td><b>S.No</b></td>
<td><b>Book
Name</b></td>
<td><b>Author</.b></td>
</tr>
<%
int
no=1;
while(rst.next()){
%>
<tr>
<td><%=no%></td>
<td><%=rst.getString("book_name")%></td>
<td>
<%=rst.getString("author")%> </td>
</tr>
<%
no++;
}
rst.close();
stmt.close();
con.close();
%>
</table>
</center>
</body>
</html>
<%}else{%>
<html>
<head>
<title>Book
Entry FormDocument</title>
<script
language="javascript">
function validate(objForm){
if(objForm.bookname.value.length==0){
alert("Please
enter Book Name!");
objForm.bookname.focus();
return
false;
}
if(objForm.author.value.length==0){
alert("Please
enter Author name!");
objForm.author.focus();
return
false;
}
return
true;
}
</script>
</head>
<body>
<center>
<form
action="BookEntryForm.jsp" method="post"
name="entry" onSubmit="returnvalidate(this)">
<input
type="hidden" value="list" name="action">
<table
border="1" cellpadding="0" cellspacing="0">
<tr>
<td>
<table>
<tr>
<td
colspan="2" align="center">
<h2>Book
Entry Form</h2></td>
</tr>
<tr>
<td
colspan="2"> </td>
</tr>
<tr>
<td>Book
Name:</td>
<td><input
name="bookname" type="text" size="50"></td>
</tr>
<tr>
<td>Author:</td><td><input
name="author" type="text" size="50"></td>
</tr>
<tr>
<td
colspan="2" align="center">
<input
type="submit" value="Submit"></td>
</tr>
</table>
</td>
</tr>
</table>
</form>
</center>
</body>
</html>
<%}%>
Declaring
Variables: Java is a strongly typed language which means, that
variables must be explicitly declared before use and must be declared
with the correct data types. In the above example code we declare
some variables for making connection. Theses variables are-
Connection
con=null;
ResultSet rst=null;
Statement stmt=null;
The
objects of type Connection,
ResultSet
and Statement
are associated with the Java sql.
"con" is a Connection type object variable that will hold
Connection type object. "rst" is a ResultSet type object
variable that will hold a result set returned by a database
query. "stmt" is a object variable of Statement
.Statement Class methods allow to execute any query.
Connection to
database: The first task of this programmer is to load database
driver. This is achieved using the single line of code :-
String driver =
"org.gjt.mm.mysql.Driver";
Class.forName(driver).newInstance();
The next task is to
make a connection. This is done using the single line of code :-
String
url="jdbc:mysql://localhost/books?user=<userName>&password=<password>";
con=DriverManager.getConnection(url);
When url is passed
into getConnection() method of DriverManager class it returns
connection object.
Executing Query
or Accessing data from database:
This is done using
following code :-
stmt=con.createStatement(); //create a
Statement object
rst=stmt.executeQuery("select * from
books_details");
stmt is the
Statement type variable name and rst is the RecordSet type
variable. A query is always executed on a Statement object.
A
Statement object is created by calling createStatement() method on
connection object con.
The two most
important methods of this Statement interface are executeQuery() and
executeUpdate(). The executeQuery() method executes an SQL statement
that returns a single ResultSet object. The executeUpdate() method
executes an insert, update, and delete SQL statement. The method
returns the number of records affected by the SQL statement
execution.
After creating a
Statement ,a method executeQuery() or executeUpdate() is called
on Statement object stmt and a SQL query string is passed in
method executeQuery() or executeUpdate().
This will return a
ResultSet rst related to the query string.
Reading values
from a ResultSet:
while(rst.next()){
%>
<tr><td><%=no%></td><td><%=rst.getString("book_name")%></td><td><%=rst.getString("author")%></td></tr>
<%
}
The ResultSet
represents a table-like database result set. A ResultSet
object maintains a cursor pointing to its current row of data.
Initially, the cursor is positioned before the first row. Therefore,
to access the first row in the ResultSet,
you use the next()
method. This method moves the cursor to the next record and returns
true
if the next row is valid, and false
if there are no more records in the ResultSet
object.
Other important
methods are getXXX()
methods, where XXX
is the data type returned by the method at the specified index,
including String,
long,
and int.
The indexing used is 1-based. For example, to obtain the second
column of type String, you use the following code:
resultSet.getString(2);
You can also use the
getXXX()
methods that accept a column name instead of a column index. For
instance, the following code retrieves the value of the column
LastName of type String.
resultSet.getString("book_name");
The above example
shows how you can use the next()
method as well as the getString()
method. Here you retrieve the 'book_name' and 'author' columns from a
table called 'books_details'. You then iterate through the returned
ResultSet
and print all the book name and author name in the format " book
name | author " to the web page.
Summary:
This article
presents JDBC and shows how you can manipulate data in a relational
database from your JSP page. To do this, you need to use
the java.sql package: DriverManager,
Connection,
Statement,
and ResultSet.
Keep in mind, however, that this is only an introduction. To create a
Web application, you need JDBC to use more features such as
prepared statements and connection pooling.
Implement JavaScript with JSP
Step
1: Create employee form (EmployeeInformation.jsp)
Step
2 : Create "ProcessAction.jsp" for Process the Data
and forward according to user requirement.
Step
3: Create data insert action page ("JSPInsertAction.jsp")
Step
4: Create data deletion code from database ("ClearAction.jsp").
Step
5: Create update data code ("update.jsp").
code
EmployeeInformation.jsp
<%@ |
We will create
ProcessAction.jsp for getting all string value using with
getParameter() method and forward on different page like
JSPInsertAction.jsp, ClearAction.jsp, and update.jsp.
<%@ |
This code using for
insert data into database by using JDBC database. When you will
select same employee id and employee name then massage will display
employee id already exit in database.
JSPInsertAction.jsp
<%@ |
When, you will
select employee id and employee name then select delete radio button
after selecting delete radio button when you will click on submit
button then data will successfully delete from database.
ClearAction.jsp
<%@
|
update.jsp
<%@
page language="java" import="java.lang.*"
import="java.sql.*" %>
<HTML>
<BODY>
<%
Connection
con = null;
String url =
"jdbc:mysql://192.168.10.211:3306/";
String db =
"amar";
String driver = "com.mysql.jdbc.Driver";
String
userName ="amar";
String password="amar123";
String
rep=request.getParameter("empname");
String
code=(String)request.getParameter("empid");
int
ID=Integer.parseInt(code);
try {
Class.forName(driver);
con
= DriverManager.getConnection(url+db,userName,password);
String
rec="UPDATE Employee SET empname='"+rep+"' where
empid='"+ID+"'";
Statement
stmt=null;
stmt=con.createStatement();
int
mod=stmt.executeUpdate(rec);
if(mod==0) { %>
<script
language="javascript">
alert("This Emp ID
already Exists");
</script>
<%
}
if(mod==1)
{ %>
<script language="javascript">
alert("Record
Updated
Successfully");
</script>
<%
}
con.commit();
stmt.close();
con.close();
}
catch(Exception
e) { %>
<script language="javascript">
alert("Please
Enter New
Name");
document.location="EmplyeeInformation.jsp";
</script>
<%
}
%>
</BODY>
</HTML>
Working
with sessions
This JSP Tutorial
shows you how to track the session between different JSP pages. In
any web application user moves from one page to another and it
becomes necessary to track the user data and objects throughout the
application. JSP provide an implicit object "session",
which can be use to save the data specific the particular to the
user.
In this tutorial we
will create an application that takes the user name from the user and
then saves into the user session. We will display the saved data to
the user in another page.
Here is the code of
the JSP file (savenameform.jsp) that takes the input from user:
<%@
page language="java" %>
<html>
<head>
<title>Name
Input Form</title>
</head>
<body>
<form
method="post" action="savenametosession.jsp">
<p><b>Enter
Your Name: </b><input type="text"
name="username"><br>
<input
type="submit" value="Submit">
</form>
</body>
The
above page prompts the user to enter his/her name. Once the user
clicks on the submit button, savenametosession.jsp is called. The JSP
savenametosession.jsp retrieves the user name from request attributes
and saves into the user session using the function
session.setAttribute("username",username);. Here is
the code of savenametosession.jsp:
<%@
page language="java" %>
<%
String
username=request.getParameter("username");
if(username==null)
username="";
session.setAttribute("username",username);
%>
<html>
<head><title>Name
Saved</title></head>
<body>
<p><a
href="showsessionvalue.jsp">Next Page to view the
session value</a><p>
</body>
</html>
The
above JSP saves the user name into the session object and displays a
link to next pages (showsessionvalue.jsp). When user clicks on the
"Next Page to view session value" link, the JSP page
showsessionvalue.jsp displays the user name to the user. Here is the
code of showsessionvalue.jsp:
<%@
page language="java" %>
<%
String
username=(String)
session.getAttribute("username");
if(username==null)
username="";
%>
<html>
<head><title>Show
Saved Name</title></head>
<body>
<p>Welcome:
<%=username%><p>
</body>
</html>
The
function session.getAttribute("username") is used to
retrieve the user name saved in the session
JSP
Cookies
Let's understand the
cookies. Cookies are short pieces of data sent by web
servers to the client browser. The cookies are saved to clients
hard disk in the form of small text file. Cookies helps the web
servers
to identify web users, by this way server tracks the user. Cookies
pay very important role in the session tracking.
Cookie Class
In JSP cookie are
the object of the class javax.servlet.http.Cookie. This class
is used to creates a cookie, a small amount of information sent by a
servlet to a Web browser, saved by the browser, and later sent back
to the server. A cookie's value can uniquely identify a client, so
cookies are commonly used for session management. A cookie has a
name, a single value, and optional attributes such as a comment, path
and domain
qualifiers, a maximum age, and a version number.
The getCookies()
method of the request object returns an array of Cookie objects.
Cookies can be constructed using the following code:
Cookie(java.lang.String
name, java.lang.String value)
Cookie objects have
the following methods.
Method | Description |
getComment() | Returns |
getMaxAge() | Returns |
getName() | Returns |
getPath() | Returns |
getValue() | Returns |
setComment(String) | If |
setMaxAge(int) | Sets |
setPath(String) | This |
setValue(String) | Sets |
Example
using Cookies:
Here
is the code of the form (cookieform.jsp) which prompts the user to
enter his/her name.
<%@
page language="java" %>
<html>
<head><title>Cookie
Input Form</title></head>
<body>
<form
method="post" action="setcookie.jsp">
<p><b>Enter
Your Name: </b><input type="text"
name="username"><br>
<input type="submit"
value="Submit">
</form>
</body>
Above
form prompts the user to enter the user name. User input are posted
to the setcookie.jsp file, which sets the cookie. Here is the code of
setcookie.jsp file:
<%@
page language="java" import="java.util.*"%>
<%
String
username=request.getParameter("username");
if(username==null)
username="";
Date now = new Date();
String timestamp
= now.toString();
Cookie cookie = new Cookie
("username",username);
cookie.setMaxAge(365 * 24 * 60 *
60);
response.addCookie(cookie);
%>
<html>
<head><title>Cookie
Saved</title></head>
<body>
<p><a
href="showcookievalue.jsp">Next Page to view the cookie
value</a><p>
</body>
</html>
Above
code sets the cookie and then displays a link to view cookie page.
Here is the code of display cookie page (showcookievalue.jsp):
<%@
page language="java" %>
<%
String cookieName =
"username";
Cookie cookies [] = request.getCookies
();
Cookie myCookie = null;
if (cookies != null)
{
for
(int i = 0; i < cookies.length; i++)
{
if (cookies
[i].getName().equals (cookieName))
{
myCookie =
cookies[i];
break;
}
}
}
%>
<html>
<head>
<title>Show
Saved Cookie</title>
</head>
<body>
<%
if
(myCookie == null) {
%>
No Cookie found with the name
<%=cookieName%>
<%
} else {
%>
<p>Welcome:
<%=myCookie.getValue()%>.
<%
}
%>
</body>
</html>
When
user navigates to the above the page, cookie value is displayed.
Disabling
Session in JSP
Every time a JSP is
requested, JSP creates an HttpSession object to maintain state for
each unique client. The session data is accessible in the JSP as the
implicit session object. In JSPs, sessions are enabled by
default.
Session object uses the server resources. Each
session object uses up a small amount of system resources as it is
stored on the server side. This also increases the traffic as the
session ID is sent from server to client. Client also sends the same
session ID along with each request. If some of the JSP pages on your
web site are getting thousands of hits from internet browser and
there is not need to identify the user, so its better to disable the
session in that JSP page.
You can tell the container to
disable session in the JSP file by setting the session attribute to
false. Set the session attribute of the page directive to false, as
shown in the following example:
<%@ page
session="false" %>
Here is the full
code of jsp file in which session is disabled:
<%@
page language="java"
session="false"%>
<html>
<head>
<title>Session
Disabled</title>
</head>
<body>
<p>Session
is Disabled in this page
</body>
</html>
Calling Servlet
to build a List of data from database and show this on the JSP page
in table
This example
illustrate how a servlet can be used to create a data list from
database and how it can be added to the request object and sent to
the JSP page. We are using tomcat to run and test the application
In our example
"DataServlet.java" is the servlet which is making
the connection to the database and retrieves the data from database.
After getting the values from database, data is added to the Data
List. Then data list is added to the request object and sent to the
JSP page. In JSP page the values are displayed using Iterator
class object.
Table
structure for "message" is :
create
table `message` (
`id` double ,
`message` varchar
(256)
);
insert into `message` (`id`, `message`)
values('1','amit');
insert into `message` (`id`, `message`)
values('2','kumar');
insert into `message` (`id`, `message`)
values('3','singh');
insert into `message` (`id`, `message`)
values('4','raghuwanshi');
insert into `message` (`id`, `message`)
values('5','vineet');
insert into `message` (`id`, `message`)
values('6','sandeep');
insert into `message` (`id`, `message`)
values('7','suman');
insert into `message` (`id`, `message`)
values('8','vineet');
Following
code ads the data into request object:
request.setAttribute("data",dataList);
Following
code forwards the request to a JSP page:
RequestDispatcher
dispatcher = request.getRequestDispatcher(page);
if (dispatcher !=
null){
dispatcher.forward(request, response);
}
DataServlet.java
import java.io.*;
import java.util.*;
import java.sql.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class DataServlet extends HttpServlet{
private ServletConfig config;
//Setting JSP page
String page="DataPage.jsp";
public void init(ServletConfig config)
throws ServletException{
this.config=config;
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException,IOException
{
PrintWriter out = response.getWriter();
//Establish connection to MySQL database
String connectionURL = "jdbc:mysql://192.168.10.59/messagepaging";
Connection connection
=
null;
ResultSet rs;
response.setContentType("text/html");
List dataList
=
new ArrayList();
try {
// Load the database driver
Class.forName("com.mysql.jdbc.Driver");
// Get a Connection to the database
connection = DriverManager.getConnection(connectionURL, "root", "root");
//Select the data from the database
String sql = "select * from message";
Statement s = connection.createStatement();
s.executeQuery (sql);
rs = s.getResultSet();
while (rs.next ()){
//Add records into data list
dataList.add(rs.getInt("id"));
dataList.add(rs.getString("message"));
}
rs.close ();
s.close ();
}catch(Exception e){
System.out.println("Exception is ;"+e);
}
request.setAttribute("data",dataList);
//Disptching request
RequestDispatcher dispatcher = request.getRequestDispatcher(page);
if (dispatcher != null){
dispatcher.forward(request, response);
}
}
}
DataPage.jsp
<%@page
language="java" import="java.util.*"
%>
<html>
<head><title>Data
Page</title></head>
<body>
<table
border="1" width="303">
<tr>
<td
width="119"><b>ID</b></td>
<td
width="168"><b>Message</b></td>
</tr>
<%Iterator
itr;%>
<% List data= (List)request.getAttribute("data");
for
(itr=data.iterator(); itr.hasNext(); )
{
%>
<tr>
<td
width="119"><%=itr.next()%></td>
<td
width="168"><%=itr.next()%></td>
</tr>
<%}%>
</table>
</body>
</html>
For
servlet to be invoked we have to do following entry in the web.xml
file for servlet mapping
<!--web.xml
code -->
<servlet>
<servlet-name>DataServlet</servlet-name>
<servlet-class>DataServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DataServlet</servlet-name>
<url-pattern>/DataServlet</url-pattern>
</servlet-mapping>
For running the
above example we have to follow the following steps:
1.Create and Save
"DataServlet.java".
2.Compile that java file and place
the DataServlet.class file into classes folder.
3.Do the servlet
mapping in the web.xml
4.Create and Save "DataPage.jsp"
and place it into appropriate folder.
5.Deploy the Tomcat Server.
Access all the
fields from table through JSP
This is detailed
java
program to connect java application
with MySql database and execute query to display data from the
specified table. Before running this java code you need
mysql-connector-java-3.1.6-bin.jar file and set class path to
this file.
This is first jsp
page that has a link 'show data from table', which displays
all the data from table when clicked. This is the code of first
welcome jsp page
welcome_to_database_query.jsp
<!DOCTYPE
HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@
page import="java.sql.*" %>
<%@
page import="java.io.*" %>
<html>
<head>
<title>display data from the table using jsp</title></head>
<body>
<TABLE
style="background-color: #ffffcc;">
<TR>
<TD
align="center">
<h2>To
display all the data from the table click here...</h2></TD>
</TR>
<TR>
<TD
align="center"><A HREF="ConnectJspToMysql.jsp">
<font size="4" color="blue">show
data from
table</font></A></TD>
</TR>
</TABLE>
</body>
</html>
ConnectJspToMysql.jsp
<!DOCTYPE
HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@
page import="java.sql.*" %>
<%@
page import="java.io.*" %>
<html>
<head>
<title>display
data from the table using jsp</title>
</head>
<body>
<h2>Data
from the table 'stu_info' of database 'student'</h2>
<%
try {
/* Create
string of connection url within specified
format with
machine name, port number and database name.
Here machine
name id localhost and database name is student. */
String
connectionURL = "jdbc:mysql://localhost:3306/student";
// declare a
connection by using Connection interface
Connection
connection = null;
// declare
object of Statement interface that is used for
executing sql
statements.
Statement
statement = null;
// declare a
resultset that uses as a table for output data
from tha table.
ResultSet rs =
null;
// Load
JBBC driver "com.mysql.jdbc.Driver".
Class.forName("com.mysql.jdbc.Driver").newInstance();
/* Create a
connection by using getConnection()
method that
takes parameters of string type
connection url, user name and password to connect to database. */
connection =
DriverManager.getConnection(connectionURL, "root", "root");
/*
createStatement() is used for create statement
object
that is used for sending sql statements to the specified database.
*/
statement =
connection.createStatement();
// sql query to
retrieve values from the secified table.
String
QueryString = "SELECT * from stu_info";
rs =
statement.executeQuery(QueryString);
%>
<TABLE
cellpadding="15" border="1"
style="background-color: #ffffcc;">
<%
while (rs.next()) {
%>
<TR>
<TD><%=rs.getInt(1)%></TD>
<TD><%=rs.getString(2)%></TD>
<TD><%=rs.getString(3)%></TD>
<TD><%=rs.getString(4)%></TD>
</TR>
<% } %>
<%
// close all the
connections.
rs.close();
statement.close();
connection.close();
}
catch (Exception ex) {
%>
</font>
<font size="+3"
color="red"></b>
<%
out.println("Unable
to connect to database.");
}
%>
</TABLE><TABLE>
<TR>
<TD><FORM
ACTION="welcome_to_database_query.jsp" method="get"
>
<button
type="submit"><-- back</button></TD>
</TR>
</TABLE>
</font>
</body>
</html>
Use Break
Statement in jsp code
The break statement
is used to terminate the execution of near most enclosing loop or
conditional statement. Now the next statement outside the loop is
executed.
In the example given
below the elements of an array are added one by one. After each
addition, the sum is checked whether it is more than 12. If the sum
is less than 12 then the message "we are in loop..."
is displayed otherwise the control comes out of the loop and does not
print the same line again for this iteration. The rest iterations are
also not executed because the loop is now terminated and the control
is on the next statement after loop.
break_statement_jsp.jsp
<!DOCTYPE "http://www.w3.org/TR/html4/loose.dtd"> <HTML> <HEAD> <TITLE>Using </HEAD> <BODY> <H1>use <% double int for(int sum if } %> </BODY> </HTML> |
Create dynamic
page through JSP
This is detailed jsp
code that shows how to create dynamic page. This code shows one by
one record of student from database on click a button named 'next
record'. On each click of button, application fetch next record
from database.
Create
a database : Before running this jsp code, first create a
database named 'student' through the sql query given below in
mysql command prompt:
mysql> |
Then
create a table named 'stu_info' in the same database through
following sql query :-
create |
Create your
application directory named "user" in the Tomcat server.
Before running this java code you need mysql connector jar in the
Tomcat-6.0.16/webapps/user/WEB-INF/lib.
ConnectJspToMysql.jsp:
This file provides
full code how to connect with database and showing the next record of
database in JSP.
<!DOCTYPE
HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@
page import="java.sql.*" %>
<%@
page import="java.io.*" %>
<HTML>
<HEAD>
<TITLE>Navigating in a Database Table </TITLE></HEAD>
<BODY
bgcolor="#ffffcc">
<font
size="+3" color="green"><br>Welcome in
www.roseindia.net !</font>
<br>
<font
size="+1" color="#6E6E6E"><br>This is
dynamic page that shows data<br>
from
database as per user choice.</font>
<%
int current = 0;
// declare a
connection by using Connection interface
Connection
connection = null;
/* Create
string of connection url within specified format with machine
name,
port number and database name. Here machine name id localhost
and
database name is student. */
String
connectionURL = "jdbc:mysql://localhost:3306/student";
/*declare a
resultSet that works as a table resulted by execute a specified
sql query. */
ResultSet rs
= null;
%>
<FORM
NAME="form1" ACTION="ConnectJspToMysql.jsp"
METHOD="get"><%
if
(request.getParameter("hidden") != null) {
current =
Integer.parseInt(request.getParameter("hidden"));
}
// Declare
statement.
Statement
statement = null;
try {
// Load
JDBC driver "com.mysql.jdbc.Driver"
Class.forName("com.mysql.jdbc.Driver").newInstance();
/* Create
a connection by using getConnection() method that takes
parameters
of string type connection url, user name and password to
connect
to database. */
connection
= DriverManager.getConnection(connectionURL, "root",
"root");
/*
createStatement() is used for create statement object that is
used
for sending sql statements to the specified database. */
statement
= connection.createStatement();
//
executeQuery() method execute specified sql query.
rs =
statement.executeQuery("select * from stu_info");
for (int
i = 0; i < current; i++) {
rs.next();
}
if
(!rs.next()) {
%>
<FONT
size="+2" color="red"></b>
<%
out.println("Sorry
! found some problems with database.");
} else {
%>
<TABLE
style="background-color: #ECE5B6;" WIDTH="30%" >
<TR><TH
width="50%">ID</TH><TD width="50%">
<%= rs.getInt(1)%> </TD></tr>
<TR><TH>Name</TH><TD>
<%= rs.getString(2)%> </TD></tr>
<TR><TH>City</TH><TD>
<%= rs.getString(3)%> </TD></tr>
<TR><TH>Phone</TH><TD>
<%= rs.getString(4)%> </TD></tr>
</TR>
</TABLE>
<BR>
<INPUT
TYPE="hidden" NAME="hidden" VALUE="<%=current
+ 1%>">
<INPUT
TYPE="submit" VALUE="next record">
</FORM>
<%
}
}
catch
(Exception ex) {
%>
<FONT
size="+3" color="red"></b>
<%
out.println("Unable
to connect to database.");
} finally {
// close
all the connections.
rs.close();
statement.close();
connection.close();
}
%>
</FONT>
</FORM>
</body>
</html>
Save
this code as a .jsp file named "ConnectJspToMysql.jsp"
in the directory Tomcat-6.0.16/webapps/user/ and run this jsp page
Retrieve image
from mysql database through jsp
First create a
database of structure given below and save images. Here we will use
table 'save_image' of database 'mahendra'.
First create
database named 'mahendra' by query given below....
mysql>
create database mahendra;
Structure of
table 'save_image'
CREATE
); |
Create application
directory named "user" in the tomcat-6.0.16/webapps. Before
running this java code you need mysql connector jar file in the
Tomcat-6.0.16/webapps/user/WEB-INF/lib.
Note : In the
jsp code given below, image will be retrieved from database on the
basis of 'id' field of the table. So code will retrieve image
of specified 'id' value. In this example we will retrieve image with
'id' value 11. So before running this jsp code first check whether
image for the specified 'id' value is present.
retrieve_image.jsp
<%@
page import="java.sql.*" %>
<%@ page
import="java.io.*" %>
<% // declare a
connection by using Connection interface Connection connection =
null;
/* Create string of connection url within specified format
with machine
name, port number and database name. Here
machine name id localhost
and database name is mahendra.
*/
String connectionURL =
"jdbc:mysql://localhost:3306/mahendra";
/*declare a
resultSet that works as a table resulted by execute a specified
sql
query. */
ResultSet rs = null;
// Declare
statement.
PreparedStatement psmnt = null;
// declare
InputStream object to store binary stream of given image.
InputStream
sImage;
try {
// Load JDBC driver
"com.mysql.jdbc.Driver"
Class.forName("com.mysql.jdbc.Driver").newInstance();
/*
Create a connection by using getConnection() method that
takes
parameters of string type connection url, user name
and password to
connect to database. */
connection =
DriverManager.getConnection(connectionURL, "root",
"root");
/* prepareStatement() is used for create
statement object that is
used for sending sql statements to
the specified database. */
psmnt =
connection.prepareStatement("SELECT image FROM save_image WHERE
id = ?");
psmnt.setString(1, "11"); // here integer
number '11' is image id from the table
rs =
psmnt.executeQuery();
if(rs.next()) {
byte[] bytearray = new
byte[1048576];
int size=0;
sImage =
rs.getBinaryStream(1);
response.reset();
response.setContentType("image/jpeg");
while((size=sImage.read(bytearray))!=
-1
){
response.getOutputStream().write(bytearray,0,size);
}
}
}
catch(Exception
ex){
out.println("error :"+ex);
}
finally {
//
close all the
connections.
rs.close();
psmnt.close();
connection.close();
}
%>
Save
this code as a .jsp file named "retrieve_image.jsp"
in the application directory in Tomcat-6.0.16 and run this jsp page
How To Page
Refresh Using JavaScript In JSP
Brief description
of the flow of the application:
User opens
sign.jsp in the browser and clicks on "Sign
In" button.
New opens where
user can provide username and password.
If user enters
correct username and password user. If the login is
successful, parent window is refreshed and user details is
displayed.
User can also
signup for new account.
Step1:
sign.jsp
<%@
page import="java.sql.*" %>
<!DOCTYPE
HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE> New
Document </TITLE>
<META
NAME="Generator" CONTENT="EditPlus">
<META
NAME="Author" CONTENT="">
<META
NAME="Keywords" CONTENT="">
<META
NAME="Description" CONTENT="">
<script>
function signout()
{
window.location.href="signout.jsp";
}
</script>
</HEAD>
<BODY>
<br><br><br><br><br>
<table
width="250px" align="center" bgcolor="#CDFFFF"
border=0 style="border:1px solid;">
<%
if(session.getAttribute("username")!=null
&& session.getAttribute("password")!=null)
{
String username="";
String pass="";
Connection
conn = null;
String url =
"jdbc:mysql://localhost:3306/";
String dbName =
"user_register";
String driver =
"com.mysql.jdbc.Driver";
String userName =
"root";
String password =
"root";
String data = "";
int sumcount=0;
Statement
st;
try {
Class.forName(driver).newInstance();
conn =
DriverManager.getConnection(url+dbName,userName,password);
username = session.getAttribute("username").toString();
pass = session.getAttribute("password").toString();
String query =
"select *
from userregister where username='"+username+"' and
password='"+pass+"'";
st =
conn.createStatement();
ResultSet rs = st.executeQuery(query);
if(rs.next())
{
%>
<tr><td colspan=3 align="center"><b>User
Details</b></td></tr>
<tr><td><b>User Name
</b></td><td><b>:</b></td><td><%=rs.getString(2)%></td></tr>
<tr><td><b>First Name
</b></td><td><b>:</b></td><td><%=rs.getString(4)%></td></tr>
<tr><td><b>Last Name
</b></td><td><b>:</b></td><td><%=rs.getString(5)%></td></tr>
<tr><td><b>City
</b></td><td><b>:</b></td><td><%=rs.getString(6)%></td></tr>
<tr><td><b>State
</b></td><td><b>:</b></td><td><%=rs.getString(7)%></td></tr>
<tr><td><b>Country</b></td><td><b>:</b></td><td><%=rs.getString(8)%></td></tr>
<%
}
out.println(data);
}
catch
(Exception e) {
e.printStackTrace();
}
%>
<tr>
<td
align="center" colspan=3>
<input
type="button" name="signout" value="Sign
Out" onclick="signout();">
</td>
</tr>
<%
}
else
{
%>
<tr><td
colspan=2> </td></tr>
<tr><td
colspan=2 align="center"><b>To Login User Click
on Sign In</b></td></tr>
<tr><td
colspan=2> </td></tr>
<tr>
<td
colspan="2" align="center">
<input
type="button" name="signin" value="Sign In"
onClick="window.open('userlogin.jsp','mywindow','width=500,
height=350,toolbar=no,resizable=yes,menubar=yes')">
</td></tr>
<tr><td
colspan=2> </td></tr>
<%
}
%>
</table>
</BODY>
</HTML>
Step2:
userlogin.jsp
<html>
<head>
<style>
a{
font:
bold 13px Verdana;
padding: 2px;
padding-left: 4px;
display:
block;
width: 100px;
color: black;
text-decoration:
underline;
}
a:hover{
color: black;
text-decoration:
none;
}
</style>
<script>
function
validate()
{
if(document.frm.username.value=="")
{
alert("Please
enter username");
document.frm.username.focus();
return
false;
}
if(document.frm.password.value=="")
{
alert("Please
enter username");
document.frm.password.focus();
return
false;
}
return true;
}
function trim(stringToTrim)
{
return stringToTrim.replace(/^\s+|\s+$/g,"");
}
function
login()
{
if(validate())
{
xmlHttp=GetXmlHttpObject()
if
(xmlHttp==null)
{
alert ("Browser does not support HTTP
Request")
return
}
var username
=document.getElementById("username").value;
var password
=document.getElementById("password").value;
var
url="userloginmid.jsp"
url=url+"?username="+username+"&password="+password;
//alert(url);
xmlHttp.onreadystatechange=stateChanged
xmlHttp.open("GET",url,true)
xmlHttp.send(null)
}
}
function
stateChanged()
{
if (xmlHttp.readyState==4 ||
xmlHttp.readyState=="complete")
{
var showdata
= xmlHttp.responseText;
var str =
showdata.toString();
if(trim(str)=="successLogin")
{
window.opener.location.reload();
window.location.reload();
window.close();
}
else
{
window.location.href="userlogin.jsp?errmsg=error";
}
}
}
function
GetXmlHttpObject()
{
var xmlHttp=null;
try
{
//
Firefox, Opera 8.0+, Safari
xmlHttp=new XMLHttpRequest();
}
catch
(e)
{
//Internet Explorer
try
{
xmlHttp=new
ActiveXObject("Msxml2.XMLHTTP");
}
catch
(e)
{
xmlHttp=new
ActiveXObject("Microsoft.XMLHTTP");
}
}
return
xmlHttp;
}
</script>
</head>
<body>
<br><br>
<%
String
errmsg="";
if(request.getParameter("errmsg")!=null
&& request.getParameter("errmsg")!="")
{
errmsg
="Invalid username and password";
}
%>
<form
name="frm">
<table border="0"
width="400px" align="center"
bgcolor="#CDFFFF">
<tr><td colspan=2
align="center"
style="color:red;"><%=errmsg%></td></tr>
<tr><td
colspan=2 align="center"> </td></tr>
<tr><td
colspan=2 align="center"><b>User
Login</b></td></tr>
<tr><td>Username
: </td><td><input type="text"
name="username" id="username"></td></tr>
<tr><td>Password
: </td><td><input type="password"
name="password" id="password"></td></tr>
<tr><td
colspan=2 align="center"><input type="button"
name="submit" value="Submit"
onclick="login();"></td></tr>
<tr><td
colspan=2 align="center"><a
href="user_register.jsp">New
User</a></td></tr>
</form>
</body>
</html>
Step3:
userloginmid.jsp
<%@
page import="java.sql.*" %>
<%
String
username = request.getParameter("username").toString();
String
pass = request.getParameter("password").toString();
Connection
conn = null;
String
url = "jdbc:mysql://localhost:3306/";
String
dbName = "user_register";
String
driver = "com.mysql.jdbc.Driver";
String
userName = "root";
String
password = "root";
String
data = "";
int
sumcount=0;
Statement
st;
try
{
Class.forName(driver).newInstance();
conn
= DriverManager.getConnection(url+dbName,userName,password);
String
query = "select count(*) from userregister where
username='"+username+"' and password='"+pass+"'";
st
= conn.createStatement();
ResultSet
rs =
st.executeQuery(query);
if(rs.next())
{
System.out.println(query);
if(rs.getInt(1)>0)
{
session.setAttribute("username",username);
session.setAttribute("password",pass);
data
= "successLogin";
}
}
out.println(data);
}
catch
(Exception e) {
e.printStackTrace();
}
%>
Step4:
useradd.jsp
<%@
page import="java.sql.*" %>
<%
String
username = request.getParameter("username").toString();
String
pass = request.getParameter("password").toString();
String
first_name = request.getParameter("first_name").toString();
String
last_name = request.getParameter("last_name").toString();
String
city = request.getParameter("city").toString();
String
state = request.getParameter("state").toString();
String
country = request.getParameter("country").toString();
String
data="";
Connection
conn = null;
String url = "jdbc:mysql://localhost:3306/";
String
dbName = "user_register";
String driver =
"com.mysql.jdbc.Driver";
String userName =
"root";
String password = "root";
int
sumcount=0;
Statement st;
try
{
Class.forName(driver).newInstance();
conn =
DriverManager.getConnection(url+dbName,userName,password);
String
query = "insert into userregister set
username='"+username+"',password='"+pass+"',first_name='"+first_name+
"',last_name='"+last_name+"',city='"+city+"',state='"+state+"',country='"+country+"'";
System.out.println("query
: " + query);
st = conn.createStatement();
int i =
st.executeUpdate(query);
if(i>0)
{
data
="successAdd";
}
out.println(data.trim());
}
catch
(Exception e) {
e.printStackTrace();
}
%>
Calendar
In JSP Using JavaScript
In this section, we
develop a Calendar application in JSP
using JavaScript. We created the following files for the application:
1. emp_event.jsp
2.
viewevent.jsp
3. eventdisp.jsp and
4. emp_event.java
Brief description
of the flow of the application:
User opens
emp_event.jsp in the browser and clicks on
"Save" button.
Import
datepicker.js to include a date picker in emp_event.jsp.
Servlet
emp_event.java inserts the data into the database
and redirects to viewevent.jsp.
Add the Event
Description on the particular date and having a link "Click
here To Show Event"..
Open a
viewevent.jsp in the browser and select Employee Id,
date and click on "Show" button.
New Pop window
eventdisp.jsp opens which displays the description of event
on corresponding date.
Step1:
emp_event.jsp
<%@
page import="java.sql.*" %>
<html>
<head>
<style>
A:hover
{
text-decoration:
none;
border: 0px;
font-size:14pt;
color: #2d2b2b; }
</style>
<link
rel="stylesheet" type="text/css"
href="datepicker.css"/>
<script
type="text/javascript" src="datepicker.js"></script>
<script>
function
validate()
{
var sdate = document.frm.date.value;
var sdateAr=sdate.split("-");
if(document.frm.date.value=="")
{
alert("Please
enter the date.");
document.frm.date.focus();
return
false;
}
if(sdateAr.length!=3)
{
alert("Please
enter valid Date in
mm-dd-yyyy
format.");
document.frm.date.value="";
document.frm.date.focus();
return
false;
}
if(document.frm.event_description.value=="")
{
alert("Please
enter the event description.");
document.frm.event_description.focus();
return
false;
}
return
true;
}
</script>
</head>
<body>
<br><br><br>
<form
method="post" name="frm" action="empevent"
onsubmit=
"return
validate();">
<table
border="0" width="400px" align="center"
bgcolor="#CDFFFF">
<tr><td
colspan=2 style="font-size:10pt;color:#ff0000;"
align="center"></td></tr>
<tr><td
colspan=2 style="font-size:12pt;color:#00000;"
align="center">
<h3>Employee
Event</h3></td></tr>
<tr><td> </td></tr>
<tr><td
><b>Date:</b></td><td><input
type="text" name="date"
id="cdate">
<input
type=button value="Select Date" onclick=
"displayDatePicker('date',
this);">
</td></tr>
<tr><td><b>Description:</b></td><td>
<textarea
name="event_description" rows="5" cols="25">
</textarea></td></tr>
<tr><td> </td></tr>
<tr><td
colspan=2 align="center"><input
type="submit"
name="submit" value="Save"></td></tr>
</table>
</form>
<table
border="0" width="100%" align="center">
<br><br>
<tr>
<td width="100%"
align="center">
<a
href="viewevent.jsp"
style="font-size:14pt;color:blue;">Click here to Show
Event</a></td>
</tr>
</table>
</body>
</html>
Step2:
emp_event.java
import
java.io.*;
import javax.servlet.*;
import
javax.servlet.http.*;
import javax.sql.*;
import
java.sql.*;
public class emp_event extends
HttpServlet{
public void doPost(HttpServletRequest
request, HttpServletResponse response)
throws
ServletException,IOException{
response.setContentType("text/html");
PrintWriter
out = response.getWriter();
System.out.println("MySQL
Connect Example.");
Connection conn = null;
String url =
"jdbc:mysql://localhost:3306/";
String dbName =
"user_register";
String driver =
"com.mysql.jdbc.Driver";
String userName =
"root";
String password = "root";
Statement
st;
try {
Class.forName(driver).newInstance();
conn =
DriverManager.getConnection(url+dbName,userName,password);
System.out.println("Connected
to the database");
String date =
request.getParameter("date");
String event_description =
request.getParameter("event_description");
String
strar[] = date.split("-");
String cdate =
strar[2]+"-" + strar[0]+"-"+ strar[1];
String
query = "insert into emp_event set
date_of_event='"+cdate+"',event_description='"+event_description+"'";
System.out.println("query
" + query);
out.println("query " + query);
st =
conn.createStatement();
int i =
st.executeUpdate(query);
if(i>0)
{
response.sendRedirect("viewevent.jsp");
}
else
{
response.sendRedirect("emp_event.jsp");
}
out.println(query);
conn.close();
System.out.println("Disconnected
from database");
} catch (Exception e)
{
e.printStackTrace();
}
}
}
Step3:
view_event.jsp
<%@
page import="java.sql.*" %>
<html>
<head>
<style>
A:hover
{
text-decoration:
none;
border: 0px;
font-size:14pt;
color: #2d2b2b;
}
</style>
<link
rel="stylesheet" type="text/css"
href="datepicker.css"/>
<script
type="text/javascript"
src="datepicker.js"></script>
<script>
function
validate()
{
if(document.getElementById("emp_id").value==-1)
{
alert("Please
select employee id");
return
false;
}
if(document.getElementById("date").value=="")
{
alert("Please
enter date");
return false;
}
return true
}
function
mywin()
{
if(validate()) {
var date =
document.getElementById("date").value;
var emp_id =
document.getElementById("emp_id").value;
var page =
"eventdisp.jsp?date="+date +
"&emp_id="+emp_id;
window.open(page,'mywindow','width=500,height=350,toolbar=no,resizable=yes,menubar=yes');
}
}
</script>
</head>
<body>
<br><br><br>
<form
method="post" name="frm"
action="empevent">
<table border="0"
width="400px" align="center"
bgcolor="#CDFFFF">
<tr><td colspan=2
style="font-size:12pt;color:#00000;"
align="center"><h3>Select
Event</h3></td></tr>
<tr><td
colspan=2> </td></tr>
<tr><td
><b>Employee Id</b></td><td>
<select
name="emp_id" id="emp_id">
<option
value=-1>Select</option>
<%
Connection conn =
null;
String url = "jdbc:mysql://localhost:3306/";
String
dbName = "user_register";
String driver =
"com.mysql.jdbc.Driver";
String userName =
"root";
String password = "root";
int
sumcount=0;
Statement st;
try
{
Class.forName(driver).newInstance();
conn =
DriverManager.getConnection(url+dbName,userName,password);
String
query = "select * from emp_event order by
emp_id";
out.println("query "+query);
st =
conn.createStatement();
ResultSet rs =
st.executeQuery(query);
out.println("dkfhdsf");
while(rs.next()){
%>
<option
value=<%=rs.getInt(1)%>><%=rs.getInt(1)%></option>
<%
}
}
catch (Exception e)
{
e.printStackTrace();
}
%>
</select>
</td></tr>
<tr><td
><b>Date:</b></td><td><input
type="text" name="date" id="date">
<input
type=button value="Select Date"
onclick="displayDatePicker('date',
this);">
</td></tr>
<tr><td> </td></tr>
<tr><td
colspan=2 align="center"><input type="button"
name="show" value="Show"
onclick="mywin();"></td></tr>
</table>
</form>
</body>
</html>
Step4:
event_disp.jsp
<%@
page import="java.sql.*" %>
<br><br>
<span
style='padding-left:150px;'><b>Event
Description</b></span>
<%
int emp_id =
Integer.parseInt(request.getParameter("emp_id").toString());
String
date = request.getParameter("date").toString();
String
strar[] = date.split("-");
String edate = strar[2]+"-"
+ strar[0]+"-"+ strar[1];
Connection conn =
null;
String url = "jdbc:mysql://localhost:3306/";
String
dbName = "user_register";
String driver =
"com.mysql.jdbc.Driver";
String userName =
"root";
String password = "root";
int
sumcount=0;
Statement st;
try
{
Class.forName(driver).newInstance();
conn =
DriverManager.getConnection(url+dbName,userName,password);
String
query = "select * from emp_event where emp_id="+emp_id+"
and date_of_event='"+edate+"'";
st =
conn.createStatement();
ResultSet rs =
st.executeQuery(query);
if(rs.next()){
%>
<p
style="color:#000000;border:1px solid
#000000;background-color:#CDFFFF;"><%=rs.getString(3)%></p>
<%
}
else{
%>
<p
style="color:#000000;border:1px solid
#000000;background-color:#CDFFFF;text-align:center">No
Description</p>
<%
}
}
catch (Exception e)
{
e.printStackTrace();
}
%>
<span
style='padding-left:150px;'><a
href="javascript:window.close()">Window Close</a>
</span>
User
Registration Form Using JSP(JspBeans)
One of the basic
programming tactics of jsp is to assign as much processing as
possible to java Bean component. It will not only provide basic data
validation for the registration information input by a user, but will
also exhibit stateful behavior.
Step 1: Create a
simple registration form (register.html):
<html> |
Step2:
These pages would still specify the bulk of the processing to
component beans, but they would also contain some conditional logic
to respond to a user's actions. But these controller pages would
never contain presentation logic to display UI elements. This task
would always be externalized into separate JSPs, which will be
invoked as needed by the controller.
<%@ page
language="java" %>
<%@ page import="java.util.*"
%>
<%!
%>
<jsp:useBean id="formHandler"
class="test.FormBean" scope="request">
<jsp:setProperty
name="formHandler" property="*"/>
</jsp:useBean>
<%
if
(formHandler.validate()) {
%>
<jsp:forward
page="success.jsp"/>
<%
} else
{
%>
<jsp:forward page="retry.jsp"/>
<%
}
%>
Step3:
In this step when developing beans for processing form data, you
can follow a common design pattern by matching the names of the beans
properties with the names of the form input elements. you would also
need to define the corresponding getter and setter methods for each
property within the bean.
package
test;
import java.io.*;
import java.util.*;
public
class FormBean {
private String firstName;
private String
lastName;
private String email;
private String
userName;
private String password1;
private String
password2;
private String zip;
private String[]
faveTech;
private String notify;
private Hashtable
errors;
public boolean validate() {
boolean bool=true;
if
(firstName.equals("")) {
errors.put("firstName","Please
enter your first name");
firstName="";
bool=false;
}
if
(lastName.equals("")) {
errors.put("lastName","Please
enter your last name");
lastName="";
bool=false;
}
if
(email.equals("") || (email.indexOf('@') == -1))
{
errors.put("email","Please enter a valid email
address");
email="";
bool=false;
}
if
(userName.equals("")) {
errors.put("userName","Please
enter a username");
userName="";
bool=false;
}
if
(password1.equals("") ) {
errors.put("password1","Please
enter a valid password");
password1="";
bool=false;
}
if
(!password1.equals("") && (password2.equals("")
||
!password1.equals(password2)))
{
errors.put("password2","Please confirm your
password");
password2="";
bool=false;
}
if
(zip.equals("") || zip.length() !=6 )
{
errors.put("zip","Please enter a valid zip
code");
zip="";
bool=false;
} else {
try
{
int x = Integer.parseInt(zip);
} catch (NumberFormatException
e) {
errors.put("zip","Please enter a valid zip
code");
zip="";
bool=false;
}
}
return
bool;
}
public String getErrorMsg(String s) {
String
errorMsg =(String)errors.get(s.trim());
return (errorMsg == null)
? "":errorMsg;
}
public FormBean()
{
firstName="";
lastName="";
email="";
userName="";
password1="";
password2="";
zip="";
faveTech
= new String[] { "1" };
notify="";
errors =
new Hashtable();
}
public String getFirstName() {
return
firstName;
}
public String getLastName() {
return
lastName;
}
public String getEmail() {
return
email;
}
public String getUserName() {
return
userName;
}
public String getPassword1() {
return
password1;
}
public String getPassword2() {
return
password2;
}
public String getZip() {
return zip;
}
public
String getNotify() {
return notify;
}
public String[]
getFaveTech() {
return faveTech;
}
public String
isCbSelected(String s) {
boolean found=false;
if
(!faveTech[0].equals("1")) {
for (int i = 0; i <
faveTech.length; i++) {
if (faveTech[i].equals(s))
{
found=true;
break;
}
}
if (found) return
"checked";
}
return "";
}
public
String isRbSelected(String s) {
return (notify.equals(s))?
"checked" : "";
}
public void
setFirstName(String fname) {
firstName =fname;
}
public void
setLastName(String lname) {
lastName =lname;
}
public void
setEmail(String eml) {
email=eml;
}
public void
setUserName(String u) {
userName=u;
}
public void
setPassword1(String p1) {
password1=p1;
}
public void
setPassword2(String p2) {
password2=p2;
}
public void
setZip(String z) {
zip=z;
}
public void setFaveTech(String[]
music) {
faveTech=music;
}
public void setErrors(String key,
String msg) {
errors.put(key,msg);
}
public void
setNotify(String n) {
notify=n;
}
}
Step
4: Create a "retry.jsp" file for displaying
error. If the user submits the form without fulfilling field,
proces.jsp will return on retry.jsp page. The
processing logic within the controller page is straight forward.
After the bean is instantiated, its validate() method is
invoked. The validate() method has a two-pronged effect. If an error
is encountered during the validation of any form input element, the
validate() method not only resets the value of the corresponding bean
property, but also sets an appropriate error message, which can later
be displayed for that input element. If any of the required form
elements cannot be successfully validated, the controller forwards
the request to the JSP page retry.jsp allowing the user to make
changes and resubmit the form. If there are no validation errors, the
request is forwarded to success.jsp
<jsp:useBean
id="formHandler" class="test.FormBean"
scope="request"/>
<html>
<body>
<center>
<table
cellpadding=1 cellspacing=1 border="1" >
<th
bgcolor="lightblue" colspan=2>
<font size=5>User
Registration Successfull!</font>
</th>
<font
size=4>
<tr bgcolor="lightblue">
<td
valign=top>
<b>First
Name</b>
<br>
<jsp:getProperty
name="formHandler" property="firstName"/>
</td>
<td
valign=top>
<b>Last Name</b>
<br>
<jsp:getProperty
name="formHandler" property="lastName"/>
</td>
</tr>
<tr
bgcolor="lightblue">
<td
valign=top>
<b>E-Mail</b>
<br>
<jsp:getProperty
name="formHandler" property="email"/>
<br></td>
<td
valign=top>
<b>Zip Code</b>
<br>
<jsp:getProperty
name="formHandler" property="zip"/>
</td>
</tr>
<tr
bgcolor="lightblue">
<td valign=top
colspan=2>
<b>User Name</b>
<br>
<jsp:getProperty
name="formHandler" property="userName"/>
</td>
</tr>
<tr
bgcolor="lightblue">
<td colspan=2
valign=top>
<b>What Technology are you interested
in?</b>
<br>
<%
String[] faveTech =
formHandler.getFaveTech();
if (!faveTech[0].equals("1"))
{
out.println("<ul>");
for (int i=0;
i<faveTech.length;
i++)
out.println("<li>"+faveTech[i]);
out.println("</ul>");
}
else out.println("Nothing was selected");
%>
</td>
</tr>
<tr
bgcolor="lightblue">
<td colspan=2
valign=top>
<b>Would you like to receive e-mail
notifications on our special
sales?</b>
<br>
<jsp:getProperty
name="formHandler"
property="notify"/>
</td>
</tr>
</font>
</table>
</center>
</body>
</html>
Step5:
Create a "success.jsp" file for displaying all data
entered by user. As stated earlier, the controller forwards the
request to success.jsp only after all of the submitted form data has
been successfully validated. Success.jsp in turn extracts the bean
component from the request and confirms the registration to the
client.
<jsp:useBean
id="formHandler" class="test.FormBean"
scope="request"/>
<html>
<body>
<form
action="proces.jsp" method=post>
<center>
<table
cellpadding=4 cellspacing=2 border=0>
<th
bgcolor="lightblue" colspan=2>
<font size=5>User
Registration</font>
<br>
<font size=2
color="red"><sup>*</sup> Required Fields
</font>
</th>
<tr bgcolor="lightblue">
<td
valign=top>
<B>First
Name<sup>*</sup></B>
<br>
<input
type="text"
name="firstName"
value='<%=formHandler.getFirstName()%>'
size=15 maxlength=20>
<br><font
size=2
color=red><%=formHandler.getErrorMsg("firstName")%></font>
</td>
<td
valign=top>
<B>Last Name<sup>*</sup></B>
<br>
<input
type="text"
name="lastName"
value='<%=formHandler.getLastName()%>'
size=15 maxlength=20>
<br><font
size=2
color=red><%=formHandler.getErrorMsg("lastName")%></font>
</td>
</tr>
<tr
bgcolor="lightblue">
<td
valign=top>
<B>E-Mail<sup>*</sup></B>
<br>
<input
type="text" name="email"
value='<%=formHandler.getEmail()%>'
size=25
maxlength=125>
<br><font size=2
color=red><%=formHandler.getErrorMsg("email")%></font>
</td>
<td
valign=top>
<B>Zip Code<sup>*</sup></B>
<br>
<input
type="text" name="zip"
value='<%=formHandler.getZip()%>'
size=5
maxlength=6>
<br><font size=2
color=red><%=formHandler.getErrorMsg("zip")%></font>
</td>
</tr>
<tr
bgcolor="lightblue">
<td valign=top
colspan=2>
<B>User Name<sup>*</sup></B>
<br>
<input
type="text" name="userName"
size=10
value='<%=formHandler.getUserName()%>'
maxlength=10>
<br><font
size=2
color=red><%=formHandler.getErrorMsg("userName")%></font>
</td>
</tr>
<tr
bgcolor="lightblue">
<td
valign=top>
<B>Password<sup>*</sup></B>
<br>
<input
type="password" name="password1"
size=10
value='<%=formHandler.getPassword1()%>'
maxlength=10>
<br><font
size=2
color=red><%=formHandler.getErrorMsg("password1")%></font>
</td>
<td
valign=top>
<B>Confirm
Password<sup>*</sup></B>
<br>
<input
type="password" name="password2"
size=10
value='<%=formHandler.getPassword2()%>'
maxlength=10>
<br><font
size=2
color=red><%=formHandler.getErrorMsg("password2")%></font>
</td>
<br>
</tr>
<tr
bgcolor="lightblue">
<td colspan=2
valign=top>
<B>What Technology are you interested
in?</B>
<br>
<input type="checkbox"
name="faveTech"
value="Java"<%=formHandler.isCbSelected("Java")%>>Java
<input
type="checkbox" name="faveTech"
value="JSP"
<%=formHandler.isCbSelected("JSP")%>>JSP
<input
type="checkbox" name="faveTech" value="Struts
1.1"
<%=formHandler.isCbSelected("Struts
1.1")%>>Struts 1.1<br>
<input type="checkbox"
name="faveTech"
value="Ajax"
<%=formHandler.isCbSelected("Ajax")%>>Ajax
<input
type="checkbox" name="faveTech" value="Struts
2.0"
<%=formHandler.isCbSelected("Struts
2.0")%>>Struts 2.0
<input type="checkbox"
name="faveTech"
value="Servlets"
<%=formHandler.isCbSelected("Servlets")%>>Servlets<br>
</td>
</tr>
<tr
bgcolor="lightblue">
<td colspan=2
valign=top>
<B>Would you like to receive e-mail
notifications on our special sales?</B>
<br>
<input
type="radio" name="notify"
value="Yes"
<%=formHandler.isRbSelected("Yes")%>>Yes
<input
type="radio" name="notify"
value="No"
<%=formHandler.isRbSelected("No")%>>
No
<br><br></td>
</tr>
<tr
bgcolor="lightblue">
<td colspan=2
align=center>
<input type="submit" value="Submit">
<input type="reset"
value="Reset">
</td>
</tr>
</table>
</center>
</form>
</body>
</html>
Record
user login and logout timing In JSP
we
have developed a web application of maintain record of the user Login
and Logout Time in JSP. Six files are used
"home.jsp","login.jsp",
"userloginmid.jsp", "welcome.jsp","logout.jsp"
and "userstatus.jsp" in the code given below.
Brief
description of the flow of application :
1.
Create a webpage "home.jsp" to login the user
and show the user login status link.
2.
Create a webpage "login.jsp" to login the
user.
3.
Create a webpage "welcome.jsp" to display a
message after successful login.
4.
Create a webpage "userstatus.jsp" to display
all the Login and Logout User status.
Step:1
Create Table for Database : "userregister"
create
table `userregister` (
`id` double ,
`username` varchar
(50),
`password` varchar (50),
`first_name` varchar
(50),
`last_name` varchar (50),
`city` varchar (50),
`state`
varchar (50),
`country` varchar (50)
);
"admin"
create
table `admin` (
`id` double ,
`userid` double ,
`intime`
datetime ,
`outtime` datetime
);
Step:2
Create a web page "home.jsp" to login
and display the user status link.
<HTML>
<HEAD>
<TITLE>Login Application</TITLE>
</HEAD>
<BODY>
<br><br><br><br><br>
<table align="center">
<%
if(session.getAttribute("username")!=null && session.getAttribute("username")!="")
{
%>
<tr><td align="left"><a href="logout.jsp">Click Here to Logout</a></td></tr>
<%
}
else
{
%>
<tr><td align="left"><a href="login.jsp">Click Here to User Login</a></td></tr>
<%
}
%>
<tr><td align="left"> </td></tr>
<tr><td align="left"><a href="userstatus.jsp">View Users Logon status</a></td></tr>
</table>
</BODY>
</HTML>
Step:3
To create a "login.jsp" to login the user
<html>
<head>
</head>
<body>
<br><br><br>
<table align="center" width="400px" border=0>
<tr><td align="right" width="300"><a href="home.jsp">Home</a></td></td></tr>
</table>
<table align="center"><tr><td colspan=2><h1>User Login</h2></td></tr></table>
<form name="loginform" method="post" action="userloginmid.jsp">
<table align="center" width="300px" style="border:1px solid #000000;" >
<tr><td colspan=2> </td></tr>
<tr>
<td><b>Login Name</b></td>
<td><input type="text" name="userName" value=""></td>
</tr>
<tr>
<td><b>Password</b></td>
<td><input type="password" name="password" value=""></td>
</tr>
<tr>
<td> </td>
<td><input type="submit" name="Submit" value="Submit"></td>
</tr>
<tr><td colspan=2> </td></tr>
</table>
</form>
</body>
</html>
Step:4
To create a "welcome.jsp" to display the message after
succesful login the user.
<%@ page import="java.sql.*,java.util.*" %>
<html>
<body>
<br><br>
<table align="center" width="300px" border=0>
<%
String username="";
if(session.getAttribute("username")!=null && session.getAttribute("username")!="")
{
username=session.getAttribute("username").toString();
%>
<tr>
<td align="right" width="690"><a href="home.jsp">Home</a></td>
<td align="right"><a href="logout.jsp">Logout</a></td>
</tr>
<%
}
else
{
%>
<tr>
<td align="right"><a href="home.jsp">Home</a></td>
<td align="right"><a href="login.jsp">Login</a></td>
</tr>
<%
}
%>
<tr><td colspan=2> </td></tr>
<tr><td colspan=2><h1>Welcome <%=username%></h1></td></tr>
<table>
</body>
</html>
Step:5
Create a webpage "userstatus.jsp" to
display the User Status .
<%@ page import="java.sql.*,java.util.*,java.text.*,java.text.SimpleDateFormat" %>
<html>
<head>
<TITLE>Login Application</TITLE>
</head>
<body>
<br><br>
<table align="center" width="400px" border=0>
<%
if(session.getAttribute("username")!=null && session.getAttribute("username")!="")
{ %>
<tr>
<td align="right" width="350"><a href="home.jsp">Home</a></td>
<td align="right"><a href="logout.jsp">Logout</a></td>
</tr>
<%
}
else {
%>
<tr>
<td align="right" width="350"><a href="home.jsp">Home</a></td>
<td align="right"><a href="login.jsp">Login</a></td>
</tr>
<%
}
%>
</table>
<table width="400px" align="center" border=0>
<tr style="background-color:#D9B0D8;">
<td align="center"><b>User Id</b></td>
<td align="center"><b>Username</b></td>
<td align="center"><b>Login</b></td>
<td align="center"><b>Logout</b></td>
</tr>
<%
System.out.println("MySQL Connect Example.");
Connection conn = null;
String url = "jdbc:mysql://localhost:3306/";
String dbName = "user_register";
String driver = "com.mysql.jdbc.Driver";
String username = "root";
String userPassword = "root";
String user = "";
try
{
Class.forName(driver).newInstance();
conn = DriverManager.getConnection(url+dbName,username,userPassword);
Statement st = conn.createStatement();
Statement st1 = conn.createStatement();
String queryString = "select * from admin order by userid";
ResultSet rs = st.executeQuery(queryString);
ResultSet rs1=null;
String queryStringuser="";
SimpleDateFormat sdfDestination=null;
int count=0;
String strcolor = "";
while(rs.next()){
count = count%2;
if(count==0){
strcolor = "#D9D9D9";
}
else{
strcolor = "#EFEFEF";
}
count++;
queryStringuser = "select * from userregister where id="+rs.getInt(2);
rs1 = st1.executeQuery(queryStringuser);
while(rs1.next()){
user = rs1.getString(2);
}
String inStr="";
String outStr="";
java.util.Date date;
String intime="";
String outtime="";
if((rs.getString(3)!=null && rs.getString(3)!=""))
{
inStr = rs.getString(3).toString().substring(0,rs.getString(3).toString().indexOf("."));
try
{
date = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse(inStr);
sdfDestination = new SimpleDateFormat("MMM dd, hh:mm:ss");
intime = sdfDestination.format(date);
}
catch (Exception e)
{
e.getMessage();
}
}
if((rs.getString(4)!=null && rs.getString(4)!=""))
{
outStr = rs.getString(4).toString().substring(0,rs.getString(3).toString().indexOf("."));
try
{
date = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse(outStr);
sdfDestination = new SimpleDateFormat("MMM dd, hh:mm:ss");
outtime = sdfDestination.format(date);
}
catch (Exception e)
{
e.getMessage();
}
}
%>
<tr style="background-color:<%=strcolor%>;">
<td align="center"><%=rs.getInt(2)%></td>
<td align="left" style="padding-left:10px;"><%=user%></td>
<td align="center"><%=intime%></td><td align="center"><%=outtime%></td>
</tr>
<%
}
conn.close();
}
catch (Exception e)
{
e.printStackTrace();
}
%>
Retrieve
Data from CSV file in JSP
CSV
file : A CSV file is commonly known as a Comma Delimited File
or a Character Separated File. It is a text file that has a specific
format which allows saving of text in organized manner. This format
known as a flat table, is very simple. Each row contains one record
of information. The character used to distinguish each piece of data
within each record is most commonly used a comma ",".
Create
a Page ("ReadCsvFile.jsp") to retrieve the data from CSV
file "myfile.csv".
<%@
page import="java.io.*"%>
<html>
<body>
<%
String fName = "c:\\csv\\myfile.csv";
String thisLine;
int
count=0;
FileInputStream fis
= new FileInputStream(fName);
DataInputStream myInput = new DataInputStream(fis);
int i=0;
%>
<table>
<%
while ((thisLine
= myInput.readLine()) != null)
{
String strar[] =
thisLine.split(",");
for(int
j=0;j<strar.length;j++)
{
if(i!=0)
{
out.print("
" +strar[j]+ " ");
}
else
{
out.print("
<b>" +strar[j]+ "</b> ");
}
}
out.println("<br>");
i++;
}
%>
</table>
</body>
</html>
Export
Data into CSV file uing JDBC in JSP
First
Import the packages
<%@
page import="java.io.*,java.sql.*"%>
Step
1. Create a Table "employee_details" in the database.
Step
2. Create a folder "csv" in the C:\ Drive.
Step
3. Create a Page ("CsvJdbcFile.jsp") to export data into
CSV file "myjdbcfile.csv".
<%@
page import="java.io.*,java.sql.*"%>
<html>
<body>
<%
String
filename = "c:\\csv\\myjdbcfile.csv";
Connection conn =
null;
String url = "jdbc:mysql://localhost:3306/";
String
dbName = "user_register";
String driver =
"com.mysql.jdbc.Driver";
String userName =
"root";
String password = "root";
Statement
stmt;
try
{
FileWriter fw = new
FileWriter(filename);
fw.append("Employee
Code");
fw.append(',');
fw.append("First
Name");
fw.append(',');
fw.append("Last
Name");
fw.append('\n');
Class.forName(driver).newInstance();
conn
= DriverManager.getConnection(url+dbName,userName,password);
String
query = "select * from employee_details";
stmt =
conn.createStatement();
ResultSet rs =
stmt.executeQuery(query);
while(rs.next())
{
fw.append(rs.getString(1));
fw.append(',');
fw.append(rs.getString(2));
fw.append(',');
fw.append(rs.getString(3));
fw.append('\n');
}
fw.flush();
fw.close();
conn.close();
out.println("<b>You
are Successfully Created Csv file.</b>");
} catch
(Exception e) {
e.printStackTrace();
}
%>
</table>
</body>
</html>
Download
CSV File from Database in JSP
Brief description
of the flow of application:
1.
Create a webpage "viewcsv.jsp"" to
display and download the CSV file from database. All CSV
file will show as hyperlink.
2.
Another "file_download.jsp" is used to
retrieve CSV file..
Step1:
To create a "file" table in Database
create
table `file` (
`id` double ,`file_data` blob ,`file_name` varchar
(50));
Step2:
Create a "viewcsv.jsp" to display all the CSV file.
<html>
<body>
<br><br>
<table
width="200px" style="border:1px solid
#ff0000;background-color:f7f7f7" align="center">
<tr
style="font-weight:bold;">
<td
align="center" align="center" colspan=2
style="border-bottom: 2px solid #000000;">Download Csv
File</td>
</tr>
<tr
style="font-weight:bold;">
<td align="center" style="border-bottom: 2px solid
#000000;">Id</td>
<td align="center" style="border-bottom: 2px solid
#000000;">File</td>
</tr>
<%@
page import="java.io.*,java.util.*,java.sql.*"
%>
<%
String
connectionURL = "jdbc:mysql://localhost/application";
String
url=request.getParameter("WEB_URL");
String
Content=new String("");
Statement
stmt=null;
Connection
con=null;
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
con=DriverManager.getConnection(connectionURL,"root","root");
stmt=con.createStatement();
String
qry = "select * from file";
ResultSet
rst= stmt.executeQuery(qry);
while(rst.next())
{
%>
<tr>
<td align="center"><%=rst.getInt(1)%></td>
<td align="center">
<a
href="file_download.jsp?id=<%=rst.getInt(1)%>"><%=rst.getString(3)%></a>
</td>
</tr>
<%
}
}
catch(Exception
e){
e.printStackTrace();
}
%>
</table>
</body>
</html>
Step:3 To create
a web page "file_download.jsp" .
<%@ |
