Www.torontocollege.com JavaServer Pages Fundamentals.

www.torontocollege.com

JavaServer Pages Fundamentals


ConceptsAfter completing this module you will understand the: Advantages of JSP technology JSP architecture Life cycle of a JSP page JSP syntax and semantics Role of JavaBeanTM components within JSP pages


Objectives

By the end of this module you will be able to:

Manage session-related information from JSP Communicate between JSP pages

Process forms with JSP


Prerequisites

A general familiarity with object-oriented programming concepts and the Java programming language.

A general familiarity with HTML tag


Introduction

JSP pages typically comprise of: Static HTML/XML components. Special JSP tags Optionally, snippets of code written in the Java

programming language called "scriptlets."


JSP Advantages

Write Once Run Anywhere: Dynamic content can be served in a variety of formats: Recommended Web access layer for n-tier architecture Completely leverages the Servlet API: Separation of static from dynamic content


Comparing JSP with ASP JavaServer Pages Active Server PagesWeb Server Most popular web servers Microsoft IIS SupportPlatform Platform independent Windows SupportComponent Relies on reusable, Model cross-platform COM components,Javabean,EJB VBScript and JScript Scripting Java or JavaScript Security Java security model. NT security architecture. Database JDBC ODBCAccessCustomizable JSP is extensible Cannot use custom tagTags with custom tag libraries. Libraries. is not extensible.


JSPs and Servlets

JSP is nothing but a high-level abstraction of servlets. You can do almost anything that can be done with servlets using JSP--but more

easily!


Exercise 1

Installing and Configuring Tomcat Download Tomcat in Apache SiteUnzip and Install itCreate your own project publish directory under webapps.Here we call project directory, and create subdirectory

underProject directory. See the following figure


../webapps Project/

Web-inf/ Classes/

Class file

Application name/

For example: email/

… …

JSPs file and other data

Meta-info/

Tag library

Configure the Tomcat In the server.xml file, add the following

lines 

<Context path="/project"

docBase="webapps/project" crossContext="true" debug="0" reloadable="true" trusted="false" > </Context>


Set up environmentAdd the following lines In your autoexec.bat or System Properties/Environment Variables window.

set JAVA_HOME=c:\jdk1.3 set ANT_HOME=c:\program files\apache group\

jakarta-tomcat set Tomcat_Home=c:\program files\apache group\

jakarta-tomcat set CLASSPATH=c:\jdk1.3\lib;c:\jdk1.3\lib\tools.jar;c:\

program files\apache group\jakarta-tomcat\lib\servlet.jar


Start Tomcat & try email example

Tomcat/bin>Tomcat run or startup Copy email’s jsp files and data files into email

folder and email’s class files into web-info folder. Launch a web browser and type: http://127.0.01/project/email/email.jsp


General Architecture

User enters value into form and clicks submit button

Response displayed in browser window

Interprets JSP and uses data from form to generate Response

RequestObject

Response Object


General Architecture(more detail)

Web Application Server

Client

Web Server

Plain Documents

Servlet Engine

Compiled ServletJSP Engine

JSP Documents


The Basics of JSP

Everything in a JSP page can be broken into 2 categories

Elements that can be processed on the server

Template data


Element basics

Directives Declarations Scriptlets Expressions Standard actions


Directives

<%@ directivename attribute=“value”attribute=“value” %>

The page directive The include directive The taglib directive


The page Directive

Attribute language extends import session …….


The page Directive

Attribute Description Default language Defines the scripting language to be used. For future use if JSP engine “Java” supports multiple language

extends The superclass that the generated class(into which this JSP page is compiled) must extend. This attribute should be used with extreme caution because the engines usually Attribute omitted provide specialized superclass by default with a lot of functionality that the generated classes extend


The page DirectiveAttribute Description DefaultImport import package and classes Attribute omitted

by defaultSession Specifies if the page participates in an HTTP “true” session Buffer Specifies the buffering model for output stream The default is buffered

with to the client. If the value an implementation buffer is none, then no buffering size of not less that 8kb occurs and al output is written directly through to the ServletResponse by a PrintWriter.


The page DirectiveAttribute Description DefaultautoFlush If “ture”, the output buffer to the is flushed automatically when it is full. If “false”, a runtime exception is raised to indicate buffer overflow. The default is “ture”isThreadSafe Defines the level of thread safety implemented in the page. If “false” then th e JSP processes quenes up client requests sent to the page for processing. It processes them one at a time, in the order they were received. This is the same as implementing the javax.servlet.SingleThreadModel interface in a servlet. Default is “true”


The page DirectiveAttribute Description Default

Info Define an informative stirng that can subsequently be obtained from the page’s implementation of Servlet.getServletInfo() method. It is omitted by defaultIsErrorPage Indicates if the current JSP page is intended to be the the URL target of another JSP pages’s errorPage. If “true”, then the implicit variable exception is available, and refers to the instance of the java.lang.Throwable thrown at runtime by the JSP causing the error. The default is “false”


The page DirectiveAttribute Description DefaulterrorPage Defines a URL to another JSP that is invoked

if an unchecked runtime exception is thrown. The page implementation catches the instance of the Throwable object and

passes it to the error page processing. See the isErrorPage attribute abovecontentType Defines the character encoding for the JSP

and the MIME type for response of the JSP page.The default is ”text/html”


Example of The Page Directive

File name: pagedirective.jsp<%@ page language="java" import="java.rmi.*,java.util.*" session="true" buffer="12kb" autoFlush="true" info="my page directive jsp" errorPage="Error.jsp" isErrorPage="false" isThreadSafe="false"%>


<html>

<body>

This is a JSP to test the page directive tag

<body>

</html>


Include Directive

The include directive lets you separate youcontent into more manageable elements, suchas those for including a common page header or footer. The page included can be a staticHTML page or more JSP content. For example,the directive:

<%@ include file="copyright.html" %> can be used to include the contents of the indicated

file at any location within the JSP page.


The taglib Directive

This directive allows the page to use custom user defined tags

<%@ taglib uri=“http://www.myserver.com/mytags” prefix=“pooh”

<pooh:processElement>…………..


Scripting Elements

DeclarationScriptletsExpressions


Declarations

<%! Java variable and method declaration(s) %> Example <html> <body> <h1> Hello World </h1> </html> <%! private int i=4; // my counter public void myMethod(){ // do some work here } %>


Scriptlets

<% Java code statements %>Example <html><body><h1> This is a scriptlet example </h1><%for(int i = 0; i < 10; i++){ out.println(" <b> Hello World This is a loop test "+i

+"</b><br>"); System.out.println("This goes to the system.out stream "+i);}%></html>


Expression

<%=Java expression to be evaluated %> Example <html> <body> <h1 This is a counter example> <%! int i=0; %> <% i++; %> Hello world ! <%=“This JSP has been accessed”+i+”times”

%> </body> </html>


Standard Action

<jsp:useBean><jsp:setProperty><jsp:getProperty><jsp:param><jsp:include><jsp:forward><jsp:plugin>


Using JavaBean Components

The component model for JSP technology is based on JavaBeans component architecture. JavaBeans components are nothing but Java objects which follow a well-defined design/naming pattern: the bean encapsulates its properties by declaring them private and provides public accessor (getter/setter) methods for

reading and modifying their values.


jsp:useBean

•<jsp:useBean id=“name” beandetails scope=“page|request|session|application />For example:

<jsp:useBean id="user" class="com. Person" scope="session" />

Important: What is scope? We will cover it shortly.


Beandetails: class=“className”

class=“className” type=“typename” beanName=“beanName”

type=“typeName”


Scope in tag

Scope in tag Description

page The object exists for every client request to the resource

Request The object reference is available as long as the HttpRequest object is not discarded,even if the request is passes/chained to different pages. The object is distinct for every client request

Session The object is distinct for every client, and is available as long as the client’s session is valid

Application This is not unique for clients, and consequently all clients access the same object.


Scope in tag


What does the container do

under the semantics? The container tries to locate an object that has

this id, in the specified scope If the object is found , and a type has been

specified in the tag, the container tries to cast the found object to the specified type. A java.lang.ClassCastException is thrown if the cast fails.

If the object is not found in the specified scope, and no class or beanName is specified in the tag, a java.lang.InstantiationException is throw


If the object is not found in the specified scope. The class specified is instantiated. A new object reference is associated with the variable

If the object is not found in the specified scope, and a beanName is specified, then the instantiate() method of the java.bean.Beans is invoked. If the method succeeds, the new object reference is associated with the variable, in the specified scope.

What does the container do under the semantics?


Jsp:setProperty

<jsp:setProperty name=“beanName” propertydetails

Propertydetails property = “*” property=“propertyName” property=“propertyName”

param=“parametName” property=“propertyName”

value=“propertyValue”


Jsp:getProperty<jsp:getProperty name=“name” property=“propertyName”Name: The name of the bean instance from which the property is obtained. The bean must already have been found or created using <jsp:useBean>Property: The name of the property to retrieve The jsp:getProperty action is complementary to the jsp:setProperty action and is used to access the properties of a bean. It accesses the value of a property, converts is to a String, and prints it to the output stream.


Example of Using JavaBean Components

Example : SpellCheck

SpellCheck.html

Wordpro.jsp

SpellCheck.class


SpellCheck.java

/*** This bean encapsulates the functionality to spell check a String*/public class SpellCheck {

private String word;public SpellCheck() {}/** Method to reverse the string uses

@return the reversed String */


public String reverse() {return (new StringBuffer(word).reverse()).toString();}

/**Checks the spelling of the word.This method has no body, and

just returns true for the example @return boolean, true if the spelling is right */public boolean check() {

return true;}

/** * Access method for the word property.


* @return the current value of the word property */public String getWord() {

return word;}

/** * Sets the value of the word property. * * @param aWord the new value of the word property */public void setWord(String aWord) {

word = aWord;}

}


Wordpoint.jsp

<jsp:useBean id="help" scope="request" class="SpellCheck“/><%System.out.println("Explicitly doing some work on the bean...");help.setWord(request.getParameter("word")); %>


<html><body>You entered the input(getParameter), <b> <%=

request.getParameter("word") %></b><br>You entered the input(jsp:getProperty),<b> <jsp:getProperty

name="help" property="word"/></b><br>The processed output is:<br><%= Integer.parseInt(request.getParameter("mode"))==1 ?

help.reverse() :""+help.check() %></body></html>


spellCheck.html

<html><head><title>Untitled Document</title><meta http-equiv="Content-Type" content="text/html; charset=iso-8859-

1"></head>

<body bgcolor="#FFFFFF">


<form action="wordpro.jsp" method="POST">Enter word:<input type="text" name="word"><select name="mode"> <option value="1" selected>Reverse</option> <option value="2">Spellcheck</option></select><input type="submit" name="Go" value="Submit"></form>

</body></html>


Exercise of Using JavaBean Components

In this exercise, you develop a simple JSP page (form.jsp), which can process an HTML form containing typical input elements like textboxes, radio buttons, and checkboxes. You also develop a bean (FormBean.java), whose property names mirror the input elements of the form. You will then examine the automatic instantiation of the bean on a form POST operation, using the introspective features provided by the JSP engine.


Exercise of Using JavaBean Components

TASKS You are given the JSP page containing the form.

Observe that the form posts to itself recursively. Instantiate the bean FormBean when you recognize that a POST operation has taken place. Allow the setter methods to be called on the bean using introspection.

Deploy the JSP page within Tomcat. Develop the bean, FormBean.java, with properties

matching the form elements. Compile the bean source FormBean.java. Deploy the bean within Tomcat. Run the example.


Jsp:include

<jsp:include page=“filename” flush=“true”/>Example<html><body><h2>This example shows how the includes work:

</h2><br>Including a jsp and html with the include

directive...<br><br><%@ include file="two.html" %><br><%@ include file="two.jsp" %> <br>


<hr><br>Including a jsp and html with the include

action..<br><br>

<jsp:include page="two.html" flush="true"/> <br>

<jsp:include page="two.jsp" flush="true"/>

</body></html>


What is the difference between directive include and jsp:incude

The jsp:include is being computed at request time

The directive include parses the content of the included files into the current JSP while compiling it.

The jsp:include can handle the static and dynamic content.

The directive include handles the static content


Pass value to another JSP file<html><body><h2> This example shows how the include work:</h2><br> <jsp:include page=“two.jsp” flush=“true” <jsp:param name=“attribute1” value=“value1” <jsp:param name=“attribute2” value=“value2”

</jsp:include></body></html>In this code , two.jsp can access the values of attribute using request.getParameter(“attribute1”)


JSP:include


Include Example here is a JSP page that inserts four different

snippets into a "What's New?" Web page. Each time the headlines change, authors only need to update the four files, but can leave the main JSP page unchanged.


This action lets you forward the request to another page. It has a single attribute, page, which should consist of a relative URL. This could be a static value, or could be computed at request time, as in the two examples below. <jsp:forward page="/utils/errorReporter.jsp" />

<jsp:forward page="<%= someJavaExpression %>" />

Jsp:forward


The invoking page can also pass the target resource bean parameters by placing them

into the request, as shown in the diagram:


A <jsp:forward> tag may also have jsp:param subelements that can provide values for some elements in the request used in the forwarding:

<jsp:forward page="<%= somePage %>" > <jsp:param name="name1" value="value1" /> <jsp:param name="name2" value="value2" /> </jsp:forward>

Www.torontocollege.com JavaServer Pages Fundamentals.

Documents

Transcript of Www.torontocollege.com JavaServer Pages Fundamentals.