Java Server Pages

1

Java Server Pages

• A Java Server Page is a file consisting of HTML or XML markup into which special tags and code blocks are inserted

• When the page is first requested, a JSP is parsed into a java source file which is then compiled into a servlet class and run under the container JVM

• Initially, there is a performance hit• However, there is a “build” mechanism to avoid

unneeded parsing and compilation based on the date of the JSP page relative to the class file

2

Java Server Page Tags

• Directives

• Hidden Comments

• Declarations

• Expressions

• Scriptlets

• There are also a number of XML-type tags that begin with “<jsp:’ called “actions”

3

Directives

• Directives are compiler instructions that are processed when the page is compiled

• The format is <%@ and end with %>

• Examples:<%@ page %>

<%@ include %>

4

Directives

• <%@ page %>

• At the top of each JSP is a page declaration<%@ page

language=“java” language (see below)

import=“. . .” list of packages to import

errorPage=“. . .” substitute error page

contentType=“. . .” usually “text/html”

%>

• At present only Java can be used in a JSP

5

Directives

• <%@ include %>• This directive inserts the “static” contents

of a file into the JSP at compile time• The text becomes part of the JSP page• It is useful for including code that is

common to a number of pages, but for which you do not want to use a bean

• Example:<%@ include file="relativeURL" %>

6

Hidden Comments

• These are used to document the page and are not sent to the client

• The format is <%-- comment --%>• Example:

<%-- This is a comment about the code --%>

• Any characters may be used in the body of a comment except the closing "--%>" marker which should be escaped as "--%\>".

7

Declarations

• These are used to declare variables or methods that have scope throughout the page

• The format is <%! declaration or method %>• Examples:

<%! String myString = "hello";

private String getData() {

// Java code for the method goes here

}

%>

8

Declarations

• Every JSP contains implicit references to API objects that do not need to be declared:– request– response– pageContext– session– application– out– config– page– exception

9

Expressions

• The result of an expression is converted to a String and inserted into the output stream at the place where it occurs

• The format is <%= expression %> • Examples:

<%= myString %><%= getData() %>

• Note that the expression is not terminated with a semicolon

• The parser simply wraps an out.print() or similar method around the expression as its argument

10

Scriptlets

• Scriptlets contain fragments of Java code• The format is <% Java code here %>• Scriptlet code can access implicit references and

declared variables or methods• Use a scriptlet to wrap a conditional or a loop

around a block of HTML• Examples:

<% if(request.getParameter("user").equals("new")) { %><B>Please sign up!</B><% } else { %><B>Welcome back!</B><% } %>

11

Scriptlets

• The output HTML stream will vary depending on the value of the request parameter named “user”

• Note the use of the implicit request object which does not need to be declared with “<%! %>”

• Example of scriptlets with an expression:• <% for(int i=1; i<11; i++) { %>

The current number is: <%= i %><BR><% } %>

12

Action

• <jsp:include>• This tag is used to include either static or

dynamic content in the output stream• If the file is dynamic, you can use

<jsp:param> to pass parameters to it• Examples:

<jsp:include page="/login.jsp"> <jsp:param name="username" value="Fred"/></jsp:include>

13

Action

• <jsp:forward>• This tag takes the implicit request object (which

contains the client request parameters and other CGI-type data) and forwards it to a target file - an HTML page, a servlet, or another JSP file

• Example:<jsp:forward page="relativeURL|<%= expression %>"><jsp:param name=". . ." value=". . ."/></jsp:forward>

• The <jsp:param> tag is used to pass additional parameters to the target

14

Action: Java Beans

• JavaBeans are the component model for Java - the equivalent of all those fancy components you can obtain and use in the .NET world

• In a component model / market, developers go to the marketplace, pay for the component library they need, and wire it all together in a JSP using their IDE

• This has worked for other languages (e.g. Visual Basic), but has never developed for the Java market

15

Action: Java Beans

• A Java Bean is a class with the following– A default constructor (with no argument list)– A Set and Get method for each attribute (called

a property in Java Bean terms)

• A JSP can use an action to instantiate and access an instance of the Java Bean class

• A JSP can use actions to access the other methods of an instance of the Java Bean

• A JavaBean can be monitored by listeners for changes to its parameters from the JSP

Java Bean

public class MyJavaBean

{

private String propertyName;

public MyJavaBean() { … } // Default Constructor

public void setPropertyName(String theValue)

{ this.propertyName = theValue; }

public String getPropertyName()

{ return this.propertyName; }

}16

17

Action: Java Beans

• <jsp:useBean> and <jsp:setProperty>• Example of how to set up a bean instance

<jsp:useBean id="beanInstanceName"scope="page|request|session|application"class=“MyJavaBean"><jsp:setProperty name="beanInstanceName"property="propertyName" value="theValue" /></jsp:useBean>

18

Action: Java Beans

• <jsp:getProperty>• This tag retrieves the value of a bean property and

converts it to a String to display it in the page• The format is:

<jsp:getProperty name="beanInstanceName“ property="propertyName"/>

• The name attribute points to the bean with the same id attribute used in the <jsp:useBean> tag

• The property attribute is the name of the bean property you wish to display (there must be a corresponding Get method in the bean)

19

Java Beans in Scriptlets / Expressions

• Once a Java Bean has been instantiated, its instance name and its methods can be used in scriptlets: <% beanInstanceName.setPropertyName

(“New_value”) %>

• or expressions:<%= beanInstanceName.toString() %>

20

Java Server Pages

• You can view the Java source code generated by the parser, but it's not a good idea to modify it

• The generated Java code is found in:Tomcat 6.0\work\Catalina\localhost\myapp\org\apache\jsp

• The class file for any Java Beans used must be in this directory for it to be found while compiling the generated JSP source code

• A copy of the class file for any Java Beans must also be located in the WEB-INF/classes directory for Tomcat to find it at run time

(Proper classpath setting would probably fix this)

Model-View-Controller

• Multiple views of enterprise application and information is required – one for each type of user

• Leads to MVC Architecture – separation of functions

• Java Server Pages, Servlets, and Java Beans can be used to implement the MVC architecture for access to common application and/or information

Model-View-Controller

• The MVC Solution

Enterprise Information System

HTMLView

ClassicWeb Client Administrator

SwingView

XML WebService

SupplierB2B Agent

Model-View-Controller

View (HTML/JSP)-Renders the Model-Requests updates from model(s)-Sends user gestures to controller-Allows controller to select view

Controller (Servlets)-Defines application behavior-Maps user actions to model updates-Selects views for response-One for each functionality

Model (Java Beans)-Encapsulates application state-Responds to state queries-Exposes application functionality-Notifies view(s) of changes

ChangeNotification

State Query

StateChange

View Selection

User gestures