Java Server Page

This page is http:// jan.newmarch.name /i18n/jsp/jsp.html
http://jan.newmarch.name:443/i18n/jsp/jsp.html
Count is blahbluh
Count is blah/usr/local/bin/access_count bluh

Introduction

Servlets handle HTTP requests by a Java program. They produce an HTTP response by writing HTTP/HTML to an output object
If the processing done by a servlet is small and the amount of writing is large, then servlets become messy to write, hard to read and difficult to maintain
JSP pages (like ASP and many other systems) consist mainly of HTML instructions with some embedded HTTP instructions and a mechanism to embed executable code (for JSP, this is Java code)
These are good for the presentation-side of a Web application

MVC model

Smalltalk invented the Model-View-Controller pattern to handle user interfaces
- The model is the object which contains the state variables and methods of the "system" e.g. for an airconditioner, it would hold current temperature, temperature that has been set and methods to turn on or off, reset temperature etc
- The view is e.g a GUI object that displays the state of the system and has buttons, sliders, etc to change values
- The controller handles actions invoked by the view and calls methods on the model. It also takes changes in the model and tells the view to change its appearance
The MVC has been used even when it is not quite the right description
IBM came up with something they called MVC for Web applications, even though it isn't quite right:
- The model is the backend logic module
- The view is the Java Server Page that creates HTML for the browser to display
- The controller is the servlet that handles input from the browser and calls the business logic and JSP as appropriate

Basic JSP page

JSP pages are mainly HTML text
Tags <% ... %> contains Java code
A tag <%= value %> inserts the value of a Java expression into the HTML document


<%@ page contentType="text/html; charset=ISO-8859-5" %>

<html>
  <head>
    <title> Hello </title>
  </head>

  <body>
    <p>
      <%
          String hello = "Hello world";
       %>
      This JSP page is saying <br>
      <%= hello %>
    </p>
  </body>
</html>

Deploying JSP pages

Deployment of servlets and JSP pages seems to me to be far more complex than it needs to be
Under the Tomcat home there is a directory webapps
Create your own subdirectories
- jan
- jan/jsp
- jan/WEB-INF
- jan/WEB-INF/classes
Compiled servlet files go into jan/WEB-INF/classes
JSP pages go into jan/jsp

A servlet such as HelloWWW is referenced by


      http://jan.newmarch.name:8080/jan/servlet/helloWWW

A JSP page such as hello.jsp is referenced by


      http://jan.newmarch.name:8080/jan/jsp/hello.jsp

That was the simple version - it can get much messier
When you modify a JSP page or a servlet class, you may need to restart Tomcat to register the changes

Request parameter

It is customary in a servlet to call the HttpServletRequest request parameter request. In JSP, that is its name:


<%@ page import="java.util.*,java.text.NumberFormat" %>
<%@ page contentType="text/html; charset=ISO-8859-1" %>
<html>
  <head>
    <title>Localized Numbers</title>
  </head>
  <body>
    <%
      Locale preferredLocale = request.getLocale();
      NumberFormat nf = NumberFormat.getInstance(preferredLocale);
      String numberStr = nf.format(123456.789);
     %>

    The number 123456.789 in the user's preferred locale is
    <%= numberStr %>
  </body>
</html>

Application objects

You can define your own objects and call them

Java code:


package jan;

import java.text.NumberFormat;
import java.util.Locale;
import javax.servlet.http.*;

public class MyNumber {

    private double value = 123456.789;
    private NumberFormat nf;

    public MyNumber(HttpServletRequest request) {
	Locale preferredLocale = request.getLocale();
	nf = NumberFormat.getInstance(preferredLocale);
    }

    public String toString() {
	return(nf.format(value));
    }
}

The Java class should be copied to the servlet location e.g. TOMCAT_HOME/webapps/jan/WEB-INF/classes

A JSP calling this is


<%@ page import="jan.MyNumber" %>
<%@ page contentType="text/html; charset=ISO-8859-5" %>

<html>
  <head>
    <title> Hello </title>
  </head>

  <body>
    <p>
	My number in the current locale is <br>
      <%=
          new MyNumber(request).toString()
       %>
    </p>
  </body>
</html>

Tomcat v1.5.5 seems to require the Java classes to be in a package - Tomcat 1.4 didn't

Forwarding control

A servlet can forward control to a JSP page by e.g.


    RequestDispatcher dispatcher = request.
        getRequestDispatcher("/template.jsp");
    if (dispatcher != null)
        dispatcher.forward(request, response);

One JSP page can forward control to another by


      <jsp:forward page="/main.jsp" />

Including another JSP page

The syntax <%@ include file="relativeURL" %> includes a file at that point, which could be another JSP page

Declarations

If you want to declare a Java variable that can be used throughout the JSP page, this can be done using the syntax <%! ... %> such as
```
      <%! int i = 0; %>
      
```

Methods can also be defined e.g.


      <%! public String f(int i) {
                  if (i < 3) return("...");
                  ...
          }
      %>

Mixing HTML and Java

Java code appears within <% ... >
HTML code appears as normal text

Java constructs can be spread around HTML e.g.


<% if (Calendar.getInstance().get(Calendar.AM_PM) == Calendar.AM) { %>
     <p> Good Morning  </p>
<% } else { %>
     <p> Good Afternoon  </p>
<% } %>

This can get messy very quickly

Custom tags

JSP pages contain a mixture of Java and HTML, and can become messy
One way of cotrolling this is define custom classes and hide most of the logic in methods
This doesn't help if the methods have to contain lots of HTML! It looks like a servlet again
An alternative is to define new XML tags which actually hide Java code inside themselves.
Using a custom tag makes things look like lots of HTML/XML intead of Java/HTML
There are many libraries of custom tags, and you can define your own

Java Standard Tag Library

The JSTL is a set of custom tags - the spec etc is at JavaServer Pages Standard Tag Library
They include many common activities
There are libraries such as
- Core
- i18n
- XML
- SQL
Each tag library is defined at a URL, and this must be used to define an XML namespace (similar to a Java package) e.g.
```
      <%@ taglib prefix="c" url="http://java.sun.com/jsp/jstl/core" %>
      
```
defines the Core namespace "c".
(There seems to be nothing at this URL, and all the documents/tutorials point to different URLs, none of which exist!)

The standard libraries and customary tags are (from file:///usr/local/src/jakarta-taglibs-standard-1.1.2/doc/GettingStarted.html)

Funtional Area	URI	Prefix	Example
Core	http://java.sun.com/jsp/jstl/core	c	<c:tagname ...>
XML processing	http://java.sun.com/jsp/jstl/xml	x	<x:tagname ...>
I18N capable formatting	http://java.sun.com/jsp/jstl/fmt	fmt	<fmt:tagname ...>
Database access (SQL)	http://java.sun.com/jsp/jstl/sql	sql	<sql:tagname ...>
Functions	http://java.sun.com/jsp/jstl/functions	fn	fn:functionName(...)

Area	Function	Tags	TLD	Prefix
Core	Expression Language Support	`catch` `out` `remove` `set`	`/jstl-c`	`c`
Flow Control	`choose` `when` `otherwise` `forEach` `forTokens` `if`
URL Management	`import` `paramredirect` `param` `url` `param`
XML	Core	`out` `parse` `set`	`/jstl-x`	`x`
Flow Control	`choose when otherwise` `forEach` `if`
Transformation	`transform` `param`
I18n	Locale	`setLocale`	`/jstl-fmt`	`fmt`
Message formatting	`bundle` `message` `param` `setBundle`
Number and dateformatting	`formatNumber` `formatDate` `parseDate` `parseNumber` `setTimeZone` `timeZone`
Database		`setDataSource`	`/jstl-sql`	`sql`
SQL	`query` `dateParam` `param` `transaction` `update dateParam` `param`

Using JSTL tags


<%@ page contentType="text/html; charset=ISO-8859-5" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<fmt:formatNumber value="123456789" />

<c:if test="${1 == 1}">
  1 == 1 is true
</c:if>

<c:if test="${1 == 2}">
  1 == 2 is true
</c:if>

<br>

<c:set var="name" value="Fred" />
His name is ${name}

<br>
<c:forEach var="current" items="${headerValues}">
  Header key is: ${current.key},
  Value is: ${header[current.key]}
  <br>
</c:forEach>

Expression language

JSTL evaluates expressions in tags, both as attributes and as tag content
Expressions are enclosed in ${ ... }
The expression language is based on ECMAScript (JavaScript) and XPath

JSTL Implicit objects

The EL (expression language) has a number of inbuilt variables including

pageContext
pageContext.request
param
paramValues
header
headerValues

JSTL and i18n

The i18n tag library is defined by the URL http://java.sun.com/jsp/jstl/fmt

The customary namespaces is "fmt":


      <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

Formatting tags are
- fmt:setLocale
- fmt:formatNumber
- fmt:formatDate
- fmt:timeZone
- fmt:setTimeZone
- fmt:parseDate
- fmt:parseNumber
- fmt:requestEncoding
- fmt:bundle


<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html; charset=ISO-8859-1" %>

<c:set var="locale" value="${pageContext.request.locale}" />

<fmt:setLocale value="${locale}" />

12356.678 in the ${locale} locale is
<fmt:formatNumber value="12345.678" />

Expression variables

Variables in expressions can be implicit ones as above
You can also put your own variables in the application context, eg. from a servlet

Servlet


package jan;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;

public class LocaleServlet extends HttpServlet {
    public void doGet(HttpServletRequest request,
		      HttpServletResponse response)
	throws ServletException, IOException {
	
	HttpSession session = request.getSession(true);
	Locale[] availableLocales = new Locale[] {
	    Locale.CANADA_FRENCH,
	    Locale.FRANCE,
	    Locale.SIMPLIFIED_CHINESE};

	session.setAttribute("availableLocales", availableLocales);

	RequestDispatcher dispatcher = request.
	    getRequestDispatcher("/jsp/availableLocales.jsp");
	if (dispatcher != null)
	    dispatcher.forward(request, response);
    }

    public void doPost(HttpServletRequest request,
		      HttpServletResponse response)
	throws ServletException, IOException {
	doGet(request, response);
    }
}

JSP:


<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.Locale" %>
<%@ page contentType="text/html; charset=ISO-8859-5" %>

Locales are ${availableLocales}
Looping:
<c:forEach var="index" items="${availableLocales}">
  Locale is ${availableLocales[index]}
  <br>
</c:forEach>

Summary

Java Server Pages act as the presentation end of a backend web application. They allow a mix of HTML and Java in various ways

Include all the Java code in JSP scripts and expressions
Define extra Java classes and just include a few calls to them in JSP scripts and expressions
Use a tag and expression library such as JSTL
Build and use a tag library

References

Create internationalized JSP applications by Sing li
Java Web Services Tutorial Sun MicroSystems
` JavaServer Pages Standard Tag Library Sun MicroSystems
Apache Jakarta Tomcat Apache Software Foundation
Jakarta Taglibs Apache Software Foundation
Internationalize JSP-based Websites Govind Seshadri
Common problems with i18n and servlets/jsp-s Anton Tagunov
JSP Standard Tag Library eases Webpage development Steve Small
JSP Standard Tag Libraries, Part 1 Sue Spielman
JSP Standard Tag Libraries, Part 2 Sue Spielman
JSTL 1.0: Standardizing JSP, Part 1 Hans Bergsten
JSTL 1.0: What JSP Applications Need, Part 2 Hans Bergsten

Jan Newmarch <jan@newmarch.name>

This work is licensed under a Creative Commons License
The moral right of Jan Newmarch to be identified as the author of this page has been asserted.