1. DT211/3 Internet Application Development
Introduction to Java Server Pages (JSP)

2. Introduction First – need to know the various “java” related terms:
J2EE, J2SE, JDK, JRE, JSP,JSTL, Java Servlets,Tomcat, Apache etc…..

3. Introduction – J2EE Java Server Pages Servlets Java beans Java
Sun Microsystems supply the Java 2 Enterprise Edition (J2EE) platform, enabling developers to develop java based enterprise applications
J2EE is a standard set of technologies and APIs
(note: J2SE is the standard edition of the java platform but is not geared at large enterprise environments with distributed systems)
J2EE includes the following components:
Java
Server
Pages
Servlets
Java
beans
Java
Messaging
JNDI
JDBC

4. Introduction – J2EE
Since J2EE is a specification, vendors create products that support the J2EE specifcation e.g. Apache, IBM WebSphere, BEA Weblogic.
From a web perspective, the J2EE applications that are particularly relevant are:
Java Server Pages Java servlets Java Beans
Can be used on its own or with beans/servlets to create a web application
Can be used on its own or with JSP/beans to create a web application
More complex web applications may use all 3

5. Introduction – JDK
The (JDK) Java Development Kit is the collective name for the various development components supplied in the J2EE (or J2SE).
The Java Runtime Environment (JRE) is consists of the components required to run a java application

6. Introduction to JSP
Java Server Pages – A technology for developing web
pages that include dynamic content
Created by SUN microsystems
‘Equivalent’ of Microsoft’s Active Server Pages technology
Pages have a file extension of .JSP
JSPs enable web developers to enhance HTML code
by adding special JSP elements that are processed by the
server
Will use JSP v2.0

7. Advantages of JSP JSP pages are pre-compiled  Fast
Part of the Sun’s J2EE - Can be used with other types of java technologies, such as servlets - flexible
JSP is a specification  multiple vendors support it  commercially stable/not ‘fly by night’ technology
Easy to develop: HTML can be easily maintained with JSP. Relatively minimal programming skills required.
JSP page code is not visible on client – only generated HTML is visible

8. Running JSP pages To develop and run JSP pages, need:
Not automatically included with all web servers
To develop and run JSP pages, need:
- Java Developer Kit (JDK which is part of J2EE) or higher AND a Web server that contains a JSP Container
JSP Containers are not automatically included with all Web servers
Examples of web servers that contain a JSP container are Apache Tomcat and Blazix.

9. JSP Containers JSP Container
The JSP Container intercepts all client request for JSP pages
First time a JSP page is requested, the Container converts the page into a java program called a Servlet and compiles -- Translation phase
For all follow-on request, the Container processes each request by invoking the appropriate servlet and then generating the response - Request processing phase
Q: What happens if the JSP page is changed?

10. How a JSP page is processed by server
First time through,
JSP is translated to a servlet
After, container goes directly to the servlet in the request processing phase
If JSP page is changed, servlet is re-compiled

11. JSP and Apache
Apache project have a sub project called Jakarta (see
Jakarta project produces
Tomcat web server (nicknamed Catalina)
Tomcat webserver incorporates JSP container (nicknamed Jasper)

12. Software Versions JSP technology developing rapidly
 New version contain major new capabilities
 Always note the JSP container version you are working with, and check functionality supported (on apache website)
This course using
Apache Tomcat Version 5
JSP 2
JSLT 1.1
Servlet 2.4

13. To run a JSP Using apache Tomcat…
Create your web application directory
Create the subset WEB-INF directory (won’t run without this)
Put JSP page into web application directory
Call from the browser

14. To run a JSP In the background –
Tomcat will retrieve the JSP page from the web server
If it’s the first time JSP page has been called/run or if page has changed, Tomcat will compile the JSP page (into a servlet) - .java and .class placed in /work directory.
- subsequent calls to page will be faster as no compile needed
JSP page will be presented back to the user

15. Simplest JSP.. Helloworld
Prints out message to user when JSP is loaded..
Tomcat demo..

16. Another Simple JSP example
<html>
page import="java.util.Date" %>
<head>
<title>JSP DATE EXAMPLE</title>
</head>
<body bgcolor=#ffffff>
<h1>JSP DATE</h1>
<h2>
The current date is <%= new Date() %>.
</h2>
</body>
</html>
Prints out the current date

17. Readability of JSP pages
Always always always ensure that code is:
INDENTED COMMENTED CONTAINS AN ID BLOCK
Indented - to reflect level of the code <html>
<head>ajsdlkfjads etc
2) Well commented. Comments in JSP appear as <%-- calculate the sum of x and z here --%>
Comments in HTML appear as <!--- this is a comment -->
HTML comments will be visible by view source in browser, JSP comments won’t.

18. Readability of JSP pages
3) Titled with an ID block:
At the top of each JSP page, should have an ID block explaining who write the script, date, script name, description and any revisions. Can use either JSP or HTML comments (depending on whether users should be able to see the ID block)
<%--
*********************************************
*** Script name: addition.jsp ***
*** Author: Keith Morneau ***
*** Date: July 7th ***
*** Desciption: whatever it does.. ***
*** Revisions: ***
*** August 8th 2006: added subroutine ***
************************************************
--%>
etc

19. JSP techniques
JSP provides variety of techniques to enable dynamic processing:
Directive elements
In this topic
Scripting elements (java)
Action elements and Java Standard Tags Library
Java Beans

20. JSP Pages: Directive Elements
Directive Elements - Used to provide information about the general set-up of the page. e.g. inclusion of header files, name of page to report errors, whether session tracking is required etc
Always enclosed between …… %>
Syntax: directivename attribute = “value”, attribute = “value” …. %>

21. JSP Pages: Directive Elements
There are Three directives available to use:
page ….. >
include …… %>
taglib ….. %>

22. Directive Elements
Each directive has a set of associated attributes (similar to some tags in HTML)
Usually placed at top of JSP file but doesn’t have to be
Example:
page import="java.util.*, java.lang.*" %>
Full list of attributes available at:

23. Directive Elements: Page
Page directive - defines attributes that apply to an entire JSP page.
Examples
page contentType = “text/html” %>
page language = “java” %>
page errorPage="error.jsp" %>

24. Directive Elements: Page
List of attributes includes
page [ language="java" ] [ import="{package.class | package.*}, ..." ] [ session="true|false" ] [ isThreadSafe="true|false" ] *multiple threads allowed or not [ info="text" ] *gives info about the page to administration [ errorPage="relativeURL" ] [ contentType="mimeType [ ;charset=characterSet ]" | "text/html ; charset=ISO " ] [ isErrorPage="true|false" ] *Specifies whether exception object available or not %>

25. Directive Elements: Include
Include directive - Includes a static file in a JSP file at translation time
Syntax
include file="relativeURL" %>
The included file can be an HTML file, a JSP file, a text file, or a code file written in the Java programming language
Useful for including repetitive HTML content across a web site – headers, navigation bars, footers etc
Useful for common logic – e.g. date displays

26. Directive Elements: Include
Example: jsp page name = includexample.jsp
<html> <head><title>An Include Test</title></head> <body bgcolor="white"> <font color="blue"> The current date and time is include file="date.jsp" %> </font> </body> </html>

27. Directive Elements: Include
Example (continued) jsp page name = date.jsp
page import="java.util.*" %> <%= (new java.util.Date() ).toLocaleString() %>
Included
into includexample.jsp
from previous page
When includexample.jsp is run, displays as
The current date and time are Aug 30, :38:40

28. Directive Elements: Taglib
Taglib directive - Defines a tag library and prefix for the custom tags used in the JSP page.
Syntax
taglib uri="URIToTagLibrary“ prefix="tagPrefix" %>
Example:
taglib uri=“ prefix=“c" %>
More on taglib directives later when we use Java Standard Tag Library (JSTL)

29. Directive Elements: summary
Three directives: page, include, taglib
Used to define general set-up information about the JSP page
By themselves, don’t “do” anything
At least one used in most JSP pages

30. JSP dynamic processing
Directive elements
Done
Scripting elements
Action elements and JSTL
Java Beans

31. Scripting elements
Developers in JSP can insert java code directly into a JSP pages using scripting elements
The code is executed when the page is requested
Should be used with extreme care:
Too much code  difficult to maintain
Difficult for HTML programmers
More suitable for simple applications with small development team
Q: How do you specify that the language being used in page by scripting elements is java?
A: Page directive language attribute

32. Scripting elements Three types of scripting elements:
Expressions: The expression syntax <%= ... %> defines a scripting language expression .. “result”
Scriptlets: The scriptlet syntax <% ... %> can handle declarations, expressions, or any other type of code fragment valid in the page scripting language.
When you write a scriptlet, end the scriptlet with %> before you switch to HTML, text, or another JSP tag
3. Declarations: The declaration syntax <%! ... %> declares variables or methods.

33. Scripting elements: Expressions
Contains any valid java expression in the JSP page
Used to output dynamic values directly onto web page (e.g. result of a calculation, dates)
Enclosed between <% and %>
output as a string
Syntax <%= expression %> e.g. <% = 1+1%>

34. Expressions - examples
E.gs: any valid java expression
<%= Math.sqrt(2) %> <%= items[i] %> <%= a + b + c %> <%= new java.util.Date() %>

35. Scripting elements: Expressions
Example
<html>
<body>
Current time is: <%= new java.util.Date() %>
</body>
</html>

36. Scripting elements: Expressions
Note:
Evaluated at run time. Result is added to the response body and output directly to web page
Can use an expression within a line of text, whether or not it is tagged with HTML
Must be a valid java expression
No “;” required at end of expression (unlike scriptlets)

37. Scripting elements Scriptlets Three types of scripting elements:
Expressions
Scriptlets
Declarations

38. Scripting elements: Scriptlets
Scriplets are java code fragments with a JSP page
Enables more complex functionality than expressions
Java code is placed between <% and %> characters (just like expressions, but without the = sign at the start of the sequence.)
Can have any number of valid java code statements
Scriptlet contains Java code that is executed every time the JSP is invoked
Syntax: <% code %>

39. Scripting elements: Scriptlets
Example – jsp page that outputs numbers 1 to 10 onto a web page
html>
<head>
<title>Count to 10 in JSP scriptlet</title>
</head>
<body>
<%
for(int i=1;i<=10;i++)
{%>
<%=i%><br/> }
%>
</body>
</html>
Scriptlets
Expression used to
output to page. Can’t put HTML
Tags into the scriptlet. Can only contain valid java code

40. Scripting elements: Scriptlets
Example – jsp page that outputs numbers 1 to 10 onto a web page – Output in browser will be:..
Count to 10 in JSP 1 2 3 4 5 6 7 8 9 10

41. Scriplets: mixing scriplets with HTML and other tags
When you mingle scripting elements with HTML and JSP tags, you must always end a scripting element before you start using tags and then reopen the scripting element afterwards, like this:
<% } else { %> <!-- closing the scriptlet before the tags start --> ... tags follow ... <% } %> <!-- reopening the scriptlet to close the language block -->
At first, this may look a bit strange, but it ensures that the scripting elements are transformed correctly when the JSP source file is compiled

42. Scripting elements: Scriptlets
Example 2 –jsp page that outputs
“Hello! The time is now Wed Sep 03 13:17:58 BST Your machine's address is ” onto a web page
<HTML>
<BODY>
<%
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>
Note: could have
put this line outside the scriptlet
as HTML

43. Scripting elements: Scriptlets
Note:
Any text, HTML tags, or JSP elements you write must be outside the scriptlet
Readability: Mixture of Tags and Java code can be difficult
to read – especially for HTML developers

44. Scripting elements: Scriptlets
<% if (Math.random() < 0.5) { %>
Have a <B>nice</B> day!
<% } else { %>
Have a <B>lousy</B> day!
<% } %>
In background, JSP container compiles the JSP page into Java code.. converting the HTML snippets into java code to out.print statements
---

45. Scripting elements: Scriptlets
JSP code on previous page will be converted in background to the following java code..
if (Math.random() < 0.5) {
out.println("Have a <B>nice</B> day!"); }
else
out.println("Have a <B>lousy</B> day!");

46. Scripting elements: Scriptlets
Example 3 – fragment of JSP page that generates a table in HTML containing numbers 1 to n
<TABLE BORDER=2>
<%
for ( int i = 0; i < n; i++ ) {
%>
<TR>
<TD>Number</TD>
<TD><%= i+1 %></TD>
</TR> }
</TABLE>
HTML within “for” loop is output n times
Note: would need to supply int variable n before it will work…

47. Scripting elements Declarations Three types of scripting elements:
Expressions
Scriptlets
Declarations

48. Scripting elements: Declarations
Declaration: Declares a variable or method that can be used throughout the JSP page
Examples
<%! int i = 0; %> <%! int a, b, c; %> <%! Circle a = new Circle(2.0); %>
Syntax
<%! declarations; %>
Note the “ ;”

49. Scripting elements: Declarations
Declarations don’t generate any output onto the page by themselves
- usually used with expressions and/or scriptlets
Examples
<%! private int accessCount; %>
Accesses to page since server reboot:
<%= ++accessCount %>
Prints the number of times the current page has been requested since the server was booted

50. Scripting elements: Declarations
Example – Declares method getDate()
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>
Method
getDate()
returns a Date
object

51. Declaration
Declarations (between <%! and %> tags) contain one or more variable or method declarations that end or are separated by semicolons:
<%! int i = 0; %> <%! int a, b; double c; %> <%! Circle a = new Circle(2.0); %> You must declare a variable or method in a JSP page before you use it in the page. The scope of a declaration is usually a JSP file, but if the JSP file includes other files with the include directive, the scope expands to cover the included files as well.

52. Declarations Warnings!
Declaring variables in a JSP page using declarations can cause synchronisation problems.. Compiled servlets see these as variables which may be shared across all users using the JSP page.
On previous date example, Date stays the same when the page is reloaded.. Because only a single instance of the page (and there of the variable theDate is available). Better to use local variables within declared methods or scriptlets