Вы находитесь на странице: 1из 94

JSP Java Server Pages

JSP technology has facilitated the segregation of the work of a Web designer and a Web developer. A Web designer can design and formulate the layout for the Web page by using HTML. On the other hand, a Web developer working independently can use java code and other JSP specific tags to code the business logic. The simultaneous construction of the static and dynamic content facilitates development of quality applications with increased productivity.

A JSP page , after compilation , generates a servlet and therefore incorporates all servlet functionalities.

Servlets and JSP thus share common features, such as platform independence , creation of database-driven Web applications , and server side programming capabilities.

However , there are also some basic differences between servlets and JSP :

Servlets tie up files (an HTML file for the static content and a Java file for the dynamic contents) to independently handle the static presentation logic and the dynamic business logic. Due to this , a change made to any file requires recompilation of the servlet. JSP on the other hand allows Java to be embedded directly into an HTML page by using tags. The HTML content and the Java content can also be placed in separate files. Any changes made to HTML content is automatically compiled and loaded onto the servlet

Servlet programming involves extensive coding.

Therefore, any change made to the code requires identification of the static code content (for the designer) and dynamic code content (for the developer) to facilitate incorporation of the changes.

On the other hand, a JSP page, by virtue of the separate placement of the static and dynamic content , facilitates both Web developers and the Web designer to work independently.

JSP Life Cycle

When the client browser requests for a particular JSP page ,the server in turns sends a request to the JSP engine.

A JSP engine is a part of a Web container , that compiles a JSP page to a servlet.

The following figure represents the process of the flow of events that occur after a client requests for a JSP page.

Request-Response Cycle for a JSP Page Response Servlet reloaded No Request Browser Response Web Container ( JSP Engine) Check to ensure if the call to JSP is first of its kind Yes Servlet generation and recompilation


The request-response cycle essentially comprises of two phases , namely the translation phase and the request-processing phase. The translation phase is implemented by the JSP engine and involves generation of a servlet. Internally , this results in the creation of a class file for the JSP page ,that implements the servlet interface. During the request-processing phase, the response is generated according to the request specifications. After the servlet is loaded for the first time, it remains active , processes all the subsequent requests , and saves time that would otherwise be lost in reloading a servlet at each time.

Once a JSP is translated to a servlet , the container invokes the following life cycle methods on the servlet , that are defined in the javax.servlet.jsp.JspPage interface: 1. jspInit() : This method is invoked at the time when the servlet is initialized. 2. jspService() : This method is invoked when request for the JSP page is received. 3. jspDestroy() : This method is invoked before the servlet is removed from the service.


Accept two numbers form the user form the AcceptInput.jsp page .

Create Calculate.jsp to process the request and displays the results

Assignment DatePage.jsp <html> <body> <%= new java.util.Date () %> </body> </html>

IncludePage.jsp <html> <body> <h4> Todays Date is : <jsp:include page=DatePage.jsp flush=true /> </h4> <% out.println(<h4> The ouput of the file DatePage.jsp is shown above </h3>); %> </body> </html>

Classes of JSP API

JSP API is a set of classes and interfaces that you can use to create a JSP pages. These classes and interfaces are contained in the javax.servlet.jsp package . Some of the classes defined in the javax.servlet.jsp package are : 1. ErrorData 2. JspWriter 3. PageContext

The ErrorData Class

The ErrorData class defines error information for error pages.

You need to set the value of the page directive , isErrorPage to be true to indicate that a page is an error page.

The ErrorData class extends the java.lang.Object class .

Some of the methods defined in the ErrorData class that you can use in a jsp page are :

1. getRequestURL () : -> Returns the requested URL in the form of a String. 2. getServletName () : -> Returns the name of the servlet invoked in the form of a String. 3. getStatusCode () : -> Returns the status code of the error in the form of an interger. 4. getThrowable () : -> Returns the Throwable exception that caused the error.

The JspWriter Class

The JspWriter class is used to write action and template data in a JSP page. The object of JspWriter class is referenced by the implicit variable , out .

The JspWriter class extends the java.io.Writer class.

Some of the methos defined in the JspWriter class that you can use in a JSP page are :

1. clear() : -> Clears the contents of the buffer. The clear() method throws an IOException exception , if the buffer is already cleared.

2. close() : -> Closes and flushes the stream

3. flush() : ->Flushes the buffer stream. The flush() method flushes all the buffers in a chain of Writers and OutputStream.It throws java.io.IOException exception if you make a call to the write () or flush() after closing the stream

4. getBufferSize () : -> Returns the size of the buffer used by the JspWriter 5. print() : -> Prints a value of type boolean , interger ,character ,long integer , floating point , double precision floating point number, an array of character , string , and object. The print() throws the java.io.IOException exception if any error occurs while printing. 6. println() : -> Prints a value of type boolean , interger ,character ,long integer , floating point , double precision floating point number, an array of character , string , and object.This method writes a line separator string to terminate the current line. The Println () throws the java.io.IOException exception if any error occurs while printing

The PageContext Class

The PageContext class provides context information when the JSP technology is used in the servlet environment. The PageContext class extends the JspContext class. A PageContext instances provides access to namespaces associated with a JSP page. Some of the methods defined in the PageContext class are :

1. forward () : -> Redirects the current servlet request and servlet response to another page. This method accepts the URL of a target page as an argument. 2. getPage () : ->Returns the current value of the page object. 3. getRequest () : -> Returns the current value of the request object. The return type of the getRequest () is the servlet request. 4. getResponse(): -> Returns the current value of the response object. The return type of the getResponse () method is the servlet response.

5. getServletConfig (): -> Returns the ServletConfig of the current page. 6. getServletContext () : -> Returns the ServletContext of the current page. 7. getSession () : ->Returns the HttpSession for the current PageContext. The return type of getSession () is HttpSession. 8. include () : ->Processes the current servlet request and the response specified in the URL. The include () method asscepts two arguments, a URL path and the flush value of boolean type

<html> <head> <title>My first JSP Page</title> </head> <body> <%@page language=java%> <% System.out.println(Be in Peace); %> </body> <html>

Using JSP tags

There are five main tags:

1. 2. 3. 4. 5.

Declaration tag Expression tag Directive tag Scriptlet tag Action tag

Declaration tag (<%!


This tag allows the developer to declare variables or methods.

Before the declaration you must have <%! And at the end of the declaration the developer must have %>

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

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

Example Of Declaration tag

<%! private int counter = 0 ; private String getAccount (int accountNo); %>

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.

Example Of Expression tag

Current Date and Time is : <%= new java.util.Date() %>

Directive tag (<%@ directive. %>)

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

There are three main types of directives: 1. 2. 3. page Include - processing information for this page - files to be included

Tag library - tag library to be used in this page

Directive tag (Continue..)

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 provides the JSP Engine with special processing information.

The following table lists the 11 different attributes with a brief description.

Language : Which language the file uses. <%@ page language=java %> Import : Import all the classes in a java package into the current JSP page.This alllows the JSP page to use other java classes. The following packages are implicitly imported. java.lang.* javax.servlet.* javax.servlet.jsp.* javax.servlet.http.* <%@ page import=java.util.* %>

session : Does the page make use of sessions. By default all JSP pages have session data available. Default is set to true.

buffer :

Controls the use of the buffered output for the JSP page. Default is 8 kb <%@page buffer =none %>

autoFlush : Flush output buffer when full <%@ page autoFlush=true %>

isThreadSafe : Can the generated Servlet deal with multiple requests? If true a new thread is started so requests are handled simultaneously. info : Developer uses info attribute to add information/document for a page. Typically used to add author , version, copyright and date info <%@ page info=abc.com test page,copyright 2001. %>

errorPage : Different page to deal with errors. Must be URL to error page <%@ page errorPage=/error/error.jsp %>

isErrorPage : This flag is set to true to make a JSP page a special Error Page. This page has access to the implicit object exception

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 include the html from privacy.html found in the include directory into the current jsp page. <%@ include file = include/privacy.html %> OR To include a navigation menu (jsp file ) found in the current directory. <%@ include file = navigation.jsp %>

3.Tag Lib directive

A tag lib is a collection of the custom tags that can be used by the page. <%@ taglib uri=tag lib 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.

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 message = Be in Peace ; out.println(message); %>

Action tag
There are three main roles of the action tags:

Enable the use of the server side Javabeans. Transfer control between pages browser independent support for applets


A Javabeans is a special type of the 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 visitors presses the submit button this sends the details to a JavaBeans that sends out the emails. This way there would be no code in the JSP page dealing with sending emails.

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

<jsp:usebean id= id scope=application class=. />

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.

Dynamic JSP Include You have seen how a file can be included into a JSP using an include Directive: <%@ include file = include/privacy.html%>

This is a useful for including common pages that are shared and is included at compile time.

To include a page at run time you should use dynamic JSP includes. <jsp:include page=URL flush=true/>

<HTML> <HEAD> <TITLE> JSP Example </TITLE> </HEAD> <BODY> JSP Example <BR> <%! String message = Be in Peace; int counter = 0 ; %> Todays Message is <%=message%> <Br> Counter is <%=counter%> </BODY> </HTML>

Implicit Objects

There are several objects that are automatically available in JSP called implicit objects.

request response out session pagecontent application config page exception

Of type
javax.servlet.http.httpServletRequest javax.servlet.http.httpServletResponse javax.servlet.jsp.JspWriter javax.servlet.http.HttpSession javax.servlet.jsp.PageContext javax.servlet.http.ServletContext javax.servlet.http.ServletConfig javax.lang.Object java.lang.Throwable

page object Represents the JSP page and is used to call any methods defined by the servlet class.

config object Stores the Servlet configuration data.

request object Access to information associated with a request. This object is normally used in looking up parameter values and cookies. <% String str = request.getParameter(uname); %>

Session Tracking in JSP (Session Object)

Cookies a small text file stored on the clients machine. Cookie can be disables in the browser settings so are not always available. URL rewriting store session information in the URL. Works when cookies are not supported but can make bookmarking of web pages a problem because they have session specific information at the end of a URL.

Hidden form fields - HTML hidden edit boxes such as <input type = hidden name=user value= --->

Session objects JSP Implicit Object

A session object uses a key / value combination to store information. To retrieve information from a session: session.getValue(msg) The return type of the method getValue is Object , so you will need to typecast to get the reuired value. If there is not a session key with that name , null is returned.

To set a session key with a value, session.putValue (msg , val)

JSP comments<%-- JSP comment--%>

JSP comments are similar to HTML comments <! HTML comment -- > except JSP comments are never sent to the users browser. HTML comments are visible in the page source.

<html> <head> <title> HTML and JSP Comments </title> </head> <body> <h2> Comments </h2> <! This HTML Comment-visible in the page source --> <%-- This JSP comment-Not visible in the page source -- %> </body> </html>

Error pages

Eventually there will come a time when sometime unexpected happens. In Java terms, this is when an exception gets thrown. JSP can handle these situations so when an exception is thrown , a default error page is sent to the browser. So what makes an error page different from other JSP pages?

One of the first lines in an error page must be the page directive isErrorPage=true Inside your default error page (errorPage.jsp), above the<HTML> tag type:

<%@ page isErrorPage=true import=java.util.* %> <HTML> <BODY> Error Occurred <%= exception.toString() %> </Body> <HTML>

Our error page also uses the exception object and the toString() method to display a brief description of the error. To use a specific error page in your JSP pages, again above the <HTML> tag type: <%@ page errorPage=errorPage.jsp%> <HTML> .. </HTML>

This code will go to errorPage.jsp if an error occurs. Even after an error, the HTTP session remains available.

<%@ page errorPage=errorHandler.jsp%> <html> <body> <% if(request.getParameter(name)==null) { throw new RuntimeException(Name not Specified); } %> Hello, <%= request.getParameter(name) %> </body> </html>

<%@ page isErrorPage=true %> <html> <body> Unable to process your request: <%= exception.getMessage()%> <br> Please try again. <body> </html>

In JSP 1.2 , it is not necessary that the errorPage value be a JSP page. It can also be a static file , such as an HTML page: <%@ page errorPage = errorHandler.html %>

The Need for JSP With servlets, it is easy to Read form data Read HTTP request headers Set HTTP status codes and response headers Use cookies and session tracking Share data among servlets Remember data between requests Get fun, high-paying jobs But, it sure is a pain to Use those println statements to generate HTML Maintain that HTML


The JSP Framework

Use regular HTML for most of page Mark servlet code with special tags Entire JSP page gets translated into a servlet (once), and servlet is what actually gets invoked (for each request) Example: <HTML> <HEAD> <TITLE>Order Confirmation</TITLE> </HEAD> <BODY> <H2>Order Confirmation</H2> Thanks for ordering <I> <%= request.getParameter("title") %> </I> ! </BODY> </HTML>

Benefits of JSP
Write HTML. Read and maintain the HTML. Use standard HTML tools such as Macromedia DreamWeaver or Adobe GoLive. Have different members of your team do the HTML layout than do the Java programming. Separate the (Java) code that creates the content from the (HTML) code that presents it.

Advantages of JSP Over Competing Technologies Versus ASP or ColdFusion Better language for dynamic part Portable to multiple servers and operating systems Versus PHP Better language for dynamic part Better tool support Versus pure servlets More convenient to create HTML Can use standard tools (e.g., DreamWeaver) Divide and conquer JSP programmers still need to know servlet programming

Versus Velocity or WebMacro Standard Versus client-side JavaScript (in browser) Capabilities mostly do not overlap with JSP, but You control server, not client Richer language Versus server-side JavaScript (e.g., LiveWire, BroadVision) Richer language Versus static HTML Dynamic features Adding dynamic features no longer "all or nothing" decision

Setting Up Your Environment

Set your CLASSPATH : Compile your code : Not. Not.

Use packages to avoid name conflicts : Not. Put JSP page in special directory: Not.

Use special URLs to invoke JSP page: Not. Use same URLs as for HTML pages (except for file extensions)

<HTML> <HEAD> <TITLE>JSP Expressions</TITLE> </HEAD> <BODY> H2>JSP Expressions</H2> <UL> <LI>Current time: <%= new java.util.Date() %> <LI>Server: <%= application.getServerInfo() %> <LI>Session ID: <%= session.getId() %> <LI>The <CODE>testParam</CODE> form parameter: <%= request.getParameter("testParam") %> </UL> </BODY> </HTML>

<HTML> <BODY> <% // This is a scriptlet. Notice that the "date" // variable we declare here is available in the // embedded expression later on. System.out.println( "Evaluating date now ); java.util.Date date = new java.util.Date(); %> Hello! The time is now : <%= date %> </BODY> </HTML>

<HTML> <BODY> <% // This scriptlet declares and initializes "date" System.out.println( "Evaluating date now" ); java.util.Date date = new java.util.Date(); %> Hello! The time is now <% // This scriptlet generates HTML output out.println( String.valueOf( date )); %> </BODY> </HTML>

<HTML> <BODY> <% // This scriptlet declares and initializes "date" System.out.println( "Evaluating date now" ); java.util.Date date = new java.util.Date(); %> Hello! The time is now <% out.println( date ); out.println( "<BR>Your machine's address is " ); out.println( request.getRemoteHost() ); %> </BODY> </HTML>

<TABLE BORDER=2> <% for ( int i = 0; i < n; i++ ) { %> <TR> <TD> Number </TD> <TD> <%= i+1 %> </TD> </TR> <% } %> </TABLE>

<% if ( hello ) { %> <P> Hello, world <% } else { %> <P>Goodbye, world <% } %>

JSP Directives
<%@ page import="java.util.*" %> <HTML> <BODY> <% System.out.println( "Evaluating date now" ); Date date = new Date(); %> Hello! The time is now <%= date %> </BODY> </HTML> The first line in the above example is called a "directive". A JSP "directive" starts with <%@ characters. <%@ page import= "java.util.*, java.text.*" %>

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. <HTML> <BODY> Going to include hello.jsp...<BR>

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


JSP Declarations
<%@ page import="java.util.*" %> <HTML> <BODY> <%! Date theDate = new Date(); Date getDate() { System.out.println( "In getDate() method); return theDate; } %> Hello! The time is now <%= getDate() %> </BODY> </HTML>

Package foo; public class counter { private static int count; public static synchronized int getCount() { count++; return count; } }

<html> <body> The page count is : <% out.println(Counter.getCount()); %> </body> <html>

OutPut ?

JSP code should be : <% out.println(foo.Counter.getCount()); %> OR

<% page import=foo.* %>

Scriptlet code: <@ page import=foo.*%> <html> <body> The page count is : <% out.println(Counter.getCount()); %> </body> </html> Expression code: <@ page import=foo.*%> <html> <body> The page count is : <%= Counter.getCount() %> </body> </html>







Expression :



When the container sees this :

<%= Counter.getCount() %>

It turns it into this :


If you did put a semicolon in your expression:

<%= Counter.getCount(); %>

That would be bad.It would mean this:


Valid or Not ?
1. 2. 3. 4. 5. 6. 7. 8. 9. 10.

<%= 27 %> <%= ((Math.random()+5)*2); %> <%= 27 %> <%= Math.random() %> <%= String s = foo %> <%= new String[3] %> <% = 42*20; %> <%= 5>3 %> <%= false %> <%= new Counter() %>

Answer ?

1. 2. 3. 4. 5. 6.


8. 9. 10.

All primitive literals are fine. No! The semicolon cant be here. String literal is fine. Yes, the method returns a double. No! you cant have a variable declaration here. Yes , because the new String array is an object , and ANY object can be sent to a println() statement. No! The arithmetic is fine , but theres a space between the % and the =. It cant be <% = , it must be <%= Sure , this resolves to a boolean, so it prints true. Primitive literals are fine No problem. This is just like the String [] . It prints the result of the objects toString() method.

Will it compile? Will it Work?

<html> <body> <% int count = 0; %> The page count is : <%= ++count %> </body> </html> If it compiles see the O/P

What Really happens to your JSP code?

This JSP: <html> <body> <% int count = 0; %> The Page count is now : <%= ++count %> </body> </html>

Becomes this servlet: public class basicCounter_jsp extends SomeSpecialHttpServlet { public void _jspservice(HttpServletRequest req,HttpServletResponse resp) throws java.io.IOException , ServletException { PrintWriter out = response.getWriter(); response.setContentType(text/html); out.write(<html><body>); int count = 0; out.write(The page count is now:); out.print(++count); out.write(</body></html>); } }



John Barrett the Chief Technology Officer has entrusted the development team with the task of creating an application that validates id and password of every customer before they can access their account datails. The customer id has to be in a numeric form. He also wants that an error message should be displayed to the customer, if the entered customer id or password is incorrect. Before the changes can be made to the entire application , John wants to test this functionality be making a sample application for a specific customer . Larry Williams , the programmer has been assigned the task of implementing this functionality. Larry decides to use JSP for developing this application