jsp

JSP Study Material 4th CSE, 4th IT Institute of Engineering & Management

Prepared by : Sourav Mukherjee Copy Right : 2004-2005

1

Servlets Introduction The rise of server-side Java applications is one of the latest and most exciting

trends in Java Programming. The java language was originally intended for use

in small, embedded devices. Java’s potential as a server side development

platform had been sadly overlooked until recently.

Business in particular has been quick to recognize Java’s potential on

the server-side. Java is inherently suited for large client/server

applications. The cross platform nature of java extremely useful for

organizations that have a heterogeneous collection of servers running

various flavors of the Unix and Windows operating systems. Java’s

modern, object-oriented, memory-protected design allows developers

to cut development cycles and increase reliability. In addition, Java’s

build – in support for networking and enterprise API’s provides access

to legacy data, easing the transition form older client/server systems.

Java servlets are a key component of server –side Java development. A servlets

is a small pluggable extension to a server that server’s functionality. Servlets

allow developers to extend and customize any java – enabled server a web

server, a mail server, an application server or any custom server.

Java Servlets

A servlets is a generic server extension – a java class that can be

loaded dynamically to expand the functionality of a server, Servlets

are commonly used with web servers, where they can take place of

CGI scripts. A servlets is similar to a proprietary server extension,

Please purchase PDFcamp Printer on http://www.verypdf.com/ to remove this watermark.

http://www.verypdf.com/



2

except that it runs in side a JVM on the server so it is safe and

portable. Servlets operate solely within the domain of the server:

unlike applets they do not require support for Java in the web browser.

Servlets are supported on all platform that support Java, and servlets work with

all major web servers. Java servlets, as defined by the Java Software division of

Sun Microsystems are the first standard extension to Java. This means that

servlets are officially blessed by Sun and are part of the Java language, but they

are not part of the core Java API.

To make it easy for you to develop servlets support. The javax.servlets and

javax.servlets.http package consistitute this servlets API.

In Addition to servlets class, you need a servlets engine, so that you can test and

deploy your servlets. The choice of the servlets engine depends partly on which

web server you are running. There are three kinds of servlets engines.

§ Standard Servlet Engine

§ Add-on Servlet engine.

§ Embeddable servlet engine

Standard Servlet Engine

A standalone engine is a server that includes build-in support for servlets Such

as engine has the advantage that everything works on Sun’s Java web Server,

Jigsaw Server, Netscapet Enterprise Server





3

Add-on Servlet Engine

An add-on Servlet engine functions as a plug – in to an existing server –it adds

Servlet support for a server that was not originally designed with servlets in

mind. Add – on servlet engines include Java-Apache projects’s Jserv module,

Jrun, WebSphere application

Embeddable Servlet Engine

An embeddable servlet engine is generally a lightweight servlet deployment

platform that can be embedded in another application.

Power of Servlet

Till now we have portrayed servlets as an alternative to other dynamic web

content technology, but we have not really explained why think you should use

them. What makes servlets viable choice for web development ? We believe that

servlets offer a number of advantage over other approaches in the aspects

explained below.

Portability, power, Efficiency and Endurance, Safety, Elegance, Integration,

Extensibility and flexibility, Capable of running in Process, Compiled, Crash

Resistance, Dynamically loadable across the network, Multithreaded.





4

Servlet Structure To start with it is important to notice that servlet are basic Java applications

similar to others you may have written. The only difference is that they extend

new classes and implement some unfamiliar methods. Fortunately, servlets are

as simple to write as any other Java program. You just have to learn the servlet

structure and a new class library.

Particularly all servlets that perform some useful function have two things in

common.

1. First, they all extend one of two servlet classes -> GeneracServlet or

HttpServlet. Extending these classes provides a framework for creating a

servlet as well as significant default functionality.

2. Second all servlets override at least one method wherein custom

functionality is implemented. The method that is automatically called by

the server in response to a client request is called is service(). The method

may be overridden to provide custom functionality. However, if the

servlet developer chooses not to override the service() method, other

methods will be invoked in response to a client request.

In addition to the classes and methods mentioned above, there are tow other

methods that are implemented by most servlets->init() and destroy(). The init()

method is called a single time when the servlet is first loaded. It is similar to c

class constructor in that it provided a method wherein initialization code is





5

guaranteed to be run. The destroy() method is executed when the servlet is

unloaded. It is used to free any resources held by the servlet.

Here is a skeleton structure of any Servlet Public class SkeleServ extends HttpServlet{ Public void init(){ //initialization code goes here } public void service(){ //meaningful work happens here } public void destroy(){ //free resources here } } The SkeleServ given does not look too difficult. Of course, the actual

implementation of different servlets may very widely. For example, servlet may

or may not implement the init() or destroy() methods. Implementation of these

methods is not mandatory. Likewise, a servlet developer may choose not to

override the service() method and opt to implement another method that is

automatically called by the inherited service() method. Similar to service(), this

method would implement the servlet’s unique functionality. The method

automatically called service() depends upon the type of HTTP request received (

e.g. doGet() is called for GET requests and doPost() for POST requests)

Life Cycle for Servlet

The review the process by which a server invokes a servlet. This process can be

broken in to nine steps as following.





6

i. The server loads the servlet when it is first request by the client or it

configured to do so, at server start-up. The servlet may be loaded from

either a local or remote location using the standard Java class loading

facility.

ii. The server creates one or more instances of the servlet class. Depending

on implementation. The server may create a single instances from which

one is chosen to service each new request.

iii. The server constructs a ServletConfig object that provides initialization

information to the servlet.

iv. The server calls the servlets init() method, passing the object constructed

in the step 3 as a parameter. The init() method is guaranteed to finish

execution prior to the servlet processing the first request. If the server has

created multiple servlet instances( step 2), the init() method is called one

time for each instance.

v. The server constructs a ServletRequest or HttpServletRequest object from

the data included in the client’s request. It also constructs a

ServletRespopnse or HttpServletResponse object that provides methods

for customizing the server’s response. The type of object passed in these

two parameters depends on whether the servlet extends the

GenericServelt class or the HttpServlet class, respectively.

vi. The server calls the servlet’s service() method ( or other, more specific

method like doGet() or doPost() for HTTP servlets), passing the objects

constructed in step 5 as parameter. When concurrent request arrive

multiple service() methods can run in separate threads.

vii. The service() method process the client request by evaluating the

ServletRequest or HttpServletRequest object and responds using

ServletResponse or HttpServletResponse object.

viii. If the server receives another request for this servlet, the process begins

again at step 5.





7

ix. When instructed to unload the servlet, perhaps by the server

administrator or programmatically by the servlet itself, the server calls the

servlet itself, the server calls the servlet’s destroy() method. The servlet is

then eligible for garbage collection.

Introduction to JSP JavaServer Pages (JSP) is a technology based on the Java language and enables

the development of dynamic web sites. JSP was developed by Sun Microsystems

to allow server side development. JSP files are HTML files with special Tags

containing Java source code that provide the dynamic content.

The following shows the Typical Web server, different clients connecting via the

Internet to a Web server. In this example, the Web server is running on Unix and

is the very popular Apache Web server.

First static web pages were displayed. Typically these were people’s first

experience with making web pages so consisted of My Home Page sites and

company marketing information. Afterwards Perl and C were languages used on

the web server to provide dynamic content. Soon most languages including

Visualbasic, Delphi, C++ and Java could be used to write applications that





8

provided dynamic content using data from text files or database requests. These

were known as CGI server side applications. ASP was developed by Microsoft to

allow HTML developers to easily provide dynamic content supported as

standard by Microsoft’s free Web Server, Internet Information Server (IIS). JSP is

the equivalent from Sun Microsystems, a comparison of ASP and JSP will be

presented in the following section.

The following diagram shows a web server that supports JSP files. Notice that

the web server also is connected to a database.

JSP source code runs on the web server in the JSP Servlet Engine. The JSP Servlet

engine dynamically generates the HTML and sends the HTML output to the client’s web

browser.

Why use JSP? JSP is easy to learn and allows developers to quickly produce web sites and

applications in an open and standard way. JSP is based on Java, an objectoriented

language. JSP offers a robust platform for web development.

Main reasons to use JSP:





9

1. Multi platform

2. Component reuse by using Javabeans and EJB.

3. Advantages of Java.

You can take one JSP file and move it to another platform, web server or JSP Servlet engine.

HTML and graphics displayed on the web browser are classed as the

presentation layer. The Java code (JSP) on the server is classed as the

implementation. By having a separation of presentation and implementation,

web designers work only on the presentation and Java developers concentrate on

implementing the application.

JSP compared to ASP

JSP and ASP are fairly similar in the functionality that they provide. JSP may

have slightly higher learning curve. Both allow embedded code in an HTML

page, session variables and database access and manipulation. Whereas ASP is

mostly found on Microsoft platforms i.e. NT, JSP can operate on any platform





10

that conforms to the J2EE specification. JSP allow component reuse by using

Javabeans and EJBs. ASP provides the use of COM / ActiveX controls.

JSP compared to Servlets A Servlet is a Java class that provides special server side service. It is hard work to write

HTML code in Servlets. In Servlets you need to have lots of println statements to

generate HTML.

JSP architecture

JSPs are built on top of SUN’s servlet technology. JSPs are essential an HTML

page with special JSP tags embedded. These JSP tags can contain Java code. The

JSP file extension is .jsp rather than .htm or .html. The JSP engine parses the .jsp

and creates a Java servlet source file. It then compiles the source file into a class

file, this is done the first time and this why the JSP is probably slower the first

time it is accessed. Any time after this the special compiled servlet is executed

and is therefore returns faster.





11

Steps required for a JSP request: 1. The user goes to a web site made using JSP. The user goes to a JSP page

(ending with .jsp). The web browser makes the request via the Internet.

2. The JSP request gets sent to the Web server.

3. The Web server recognises that the file required is special (.jsp), therefore

passes the JSP file to the JSP Servlet Engine.

4. If the JSP file has been called the first time, the JSP file is parsed,

otherwise go to step 7.

5. The next step is to generate a special Servlet from the JSP file. All the





12

HTML required is converted to println statements.

6. The Servlet source code is compiled into a class.

7. The Servlet is instantiated, calling the init and service methods.

8. HTML from the Servlet output is sent via the Internet.

9. HTML results are displayed on the user’s web browser.

Generate Implementation class and the JSP life cycle & methods The servlet class generated at the end of the tranlation process must extend a

super class that is either:

§ Specified by the JSP author through the use of the extends attribute in the

page directive as we shall see in a while, or

§ 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 are use HTTP their implementation

classes must actually implement the javax.servlet.jsp.JspPage.)

The javax.servlet.jsp.JspPage interface contains 2 methods: Method Usage Public void jspInit() This is invoked when the JSP is

initialized. This is similier to the init() method is servlets. Page authods are free to provide initialization of the JSP by implementing this method in their JSPs

Public void jspDestroy() This is invoked when the JSP is about to be destroyed by the container. This is similar to the destroy() method in servlets/constructor. Page authors are





13

free to provide cleanup of the JSP by implementing this method is their JSPs.

The javax.servlet.jsp.HttpJspPage interface contains 1 method. Method Usage Public void _jspService( HttpServletRequest Request, HttpServletResponse) throws ServletException, IOException

This method corresponds to the body of the JSP page and is used to threaded request processing, just like the service() method in servlets. This implementing for this method is generated by the JSP container and should never be provided by page authors.

How these 3 methods work together in a JSP can be seen in the figure below, which summarized the 3 mojor life events in a JSP.

§ The page is initialized by invoking the jspInit() method, which may be

user defined. This initializes the JSP much in the same way as servlets

are initialized.

Initialize Public void jspInit()

Handle client requests and generate response Void _jspService(ServletRequest, ServletReaponse) throws

IOException, ServletException

Destroy Public void jspDestroy()





14

§ Every time a request comes to the JSP, the container generated

_jspService() method is invoked, the request is processed and the JSP

generates the appropriate reaponse. This response is taken by the

container and passed back to the client.

§ When the JSP is destroyed by the server( for example at shutdown),

the jsp_destroy() method, which can be user defined, is invoked to

platform and clean up.

Creating your first JSP page <html> <head> <title>My first JSP page </title> </head> <body> <%@ page language=”java” %> <% System.out.println(“Hello World”); %> </body> </html> Type the code above into a text file. Name the file helloworld.jsp. Place this in the correct directory on your JSP web server and call it via your browser. Using JSP tags There are four main tags:

1. Declaration tag

2. Expression tag

3. Directive Tag

4. Scriptlet tag

5. Action tag





15

Declaration tag ( <%! %> )

This tag allows the developer to declare variables or methods.

Before the declaration you must have <%!

At the end of the declaration, the developer must have %>

Code placed in this tag must end in a semicolon ( ; ).

Declarations do not generate output so are used with JSP expressions or

scriptlets.

For Example,

<%!

private int counter = 0 ;

private String get Account ( int accountNo) ;

%>

The JSP you write turns into a class definition. All the scriptlets you write are

placed inside a single method of this class.

You can also add variable and method declarations to this class. You can then

use these variables and methods from your scriptlets and expressions.

To add a declaration, you must use the <%! and %> sequences to enclose your

declarations, as shown below.

<%@ page import="java.util.*" %>

<HTML>

<BODY>

<%!





16

Date theDate = new Date();

Date getDate()

{

System.out.println( "In getDate() method" );

return theDate;

}

%>

Hello! The time is now <%= getDate() %>

</BODY>

</HTML>

The example has been created a little contrived, to show variable and method

declarations.

Here we are declaring a Date variable theDate, and the method getDate. Both of

these are available now in our scriptlets and expressions.

But this example no longer works! The date will be the same, no matter how

often you reload the page. This is because these are declarations, and will only

be evaluated once when the page is loaded! (Just as if you were creating a class

and had variable initialization declared in it.)

Exercise: Modify the above example to add another function computeDate which

re-initializes theDate. Add a scriptlet that calls computeDate each time.

Note: Now that you know how to do this -- it is in general not a good idea to use

variables as shown here. The JSP usually will run as multiple threads of one

single instance. Different threads would interfere with variable access, because it

will be the same variable for all of them. If you do have to use variables in JSP,

you should use synchronized access, but that hurts the performance. In general,

any data you need should go either in the session objet or the request objectc





17

(these are introduced a little later) if passing data between different JSP pages.

Variables you declare inside scriptlets are fine, e.g. <% int i = 45; %> because

these are declared inside the local scope and are not shared.

Expression tag ( <%= %>) This tag allows the developer to embed any Java expression and is short for

out.println().

A semicolon ( ; ) does not appear at the end of the code inside the tag.

For example, to show the current date and time.

Date : <%= new java.util.Date() %>

Directive tag ( <%@ directive … %>)

We have been fully qualifying the java.util.Date in the examples in the previous

sections. Perhaps you wondered why we don't just import java.util.*;

It is possible to use "import" statements in JSPs, but the syntax is a little different

from normal Java. Try the following example:

<%@ page import="java.util.*" %>

<HTML>

<BODY>

<%

System.out.println( "Evaluating date now" );

Date date = new Date();

%>

Hello! The time is now <%= date %>

</BODY>

</HTML>





18

The first line in the above example is called a "directive". A JSP "directive" starts

with <%@ characters.

This one is a "page directive". The page directive can contain the list of all

imported packages. To import more than one item, separate the package names

by commas, e.g.

<%@ page import="java.util.*,java.text.*" %>

There are a number of JSP directives, besides the page directive. Besides the

page directives, the other most useful directives are include and taglib. We will

be covering taglib separately.

The include directive is used to physically include the contents of another file.

The included file can be HTML or JSP or anything else -- the result is as if the

original JSP file actually contained the included text. To see this directive in

action, create a new JSP

<HTML>

<BODY>

Going to include hello.jsp...<BR>

<%@ include file="hello.jsp" %>

</BODY>

</HTML>

View this JSP in your browser, and you will see your original hello.jsp get

included in the new JSP.

Exercise: Modify all your earlier exercises to import the java.util packages.

A JSP directive gives special information about the page to the JSP Engine.





19

There are three main types of directives:

1) page – processing information for this page.

2) Include – files to be included.

3) Tag library – tag library to be used in this page.

Directives do not produce any visible output when the page is requested but

change the way the JSP Engine processes the page.

For example, you can make session data unavailable to a page by setting a page

directive (session) to false.

1. Page directive This directive has 11 optional attributes that provide the JSP Engine with special

processing information. The following table lists the 11 different attributes with a

brief description:

<%@ page attributes %>

Attribute Description Default Value

Language Defines the scripting language to be used.

This attribute exists in case future JSP

containers support multiple language

Java

Extends The value is a fully qualified class name of

the superclass that the generated class, into

which this JSP page is translated, must

Ommited by

default





20

extend.

Import Comma separated list of packages or classes

with the same meaning as import statements

in Java Class

Ommited by

default

Session Specifies whether the page participates in an

HTTP session. When true the implicit object

named session, which refers to the

javax.servlet.http.HttpSession, is available

and can be used to access the current/new

session for the page

If false, the page does not participate in a

session and implicit session object is

unavailable.

Buffer Specifies the buffering model for the output

stream to the client

If the value is none, no buffering occurs and

all output is written directlythrough to the

ServletResponse by a PrinterWriter.

If a buffer size is specified, output is buffered

with a buffer size not less than that value.

Implementation

– dependent; at

least 8kb

Auto Flush If true, the output buffer to the client is

flushed automatically when it is full.

If false, a runtime exception is raised to

indicate a buffer overflow.

true

IsThreadSafe Defines the lavel of thread safely

implemented in the page.

True

Info Defines an informative string that can

subsequently be obtained from the page’s

Ommited by

default





21

implementation of the

Servlet.getServletInfo() method.

Error page Defines a URL to another JSP page within

current web application, which is invoked if

a checked or unchecked exception is thrown.

The page implementation catches the

instance of the Throwable object and passes

it to the error page processing. The error

page mechanism is very useful, and avoids

the need for developers to write code to

catch unrecoverable exception in the JSP

pages.

Ommited by

default

Is Error Apge Indicates if the current JSP page is intended

to be another JSP pages’ error page

False

Content Type Defines the character encoding for the JSP

and the MIME type for the response of the

JSP page.

MIME Type is

text/html

2. Include directive

Allows a JSP developer to include contents of a file inside another. Typically

include files are used for navigation, tables, headers and footers that are common

to multiple pages.

Two examples of using include files:

This includes the html from privacy.html found in the include directory into the

current jsp page.

<%@ include file = “include/privacy.html %>

or to include a naviagation menu (jsp file) found in the current directory.

<%@ include file = “navigation.jsp %>





22

Include files are discussed in more detail in the later sections of this tutorial.

3. Tag Lib directive

A tag lib is a collection of custom tags that can be used by the page.

<%@ taglib uri = “tag library URI” prefix = “tag Prefix” %>

Custom tags were introduced in JSP 1.1 and allow JSP developers to hide

complex

server side code from web designers.

This topic will be covered in the Advanced JSP tutorial at visualbuilder.com

Scriptlet tag ( <% … %> )

Between <% and %> tags, any valid Java code is called a Scriptlet. This code can

access any variable or bean declared.

For example, to print a variable.

<%

String username = “visualbuilder” ;

out.println ( username ) ;

%>

Scriptlets We have already seen how to embed Java expressions in JSP pages by putting

them between the <%= and %> character sequences.

But it is difficult to do much programming just by putting Java expressions

inside HTML.

JSP also allows you to write blocks of Java code inside the JSP. You do this by

placing your Java code between <% and %> characters (just like expressions, but

without the = sign at the start of the sequence.)





23

This block of code is known as a "scriptlet". By itself, a scriptlet doesn't

contribute any HTML (though it can, as we will see down below.) A scriptlet

contains Java code that is executed every time the JSP is invoked.

Here is a modified version of our JSP from previous section, adding in a scriptlet.

<HTML>

<BODY>

<%

// This is a scriptlet. Notice that the "date"

// variable we declare here is available in the

// embedded expression later on.


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

%>

Hello! The time is now <%= date %>

</BODY>

</HTML>

If you run the above example, you will notice the output from the

"System.out.println" on the server log. This is a convenient way to do simple

debugging (some servers also have techniques of debugging the JSP in the IDE.

See your server's documentation to see if it offers such a technique.)

By itself a scriptlet does not generate HTML. If a scriptlet wants to generate

HTML, it can use a variable called "out". This variable does not need to be

declared. It is already predefined for scriptlets, along with some other variables.

The following example shows how the scriptlet can generate HTML output.

<HTML>

<BODY>

<%

// This scriptlet declares and initializes "date"






24


%>

Hello! The time is now

<%

// This scriptlet generates HTML output

out.println( String.valueOf( date ));

%>

</BODY>

</HTML>

Here, instead of using an expression, we are generating the HTML directly by

printing to the "out" variable. The "out" variable is of type

javax.servlet.jsp.JspWriter.

Another very useful pre-defined variable is "request". It is of type

javax.servlet.http.HttpServletRequest

A "request" in server-side processing refers to the transaction between a browser

and the server. When someone clicks or enters a URL, the browser sends a

"request" to the server for that URL, and shows the data returned. As a part of

this "request", various data is available, including the file the browser wants from

the server, and if the request is coming from pressing a SUBMIT button, the

information the user has entered in the form fields.

The JSP "request" variable is used to obtain information from the request as sent

by the browser. For instance, you can find out the name of the client's host (if

available, otherwise the IP address will be returned.) Let us modify the code as

shown:

<HTML>

<BODY>

<%

// This scriptlet declares and initializes "date"






25


%>

Hello! The time is now

<%

out.println( date );

out.println( "<BR>Your machine's address is " );

out.println( request.getRemoteHost());

%>

</BODY>

</HTML>

A similar variable is "response". This can be used to affect the response being

sent to the browser. For instance, you can call response.sendRedirect(

anotherUrl ); to send a response to the browser that it should load a different

URL. This response will actualy go all the way to the browser. The browser will

then send a different request, to "anotherUrl". This is a little different from some

other JSP mechanisms we will come across, for including another page or

forwarding the browser to another page.

Mixing Scriptlets and HTML We have already seen how to use the "out" variable to generate HTML output

from within a scriptlet. For more complicated HTML, using the out variable all

the time loses some of the advantages of JSP programming. It is simpler to mix

scriptlets and HTML.

Suppose you have to generate a table in HTML. This is a common operation,

and you may want to generate a table from a SQL table, or from the lines of a

file. But to keep our example simple, we will generate a table containing the

numbers from 1 to N. Not very useful, but it will show you the technique.

Here is the JSP fragment to do it:





26

<TABLE BORDER=2>

<%

for ( int i = 0; i < n; i++ ) {

%>

<TR>

<TD>Number</TD>

<TD><%= i+1 %></TD>

</TR>

<%

}

%>

</TABLE>

You would have to supply an int variable "n" before it will work, and then it will

output a simple table with "n" rows.

The important things to notice are how the %> and <% characters appear in the

middle of the "for" loop, to let you drop back into HTML and then to come back

to the scriptlet.

The concepts are simple here -- as you can see, you can drop out of the scriptlets,

write normal HTML, and get back into the scriptlet. Any control expressions

such as a "while" or a "for" loop or an "if" expression will control the HTML also.

If the HTML is inside a loop, it will be emitted once for each iteration of the loop.

Another example of mixing scriptlets and HTML is shown below -- here it is

assumed that there is a boolean variable named "hello" available. If you set it to

true, you will see one output, if you set it to false, you will see another output.

<%





27

if ( hello ) {

%>

<P>Hello, world

<%

} else {

%>

<P>Goodbye, world

<%

}

%>

It is a little difficult to keep track of all open braces and scriptlet start and ends,

but with a little practice and some good formatting discipline, you will acquire

competence in doing it.

Action tag

There are three main roles of action tags :

1) enable the use of server side Javabeans

2) transfer control between pages

3) browser independent support for applets.

Javabeans A Javabean is a special type of class that has a number of methods. The JSP page

can call these methods so can leave most of the code in these Javabeans. For

example, if you wanted to make a feedback form that automatically sent out an

email. By having a JSP page with a form, when the visitor presses the submit

button this sends the details to a Javabean that sends out the email. This way

there would be no code in the JSP page dealing with sending emails (JavaMail

API) and your Javabean could be used in another page (promoting reuse).





28

To use a Javabean in a JSP page use the following syntax:

<jsp : usebean id = “ …. “ scope = “application” class = “com…” />

The following is a list of Javabean scopes:

page – valid until page completes.

request – bean instance lasts for the client request

session – bean lasts for the client session.

application – bean instance created and lasts until application ends.

Beans and Form processing

Forms are a very common method of interactions in web sites. JSP makes forms

processing specially easy.

The standard way of handling forms in JSP is to define a "bean". This is not a full

Java bean. You just need to define a class that has a field corresponding to each

field in the form. The class fields must have "setters" that match the names of the

form fields. For instance, let us modify our GetName.html to also collect email

address and age.

The new version of GetName.html is

<HTML>

<BODY>

<FORM METHOD=POST ACTION="SaveName.jsp">

What's your name? <INPUT TYPE=TEXT NAME=username SIZE=20><BR>

What's your e-mail address? <INPUT TYPE=TEXT NAME=email SIZE=20><BR>

What's your age? <INPUT TYPE=TEXT NAME=age SIZE=4>

<P><INPUT TYPE=SUBMIT>





29

</FORM>

</BODY>

</HTML>

To collect this data, we define a Java class with fields "username", "email" and "age"

and we provide setter methods "setUsername", "setEmail" and "setAge", as shown. A

"setter" method is just a method that starts with "set" followed by the name of the field.

The first character of the field name is upper-cased. So if the field is "email", its "setter"

method will be "setEmail". Getter methods are defined similarly, with "get" instead of

"set". Note that the setters (and getters) must be public.

public class UserData {

String username;

String email;

int age;

public void setUsername( String value ) { username = value; } public void setEmail( String value ) { email = value; } public void setAge( int value ) { age = value; } public String getUsername() { return username; } public String getEmail() { return email; } public int getAge() { return age; } }





30

The method names must be exactly as shown. Once you have defined the class,

compile it and make sure it is available in the web-server's classpath. The server

may also define special folders where you can place bean classes, e.g. with Blazix

you can place them in the "classes" folder. If you have to change the classpath,

the web-server would need to be stopped and restarted if it is already running.

(If you are not familiar with setting/changing classpath,.)

Now let us change "SaveName.jsp" to use a bean to collect the data.

<jsp:useBean id="user" class="UserData" scope="session"/>

<jsp:setProperty name="user" property="*"/>

<HTML>

<BODY>

<A HREF="NextPage.jsp">Continue</A>

</BODY>

</HTML>

All we need to do now is to add the jsp:useBean tag and the jsp:setProperty tag!

The useBean tag will look for an instance of the "UserData" in the session. If the

instance is already there, it will update the old instance. Otherwise, it will create

a new instance of UserData (the instance of the UserData is called a bean), and

put it in the session.

The setProperty tag will automatically collect the input data, match names

against the bean method names, and place the data in the bean!

Let us modify NextPage.jsp to retrieve the data from bean..


<HTML>

<BODY>

You entered<BR>

Name: <%= user.getUsername() %><BR>

Email: <%= user.getEmail() %><BR>

Age: <%= user.getAge() %><BR>





31

</BODY>

</HTML>

Notice that the same useBean tag is repeated. The bean is available as the

variable named "user" of class "UserData". The data entered by the user is all

collected in the bean.

We do not actually need the "SaveName.jsp", the target of GetName.html could

have been NextPage.jsp, and the data would still be available the same way as

long as we added a jsp:setProperty tag. But in the next tutorial, we will actually

use SaveName.jsp as an error handler that automatically forwards the request to

NextPage.jsp, or asks the user to correct the erroneous data.

Creating your second JSP page For the second example, we will make use of the different tags we have learnt.

This example will declare two variables; one string used to stored the name of a

website and an integer called counter that displays the number of times the page

has been accessed. There is also a private method declared to increment the

counter. The website name and counter value are displayed.

<HTML>

<HEAD>

<TITLE> JSP Example 2</TITLE>

</HEAD>

<BODY> JSP Example 2

<BR>

<%!

String sitename = “iemcal.com”;

int counter = 0;

private void increment Counter()





32

{

counter ++;

}

%>

Website of the day is

<%= sitename %>

<BR>

page accessed

<%= counter %>

</BODY>

</HTML> Tag libraries JSP 1.1 introduces a method of extending JSP tags, called "tag libraries". These libraries

allow addition of tags similar to jsp:include or jsp:forward, but with different prefixes

other than jsp: and with additional features.

To introduce you to tag libraries, in this tutorial we use the Blazix tag library as an

example. This tag library comes bundled with the Blazix server, which you can

download free for learning and evaluation. (The material you learn about using tag

libraries will work with any other tag libraries also.)

Each tag-library will have its own tag-library specific documentation. In order to use the

tag library, you use the "taglib" directive to specify where your tag library's "description"

resides. For the Blazix tag library, the (recommended) directive is as follows

<%@ taglib prefix="blx" uri="/blx.tld" %>

The "uri" specifies where to find the tag library description. The "prefix" is unique for

the tag library. This directive is saying that we will be using the tags in this library by

starting them with blx:





33

The Blazix tag library provides a blx:getProperty tag. This tag can be used to allow the

user to edit form data. In our GetName.jsp file, we will now add a jsp:useBean and place

the form inside blx:getProperty.

The new GetName.jsp is



<HTML>

<BODY>

<blx:getProperty name="user" property="*">


What's your name? <INPUT TYPE=TEXT NAME=username SIZE=20><BR>

What's your e-mail address? <INPUT TYPE=TEXT NAME=email SIZE=20><BR>

What's your age? <INPUT TYPE=TEXT NAME=age SIZE=4>


</FORM>

</blx:getProperty>

</BODY>

</HTML>

Note that the blx:getProperty doesn't end with /> but is instead terminated by a separate

</blx:getProperty> line. This puts all the form input fields inside the blx:getProperty so

they can be appropriately modified by the tag library.

Try putting a link to GetName.jsp from the NextPage.jsp, and you will see that the bean's

data shows up automatically in the input fields.

The user can now edit the data.

We still have a couple of problems. The user cannot clear out the name field. Moreover,

if the user enters a bad item in the "age" field, something which is not a valid integer, a

Java exception occurs.





34

We will use another tag from the Blazix tag library to take care of this. Blazix offers a

blx:setProperty tag that can be used to take care of these problems. blx:setProperty

allows us to define an exception handler method. If an exception occurs, we can collect

an error message for the user and continue processing.

Following is a version of SaveName.jsp that processes any errors, and either shows the

user GetName.jsp again to user can enter the data correctly, or automatically forwards to

NextPage.jsp.


<%!

boolean haveError;

StringBuffer errors;

public void errorHandler( String field,

String value,

Exception ex )

{

haveError = true;

if ( errors == null )

errors = new StringBuffer();

else

errors.append( "<P>" );

errors.append( "<P>Value for field \"" +

field + "\" is invalid." );

if ( ex instanceof java.lang.NumberFormatException )

errors.append( " The value must be a number." );

}

%>

<%





35

// Variables must be initialized outside declaration!

haveError = false;

errors = null;

%>

<HTML>

<BODY>


<blx:setProperty name="user"

property="*"

onError="errorHandler"/>

<%

if ( haveError ) {

out.println( errors.toString());

pageContext.include( "GetName.jsp" );

} else

pageContext.forward( "NextPage.jsp" );

%>

</BODY>

</HTML>

Note that haveError and errors must be re-initialized each time, therefore they are being

initialized outside of the declaration.

[Also notice the use of pageContext.include and pageContext.forward. These are

like jsp:include and jsp:forward, but are more convenient to use from within Java

blocks. pageContext is another pre-defined variable that makes it easy to do certain

operations from within Java blocks.]

Here, if an error occurs during the processing of blx:setProperty, we display the error

and then include the GetName.jsp again so user can correct the error. If no errors occur,

we automatically forward the user to NextPage.jsp.





36

There is still a problem with the forms, the "age" shows up as zero initially rather than

being empty. This can be fixed by adding "emptyInt=0" to both the blx:getProperty

and blx:setProperty tags (bean fields should be initialized to 0.) It happens that "0" is

not a valid value for age, so we can use "0" to mark empty strings. If "0" were a valid

value for age, we could have added "emptyInt=-1" (and made sure to initialize the bean

fields to -1.)

Another small problem is that the "<HTML>" tag gets doubled if there is an error and we

end up including "GetName.jsp". A more elegant solution is to remove the out.println,

and pass back the error as shown

<%

if ( haveError ) {

request.setAttribute( "errors",

errors.toString());

pageContext.forward( "GetName.jsp" );

} else

pageContext.forward( "NextPage.jsp" );

%>

We can then do a "request.getAttribute" in the GetName.jsp, and if the returned value

is non-null, display the error.

Techniques for form editing

A tag library such as the one that comes with the Blazix server, may not be available in

your environment. How can you allow similar features without using a tag library?

It is a little tedious, but it can be done. Basically, you must edit each HTML tag yourself,

and put in a default value. The following examples shows how we modify GetName.jsp

to provide features similar to blx:getProperty but with manual HTML tag editing:





37


<HTML>

<BODY>


What's your name? <INPUT TYPE=TEXT NAME=username

SIZE=20 VALUE="<%= user.getUsername() %>"><BR>

What's your e-mail address? <INPUT TYPE=TEXT

NAME=email SIZE=20

VALUE="<%= user.getEmail() %>"><BR>

What's your age? <INPUT TYPE=TEXT NAME=age

SIZE=4 VALUE=<%= user.getAge() %>>


</FORM>

</BODY>

</HTML>

As you can see, this simply involves adding a "VALUE" field in the INPUT tags, and

initializing the field with an expression!

To handle exceptions during input processing, a simple approach is to use "String" fields

in the bean, and do the conversion to the target datatype yourself. This will allow you to

handle exceptions.

COOKIS

Why we use Cookies

Cookies are necessary because the HTTP protocol that is used to transfer

webpages around the web is state-less. This means that web servers cannot

remember information about users throughout their travels, and so everyone





38

becomes anonymous. If you ever return to a site you have visited previously,

you are treated as if it was your first visit.

This is especially unsatisfactory for sites which ask their users to log in — if you

leave and return just a few minutes later, you'll have to log in again. The server

doesn't remember anything about your visit or your preferred settings. So,

cookies were invented to give memory, of a sort, to web servers.

Structure of a Cookie

Cookies are no more than simple text files — usually found in your browser

cache, or ‘Temporary Internet files’ — which contain one or more entries. Each

entry is made up of

1. A name-value pair which stores whatever data you want to save.

2. An expiry date, after which time the entry will be deleted.

3. The web domain and path that the entry should be associated with.

You can use JavaScript to read or write a new entry to the cookie file. The process

of creating an entry is often referred to as ‘writing a cookie’, but this is

misleading. The cookie is the text file which contains all of your entries, while the

individual entries themselves hold the data. Each domain name on the web can

have a cookie file associated with it, and each cookie can hold multiple entries.

When you request a file from a server that you have used previously, the data in

the relevant cookie is sent to the server along with your request. This way,

server-side scripts, such as those written in Perl or » PHP, can read your cookie

and figure out whether you have permission to view a certain page, for instance.

Cookies can also be used for somewhat more malicious purposes, usually by

advertising companies to track your behaviour online. Most modern browsers





39

include good measures that allow you to block cookies from certain sites, so

which sites you disclose information to is now at your discretion.

The name-value pair part of the entry is very similar to declaring a variable —

when you want to retrieve information you ask for the value that is associated

with a name that you provide. The expiry date is expressed in an unfriendly UTC

format; though fortunately there are methods for generating a suitable date. If a

date is not set, the entry is deleted when you close your browser.

The domain and path that you associate your cookie with have to be part of

the same domain that your site belongs to. For instance, I can set my cookie to be

active for www.yourhtmlsource.com, the default; or to yourhtmlsource.com,

which will cover any and all subdomains I set up for the site. I cannot, however,

set it to yahoo.com, for obvious security reasons. Using the path you can restrict

a cookie to be valid for only a certain directory. Usually you'll want it to be

available to any page in the domain, so this is set to /, the root directory.

Setting, Reading and Erasing Cookies

The document has an object in JavaScript called document.cookie, which is used

to read and retrieve cookie data. It is a repository of Strings (though not an

array). You can create new entries, read out an existing name-value pair, or

erase an entry through JavaScript. To create a cookie for my site, I write

document.cookie =

"testvalue1=Yes; expires=Fri, 13 Jul 2004 05:28:21 UTC; path=/";

The whole entry is supplied as one quoted String with segments set apart with

semicolons — first the name-value pair, then the expiry date in the correct

format, and finally the path. This syntax is fixed, and you shouldn't go

rearranging the elements. Write this entry now. To test out the cookie's contents,

we can use a simple script like



http://www.yourhtmlsource.com



40

alert(document.cookie);

Which will yield this result. You may see another value in there too, which is

used by our Stylesheet-switcher. Now we can write another entry to the cookie,

using a different name, as so:

document.cookie =

"testvalue2=Nah; expires=Fri, 13 Jul 2004 05:28:21 UTC; path=/";

Checking on the cookie's contents now, we can see that our first value is still in

there. Had we used the same name, the first value would've been overwritten;

but since we used a different name, the new entry has been added in with the

first.

Erasing cookie entries is easy — just set a new value and give an expiry date

before today, as in

document.cookie =

"testvalue2=Whatever; expires=Fri, 13 Jul 2001 05:28:21 UTC; path=/";

You can also give the entry an expiry date of -1, and it will be erased

immediately. Erase test values 1 and 2 now, if you have the heart.

Convenient Scripts

To easily tinker with cookies ourselves, we'll be using some great scripts which I

found through » PPK, and which were originally coded by » Scott Andrew.

They'll take much of the pain out of the process; especially reading the values out

of a cookie, which is a bit complicated. Here are the functions:

function createCookie(name, value, days)

{

if (days) {





41

var date = new Date();

date.setTime(date.getTime()+(days*24*60*60*1000));

var expires = "; expires="+date.toGMTString();

}

else var expires = "";

document.cookie = name+"="+value+expires+"; path=/";

}

function readCookie(name)

{

var ca = document.cookie.split(';');

var nameEQ = name + "=";

for(var i=0; i < ca.length; i++) {

var c = ca[i];

while (c.charAt(0)==' ') c = c.substring(1, c.length); //delete spaces

if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);

}

return null;

}

function eraseCookie(name)

{

createCookie(name, "", -1);

}

These are some nicely coded scripts, and don't require too much explanation.

The function we use to create cookies takes three arguments, which make up the

name-value pair and the amount of days to retain the cookie. The last argument





42

is converted into a valid date by adding its value in hours to the current time

before being annexed into the line which creates the cookie.

The cookie reading function is the most difficult one here. First it splits the

available cookie String (what we've been reading out in the alert earlier on this

page) at every occurrence of the separating semicolon. This creates a new array,

with each index holding an entry pair. We loop through these looking for the

String 'name='. When we find this, we read out whatever else makes up this

index, which will be the value associated with the name we passed to the

function at the beginning.

Erasing an entry is easy — simply recreate a cookie with its expiration date set to

-1.

JSP Easy Cookies Script Here's a simple script to set a cookie in JSP.

<%@ page import="java.util.Date"%> <%@ page import="java.net.*"%> <% Date now = new Date(); String timestamp = now.toString(); Cookie cookie = new Cookie ("Username", "David"); cookie.setMaxAge(365 * 24 * 60 * 60); response.addCookie(cookie); %> <HTML> <HEAD> </HEAD> <BODY>





43

<%=cookie.getValue()%> </BODY> </HTML>

Now here's how you check whether it exists or not.

<%@ page import="java.net.*"%> <% 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> </HEAD> <BODY> <%if (myCookie == null) {%> Hello first timer! <%} else {%> Hi again <%=redCookie.getValue()%>, welcome back! <%}%> </BODY> </HTML>





44

JDBC

One of the major problems with databases has been the feature war between the

database companies. There is a standard database language. Structure Query

Language(SQL-92), but usually you must know which database vendor you’ar

programming. However, it’s still possible to make vendor-specific calls form

JDBC so you aren’t restricted form doing what you must.

JDBC, like many of the APIs in Java, is designed for simplicity. The method calls

you make correspond to the logical operations you’d think of doing when

gathering data form a database: connect to the database, create a statement and

execute the query and look at the result set.

To allow this platform independence, JDBC provides a driver manager that

dynamically maintains all the driver objects that your databases to connect to,

you’ll need three different driver objects. The driver objects register themselves

with the driver manager at the time of loading, and can force the loading using

the method Class.forName().

Java

Database Client

JDBC Driver Database Server

Vendor Specific Protocol





45

Another way for the java program to communicate with different database

engines is through the jdbc-odbc bridge. Microsoft established a common

standard for communicating with databases, called Open Database

Connectively(ODBC). Until ODBC, most database client were server specific.

ODBC drivers abstract away vendor – specific protocols, providing a common

application programming interface to database clients. By writing your database

clients to the ODBC API, you enable your programs to access more databse

servers. So your program interaction with different databases through jdbc-

odbc bridge might look something like this

Example :

Part I

To create a html page include a form name form1 action test.jsp and two textbox

one is username and other is password.

Java Database Client

Jdbc-Odbc Bridge

Database Server Vendor A )

Database Server Vendor B )

Database Server Vendor C )





46

Part II

Create a system dsn name test through administrative privilege. DSN will create

through system->administrative tools.

Part III

Coding of test.jsp

<%

String regno=request.getParameter(“text1”);

String pass1=request.getParameter(“text2”);

%>

<html>

<head>

<title>

Test

</title>

</head>

<body bgcolor=lightskyblue>

<h1>

</h1>

<%@ page import = “java.sql.*” %>

<%

try{

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

String dbUrl=”jdbc:odbc:test”;

Connection connl=DriverManager.getConnection(dbUrl);

Statement stml=connl.createStatement();

Resultset rs=stml.executeQuery(“select reg_no,pass from stud where reg_no=’

“+regno.toString()+” ‘ “);





47

%>

<%

int cou=0;

while (rs.next())

{

cou++;

if (rs.getString(“pass”).compareTo(pass1)!=0){%>

<p aline=center><string</strong><a href=

”http://iem_program/login.htm>Error-Pass</a></p>

<%{

else

{

%>

<p aline=center><string</strong><a href=

”http://iem_program/next.htm>Continue</a></p>

<%

} catch (Exception ex)

ex.getMessage();

}%>

</body>

</html>



http://iem_program/login.htm

http://iem_program/next.htm

jsp

Documents

purchase pdfcamp

sourav mukherjee

jsp servlet

web browser

web development

web server

httpservletrequest

java code