Scribd
Upload
17 views

Introduction To JSP With Forms and Javabeans

This document provides an introduction to using JSP (JavaServer Pages) with forms and JavaBeans. It discusses how JSP embeds Java code in HTML tags, and how a JSP page is translated into a Java servlet. It then demonstrates a simple "Hello World" JSP example and shows the equivalent servlet code generated. The document outlines the basic JSP constructs of directives, declarations, scriptlets, and expressions. It also covers using request and response objects, generating and processing HTML forms, and using JavaBeans to simplify form handling in JSP.

Uploaded by

Deebiga Rajeswaran
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
17 views

Introduction To JSP With Forms and Javabeans

This document provides an introduction to using JSP (JavaServer Pages) with forms and JavaBeans. It discusses how JSP embeds Java code in HTML tags, and how a JSP page is translated into a Java servlet. It then demonstrates a simple "Hello World" JSP example and shows the equivalent servlet code generated. The document outlines the basic JSP constructs of directives, declarations, scriptlets, and expressions. It also covers using request and response objects, generating and processing HTML forms, and using JavaBeans to simplify form handling in JSP.

Uploaded by

Deebiga Rajeswaran
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 32

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

You might also like