Introduction to JSP
Download
Report
Transcript Introduction to JSP
Embeds Java code
In HTML tags
When used well
When misused (complex embedded Java)
Simple way to generate dynamic web-pages
Terribly messy (and may violate OaOO)
Keep the embedded Java simple
Use external helper classes (Beans?)
JSP Document
Translation
.java file
Compilation
.class file
Reinitialization
.class file ready to run
Subsequent
User Requests
Response Document
A JSP page is translated into a Java Servlet
And then compiled
On Tomcat, the compilation happens the first
time a page is requested
First request can be very slow!
Afterwards, just as fast as a Servlet (because it
is then a servlet)
<html>
<head> <title> Hello JSP </title>
</head>
<body>
<p> Hello World:
<%= new java.util.Date() %>
</p>
</body>
</html>
This extract shows the part that produces the output – compare it
with the JSP:
out = pageContext.getOut();
_jspx_out = out;
out.write("<html>\r\n");
out.write("<head> ");
out.write("<title> Hello JSP ");
out.write("</title> ");
out.write("</head>\r\n");
out.write("<body> \r\n");
out.write("<p> Hello World:\r\n
");
out.print( new java.util.Date() );
out.write("\r\n");
out.write("</p>\r\n");
out.write("</body>\r\n");
out.write("</html>\r\n");
So far we’ve seen literals:
And expressions:
E.g. <html>
Copied straight to output (to browser)
E.g. <%= new java.util.Date() %>
Return a value included in the output
Also have:
Directives, Declarations and Scriptlets
Instructions to the compiler
Examples:
Include another page (compile-time)
<%@ include file="header.jsp" %>
<jsp:include page="page.jsp" flush="true" />
What is the difference ???
Import some Java packages (comma sep.)
<%@ page import=“java.util.Collection”%>
These are tags that start with the word jsp as in
the previous example
These are mainly for handling form beans as
will be shown later apart from 3 tags.
<jsp:forward, to forward user to another page
<jsp:plugin, to import plugin as a java applet in
the client browser.
<jsp:forward page="/servlet/login" />
<jsp:plugin type=applet code="Molecule.class"
codebase="/html">
<jsp:include, to include the result of a jsp page
Used to declare variables and methods
Go in the declaration section of the Servlet
Can then be used later in the JSP page
Note the syntax
Examples:
<%! int count = 0 %>
<%! double sqr(double x) {
return x * x; } %>
These are sections of Java code embedded in
the page
Unlike expressions, they do not return a value
But may write directly to the page
Get the writer: response.getWriter()
They go in the service method of the servlet
Get executed each time a page is requested
Demonstrates much of the above
<%! int n = 0; %>
Page accessed: <%= ++n %> times
<% if ( (n % 10) == 0 ) {
n = 0;
}
%>
Application
Config
Out
Request
Response
Session
Each JSP page has access to two special objects
The Request object carries information passed
by the HTTP request (e.g. made by the
browser)
This includes any submitted form data
The Response object is used to pass
information back to the Client (browser)
E.g. response.getWriter() provides an
output stream for direct writing to the client
JSP makes form handling easy
Can use request.getParameter() to get
submitted values
Or can define a JavaBean to grab the values
semi-automatically.
We’ll see this in action later with a simple
example
Global object: request, session
<% session.putValue(“username”,
request.getParameter(“UserName”))
%>
<html><body>
Thanks for giving us your name, <%=
session.getValue(“username”) %>
</body></html>
The form can specify whether data is supplied
via a GET or POST request
POST is the usual way
Therefore, a servlet should implement the
doPost() method to process a form
JSP hides these GET/POST details (see
request.getParameter and
<jsp:setProperty>)
Helper classes for servlets
To generate forms (+ other HTML)
Process the form input
JSP + JavaBeans (more later)
JSP + Tag Library (will be covered later)
Come in two types
Simple JavaBeans
Simple (this course)
Enterprise (EJB: more complex, not covered)
Data bound classes
Define properties (fields)
Define get/set methods
See following example
<body>
<h3 align="center">Welcome to the Hotel
California</h3>
<form method="POST" action="BookHotel.jsp">
<p>Name: <input type="text" name="name"
size="20"></p>
<p>How many nights:
<select size="1" name="nNights">
<option selected="">1</option>
<option>2</option>
<option>3</option>
</select></p>
<p>
<input type="submit" value="Submit" name="B1">
</p>
</form>
</body>
<html>
<head><title>Bean test</title></head>
<body>
<h2>
<%=request.getParameter("name") %>
to stay for
<%= request.getParameter("nNights") %>
nights.
</h2>
</body>
</html>
<jsp:useBean id='roomBooking'
scope='page'
class='beans.HotelBean'
/>
<jsp:setProperty name='roomBooking' property='*'
/>
<html>
<head><title>Bean test</title></head>
<body>
<h2> <%=roomBooking.getName()%>
to stay for
<%= roomBooking.getnNights() %> nights. </h2>
</body>
</html>
package beans;
public class HotelBean {
String name;
int nNights;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getnNights() {
return nNights;
}
public void setnNights(int nNights) {
this.nNights = nNights;
}
}
Note the setting: scope='page'
Scope has four possible settings:
Page
Bean exists for execution of that page only
Request
Like page, but survives any forward or include
requests
Session
The Bean exists for multiple requests within the
web application, from a particular web browser
instance
Used for shopping baskets etc.
Application
The Bean exists for all requests from all users, for
all pages that use it.
Survives until the Web Application Server is
restarted
Can be used for a database connection (or
connection pool)
For this example, consider the differences:
Discussion question:
JavaBean JSP page: more complex
JavaBean also required an external class
definition
When would JavaBean solutions be better than
manual versions?
Answer:
<%@ page import="java.util.*" %>
<HTML>
<BODY>
<%!
Date theDate = new Date();
Date getDate() {
return theDate;
}
%>
Hello! The time is now <%= getDate() %>
</BODY>
</HTML>
The JSP can get really intractable with lots of
scriplets
A direct example of using scriplet is a for loop
to display records from a database in a table
format.
Put the code for the view in a function and call
it as much as you need
<%
public void printRecord(int Number){
out.print(“<TR>”);
out.print(“<TD>Number</TD>”);
out.print(“<TD>” +Number+“</TD>”);
out.print(“</TR>”);
}
%>
<TABLE BORDER=2>
<%
for ( int i = 0; i < n; i++ )
{
printRecord(i+1);
}
%>
</TABLE>
This doesn’t look anymore like an HTML code.
What is the point of JSP then, is it to get messy
code!!
So, sun devised a remedy for that and the final
result looked really good, but not the
development
The solution is called JSP Standard Tag Library
or JSTL.
The last example will be written in one tag as
<mylib: for start=“1” end=“10”/>
Next Lecture