JSP – Java Server Pages Part 1

JSP – Java Server PagesJSP – Java Server PagesPart 1Part 1

Representation and Management of Data on the Internet

IntroductionIntroduction

What is JSP Good For?What is JSP Good For?

• Servlets allow us to write dynamic Web pages

- Easy access to request, session and context data

- Easy manipulation of the response (cookies, etc.)

- And lots more...

• It is not convenient to write and maintain long

static HTML using Servlets

out.println("<h1>Bla Bla</h1>" + "bla bla bla bla"

+ "lots more here...")

JSP IdeaJSP Idea

• Use HTML for most of the page

• Write Servlet code directly in the HTML page, marked with special tags

• The server automatically translates a JSP page to a Servlet class and the latter is actually invoked- In Tomcat 5.0, you can find the generated Servlet

code under $CATALINA_BASE/work/

RelationshipsRelationships

• Servlets: HTML code is printed in Java code

• JSP: Java code is embedded in HTML code

Java

HTMLJava

HTML

ExampleExample

<html>

<head>

<title>Hello World</title>

</head>

<body>

<h2><%= new java.util.Date() %></h2>

<h1>Hello World</h1>

</body>

</html>

Tomcat 5.0 Generated Servlet

http://localhost/dbi/code/hello_jsp.html

http://localhost/dbi/code/hello_jsp.html

http://localhost/dbi/hello.jsp

Generated Servlet HierarchyGenerated Servlet Hierarchy(Tomcat 5.0 Implementation)(Tomcat 5.0 Implementation)

Apache

Implementation

Generated

Servlet

Sun

Specifications

GenericServlet

Servlet

JspPage

HttpJspPageHttpServlet

HttpJspBase

mypage_jsp

JSP Limitations and AdvantagesJSP Limitations and Advantages

• JSP can only do what a Servlet can do

• Easier to write and maintain HTML

• Easier to separate HTML from code

• Can use a "reverse engineering technique": create static HTML and then replace static data with Java code

JSP Life CycleJSP Life Cycle


The following table describes the life cycle of JSP generated Servlet in details:


Page first w

ritten

Request#1

Request#2

Server restarted

Request#3

Request#4

Page m

odified

Request#5

Request#6

JSP page translated into servlet

Yes No No No Yes No

Servlet compiled Yes No No No Yes No

Servlet instantiated and loaded into server's memory

Yes No Yes No Yes No

init (or equivalent) called

Yes No Yes No Yes No

doGet (or equivalent) called

Yes Yes Yes Yes Yes Yes

Written by Marty Hall. Core Servlets & JSP book: www.coreservlets.com

JSP TranslationJSP Translation

• When the JSP file is modified, JSP is translated into a Servlet - Application need not be reloaded when JSP file is modified

• Server does not generate the Servlet class after startup, if the latter already exists- Generated Servlet acts just like any other Servlet

init()init() and and destroy()destroy()

• init() of the generated Servlet is called every time the Servlet class is loaded into memory and instantiated

• destroy() of the generated Servlet is called every time the generated Servlet is removed

• The latter two happen even if the reason is modification of the JSP file

Thread SynchronizationThread Synchronization

• After the Servlet is generated, one instance of it serves requests in different threads, just like any other Servlet

• In particular, the service method (_jspService) may be executed by several concurrent threads

• Thus, like Servlets, JSP programming requires concurrency management

Basic JSP ElementsBasic JSP Elements

Basic Elements in a JSP fileBasic Elements in a JSP file

• HTML code: <html-tag>content</html-tag>

• JSP Comments: <%-- comment --%>

• Expressions: <%= expression %>

• Scriptlets: <% code %>

• Declarations: <%! code %>

• Directives: <%@ directive attribute="value" %>

• Actions: <jsp:forward.../>, <jsp:include.../>

• EL Expressions: ${expression} Covered Later...

JSP ExpressionsJSP Expressions

• A JSP expression is used to insert Java values directly into the output

• It has the form: <%= expression %> , where expression can be a Java object, a numerical expression, a method call that returns a value, etc...

• For example:

<%= new java.util.Date() %>

<%= "Hello"+" World" %>

<%= (int)(100*Math.random()) %>

JSP ExpressionsJSP Expressions

• A JSP Expression is evaluated

• The result is converted to a string

• The string is inserted into the page

• This evaluation is performed at runtime (when the page is requested), and thus has full access to information about the request, the session, etc...

Expression TranslationExpression Translation

<h1>A Random Number</h1><%= Math.random() %>

public void _jspService(HttpServletRequest request, HttpServletResponse response)

throws java.io.IOException, ServletException { ... response.setContentType("text/html"); ... out.write("<h1>A Random Number</h1>\r\n"); out.print( Math.random() );

out.write("\r\n"); ...

}

Predefined Variables (Implicit Objects)Predefined Variables (Implicit Objects)

• The following predefined variables can be used:

- request: the HttpServletRequest

- response: the HttpServletResponse

- session: the HttpSession associated with the request

- out: the PrintWriter (a buffered version of type JspWriter) used to fill the response content

- application: The ServletContext

• These variables and more will be discussed in details

<html>

<head>

<title>JSP Expressions</title>

</head>

<body>

<h2>JSP Expressions</h2>

<ul>

<li>Current time: <%= new java.util.Date() %></li>

<li>Your hostname:<%= request.getRemoteHost() %></li>

<li>Your session ID: <%= session.getId() %></li>

<li>The <code>testParam</code> form parameter:

<%= request.getParameter("testParam") %></li>

</ul>

</body>

</html>

http://localhost/dbi/expressions.html

JSP ScripletsJSP Scriplets

• JSP scriptlets let you insert arbitrary code into the Servlet service method ( _jspService )

• Scriptlets have the form: <% Java Code %> • The code is inserted verbatim into the service

method, according to the location of the scriplet

• Scriptlets have access to the same automatically defined variables as expressions

<%= foo() %> <% bar(); %>

public void _jspService(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {

...response.setContentType("text/html");...out.print(foo());bar();...

}

Scriptlet TranslationScriptlet Translation

An Interesting ExampleAn Interesting Example

Scriptlets don't have to be complete code blocks:

<% if (Math.random() < 0.5) { %> You <b>won</b> the game! <% } else { %> You <b>lost</b> the game! <% } %>

if (Math.random() < 0.5) { out.write("You <b>won</b> the game!"); } else { out.write("You <b>lost</b> the game!"); }

JSP DeclarationsJSP Declarations

• A JSP declaration lets you define methods or members that get inserted into the Servlet class (outside of all methods)

• It has the following form: <%! Java Code %>

• For example: <%! private int someField = 5; %>

<%! private void someMethod(...) {...} %>

• It is usually of better design to define methods in a separate Java class...

Declaration ExampleDeclaration Example

• Print the number of times the current page has been requested since the Servlet initialization:

<%! private int accessCount = 0; %>

<%! private synchronized int incAccess() {

return ++accessCount;

} %>

<h1>Accesses to page since Servlet init:

<%= incAccess() %> </h1>

http://localhost/dbi/

public class serviceCount_jsp extends... implements...

throws... {

private int accessCount = 0;

private synchronized int incAccess() {

return ++accessCount;

}

public void _jspService(HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException {

...

...

out.write("<h1>Accesses to page since Servlet init: ");

out.print(incAccess());

... } ... }

jspInit jspInit andand jspDestroy jspDestroy

• In JSP pages, like regular Servlets, we sometimes want to implement init and destroy

• It is illegal to use JSP declarations to override init or destroy, since they are (usually) already implemented by the generated Servlet

• Instead, override the methods jspInit and jspDestroy- The generated servlet is guaranteed to call these methods from

init and destroy, respectively

- The standard versions of jspInit and jspDestroy are empty (placeholders for you to override)

JSP DirectivesJSP Directives

• A JSP directive affects the structure of the

Servlet class that is generated from the JSP page

• It usually has the following form:

<%@ directive attribute1="value1" ...

attributeN="valueN" %>

• Three directives: page, include and taglib

• include and taglib will be discussed later

pagepage-Directive Attributes-Directive Attributes

• import attribute: A comma separated list of

classes/packages to import

<%@ page import="java.util.*, java.io.*" %>

• contentType attribute: Sets the MIME-Type of the

resulting document (default is text/html)

<%@ page contentType="text/plain" %>

• What is the difference between setting the contentType

attribute, and writing <

%response.setContentType("...");%> ?

More More pagepage-Directive Attributes-Directive Attributes

• session="true|false" - use a session?

• buffer="sizekb|none"

- Specifies the content-buffer size (out)

• autoFlush="true|false"

- Specifies whether the buffer should be flushed when

it fills, or throw an exception otherwise

• isELIgnored ="true|false"

- Specifies whether JSP expression language is used

- EL is discussed later

Variables in JSP Variables in JSP

Implicit ObjectsImplicit Objects

• As seen before, some useful variables, like request and session are predefined

• These variables are called implicit objects

• Implicit objects are defined in the scope of the service method- Can these be used in JSP declarations?

• Implicit objects are part of the JSP specifications

The objectsThe objects request request and and responseresponse

• request and response are the HttpServletRequest and HttpServletResponse arguments of the service method

• Using these objects, you can:

• Read request parameters

• Set response headers

• etc. (everything we learned in Servlet lectures)

The objectThe object out out

• This is the Writer used to add write output into the response body

• This object implements the interface JspWriter that combines the functionality of PrintWriter and BufferedWriter

• Recall that you can adjust the buffer size, or turn buffering off, through use of the buffer attribute of the page directive

The objectThe object pageContext pageContext

• pageContext is a new object introduced by JSP

• This object stores all important elements used by

the generated Servlet, like the application

context, the session, the output writer, etc.

• It enable vendors to elegantly extend their JSP

implementation

• This object is also used to store page-scoped

attributes (e.g., Java Beans - discussed later)

The objectThe object session session

• This is the HttpSession object associated with the request

• If the session attribute in the page directive is turned off (<%@ page session="false" %>) then this object is not available

• Recall that a session is created by default

The objectThe object config config

• This is the ServletConfig of the page, as received in the init() method

• Remember: contains Servlet specific initialization parameters

• Later, we will study how initialization parameters are passed to JSP pages

• Recall that you can also obtain the ServletContext from config

The objectThe object application application

• This is the ServletContext as obtained via

getServletConfig().getContext()

• Remember:

- The ServletContext is shared by all Web-application

Servlets (including ones generated from JSP)

- Getting and setting attributes is with getAttribute and

setAttribute of ServletContext

- You can use this object to get application-wide

initialization parameters

Page ScopePage Scope

• service() local variables

• pageContext attributes

client 1

client 2

a.jsp

b.jsp

Request ScopeRequest Scope

• request attributes

client 1

client 2

a.jsp

b.jsp

client 1

client 2

a.jsp

b.jsp

Session ScopeSession Scope

• session attributes

client 1

client 2

a.jsp

b.jsp

Servlet ScopeServlet Scope

• Servlet members

client 1

client 2

a.jsp

b.jsp

Application ScopeApplication Scope

• application attributes

client 1

client 2

a.jsp

b.jsp

Servlet Package and Helper ClassesServlet Package and Helper Classes

• The generated Servlet has a named package

• In Tomcat, this package is: org.apache.jsp

• In Java, you cannot use classes from the default package (i.e. with no package declaration) from a named package!

• Therefore, helper classes used by JSP pages must have a named package

JSP and XMLJSP and XML

Simple XML ProductionSimple XML Production

<?xml version="1.0"?>

<!DOCTYPE colors SYSTEM "colors.dtd">

<?xml-stylesheet type="text/xsl" href="colors.xsl"?>

<%! static String[] colors = {"red","blue","green"}; %>

<%@ page contentType="text/xml" %>

<colors>

<% for(int i=0; i<3; ++i) { %>

<color id="<%=i%>"><%= colors[i] %></color>

<% } %>

</colors>

Generated XMLGenerated XML

<?xml version="1.0"?>

<!DOCTYPE colors SYSTEM "colors.dtd">

<?xml-stylesheet type="text/xsl" href="colors.xsl"?>

<colors>

<color id="0">red</color>

<color id="1">blue</color>

<color id="2">green</color>

</colors>

• JSPX files are JSP files that have the extension jspx and have XML syntax

• Non-XML symbols <%, <%@, etc. are replaced with special JSP tags

• Default content type of JSPX is text/xml (and not text/html)

• Thus, JSPX files generate XML and can be edited using XML tools

JSPX FilesJSPX Files

<%= Expression %><jsp:expression> Expression

</jsp:expression>

<% Code %><jsp:scriptlet>

Code

</jsp:scriptlet>

<%! Declaration %><jsp:declaration> Declaration

</jsp:declaration>

<%@ Directive %><jsp:directive.typeAttribute="value"/>

Problems with JSPXProblems with JSPX

• The XML declaration (<?xml version="1.0"?>) and the DOCTYPE definition are now those of the JSPX file. How do we include those in the result XML?- Solution: use the <jsp:output> tag to explicitly require

DOCTYPE and XML declarations

• How do we generate dynamic attribute values and still keep the document well formed?- Solution 1: use <jsp:element> for explicit element construction

- Solution 2: use an EL expression (discussed later)

<colors xmlns:jsp="http://java.sun.com/JSP/Page">

<jsp:output doctype-root-element="colors"

doctype-system="colors.dtd" />

<jsp:output omit-xml-declaration="false"/>

<jsp:declaration>static String[] colors = {"red","blue","green"};

</jsp:declaration><jsp:scriptlet><![CDATA[ for(int i=0; i<3; ++i) { ]]></jsp:scriptlet>

<jsp:element name="color"><jsp:attribute name="id">

<jsp:expression>i</jsp:expression></jsp:attribute>

<jsp:expression>colors[i]</jsp:expression></jsp:element><jsp:scriptlet>}</jsp:scriptlet>

</colors>

JSP as JSPXJSP as JSPX

• You can tell the container that a JSP file acts as a JSPX file

• Use the <jsp:root> element as the document root

<jsp:root version="2.0" xmlns:jsp="http://java.sun.com/JSP/Page"> <jsp:output doctype-root-element="colors" doctype-system="colors.dtd" />

<jsp:output omit-xml-declaration="false"/>

<![CDATA[<?xml-stylesheet type="text/xsl" href="colors.xsl"?>]]>

<colors >

<jsp:declaration>static String[] colors = {"red","blue","green"};

</jsp:declaration>

<jsp:scriptlet><![CDATA[ for(int i=0; i<3; ++i) { ]]></jsp:scriptlet>

<jsp:element name="color">

<jsp:attribute name="id">

<jsp:expression>i</jsp:expression></jsp:attribute>

<jsp:expression>colors[i]</jsp:expression>

</jsp:element>

<jsp:scriptlet>}</jsp:scriptlet>

</colors>

</jsp:root>

Using External ParametersUsing External Parameters

JSP Initial ParametersJSP Initial Parameters

• Like Servlets, initialization parameters can be passed to JSP files using the <servlet> element of the application configuration file web.xml

• Use the sub-element <jsp-file> instead of the sub-element <servlet-class>

• A <servlet-mapping> is also needed

- Use the real JSP URL as the <url-pattern>

<web-app>

<context-param>

<param-name>dbLogin</param-name>

<param-value>snoopy</param-value>

</context-param>

<context-param>

<param-name>dbPassword</param-name>

<param-value>snoopass</param-value>

</context-param>

An ExampleAn Example

web.xml

<servlet>

<servlet-name>ParamPage</servlet-name>

<jsp-file>/paramPage.jsp</jsp-file>

<init-param>

<param-name>tableName</param-name>

<param-value>users</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>ParamPage</servlet-name>

<url-pattern>/paramPage.jsp</url-pattern>

</servlet-mapping>

</web-app>

web.xml

<html>

<head><title>JSP initial parameters</title></head>

<body>

<h1>Hello</h1>

<h2>I should use the table

<i><%= config.getInitParameter("tableName") %></i>

</h2>

<h2>To access the Database, I should use the login

<i><%= application.getInitParameter("dbLogin") %></i>

and the password

<i><%= application.getInitParameter("dbPassword") %></i>.

</h2>

</body>

</html>

paramPage.jsp

http://localhost/dbi/paramPage.jsp

JSP – Java Server Pages Part 1

Documents

Transcript of JSP – Java Server Pages Part 1