Introduction To JSP With Forms and Javabeans

Introduction to JSP
with Forms and JavaBeans

Overview
Embeds Java code
In HTML tags
When used well
 Simple way to generate dynamic web-pages
When misused (complex embedded Java)
 Terribly messy (and may violate OaOO)
Keep the embedded Java simple
 Use external helper classes (Beans?)
Life Cycle
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)
Hello World
<html>
<head> <title> Hello JSP </title> </head>
<body>
<p> Hello World:
<%= new java.util.Date() %>
</p>
</body>
</html>
See also: Date_jsp.java – the Servlet this page is

translated to
Date_jsp.java (extract)
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");
Produced
Basic Constructs
So far we’ve seen literals:

 E.g. <html>
 Copied straight to output (to browser)
And expressions:
 E.g. <%= new java.util.Date() %>
 Return a value included in the output
Also have:
 Directives, Declarations and Scriptlets
Directives
Instructions to the compiler
Examples:
 Include another page (compile-time)
<%@ include file="header.jsp" %>
 Import some Java packages (comma sep.)
<%@ page import=“java.util.Collection”%>
Declarations
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; } %>
Scriptlets
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
Illustrative Example
Demonstrates much of the above
<%! int n = 0; %>
Page accessed: <%= ++n %> times
<% if ( (n % 10) == 0 )
{
n = 0;
}
%>
What happens on next refresh?
Request and Response
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
Form Handling with JSP
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
HTML Forms
Allow user to supply input
 Text Fields – single line
 Password field – single line, blanked-out text
 Text Areas – multi-line
 Choice (pop-up menu)
 Radio-button (1 from n)
 Check-box (m from n)
 Browse button
 Submit buttons
Form Generation
Need to generate the HTML to send to the
client
The forms should be well presented
 e.g. aligned in a table
Need to name the input fields
So that we may extract the data from the
submitted form
Next: some sample form elements
Some sample form elements
linked/FormElements.html
Form Processing
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>)
Submission Data Formats
When a form is generated, it can also
specify the data format
By default, this is plain text
But can also be a MIME format
MIME allows upload of binary data (via
base-64 encoding)
Hence allows files of any type to be
uploaded to a web server
Form Life-Cycles and
Data Models
Where does a form come from?
Where are the data-types specified?
What’s the destination for the form input data?
How do we best validate it on the server?
What kind of data models are appropriate?
Can we separate form content from form
presentation?
Form Processing Architectures
Helper classes for servlets
 To generate forms (+ other HTML)
 Process the form input
JSP + JavaBeans (more later)
JSP + Tag Library (not covered in this course)
XForms – not covered, but well worth a read if
you’re keen!
MS InfoPath – installed in the Lab – can auto-
generate forms from XML Schemas
JavaBeans
Come in two types
 Simple (this course)
 Enterprise (EJB: more complex, not covered)
Simple JavaBeans
 Data bound classes
 Define properties (fields)
 Define get/set methods
See following example
Hotel Booking Form
HTML (body) for Booking Form
<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>
Accessing Submitted Values
(manual version)
<html>
<head><title>Bean test</title></head>
<body>
<h2>
<%=request.getParameter("name") %>
to stay for
<%= request.getParameter("nNights") %>
nights.
</h2>
</body>
</html>
JavaBean Version (Auto)
<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>
Java Code for Bean Version
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;
}
}
Resulting Page
Bean Scope
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
Bean Scope (cont.)
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)
Beans v. Manual
For this example, consider the
differences:
 JavaBean JSP page: more complex
 JavaBean also required an external class
definition
Discussion question:
 When would JavaBean solutions be better
than manual versions?
Answer:
Lab Exercises
Try typing in and running running these
JSP examples for yourself
Instructions for Tomcat: see Lab pages
Also study the servlet code produced (in
the tomcat\work directory

Introduction To JSP With Forms and Javabeans

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introduction To JSP With Forms and Javabeans

Uploaded by

Copyright:

Available Formats

Introduction to JSP

with Forms and JavaBeans

See also: Date_jsp.java – the Servlet this page is

So far we’ve seen literals:

<jsp:setProperty name='roomBooking' property='*' />

public String getName() {

You might also like