Scribd
Upload
4 views10 pages

JSP Example3

Uploaded by

Sudha Kore
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
4 views10 pages

JSP Example3

Uploaded by

Sudha Kore
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 10

How JSP Pages Work

A JSP page is basically a web page with traditional HTML and bits of Java code. The
file extension of a JSP page is ".jsp" rather than ".html" or ".htm", and that tells the
server that this page requires special handling that will be accomplished by a server
extension or a plug-in. Here is a simple example:
Sample 1: date.jsp
Copy
Copied to Clipboard
Error: Could not Copy
<HTML>
<HEAD>
<TITLE>JSP Example</TITLE>
</HEAD>
<BODY BGCOLOR="ffffcc">
<CENTER>
<H2>Date and Time</H2>
<%
java.util.Date today = new java.util.Date();
out.println("Today's date is: "+today);
%>
</CENTER>
</BODY>
</HTML>
This example contains traditional HTML and some Java code. The tag <% identifies the
beginning of a scriptlet, and the %> tag identifies the end of a scriptlet. When date.jsp is
requested from a web browser, you see something similar to Figure 1.

Figure 1: Requesting date.jsp


Behind the Scenes
When this page (date.jsp) is called, it will be compiled (by the JSP engine) into a java
servlet. At this point the servlet is handled by the servlet engine just like any other
servlet. The servlet engine then loads the servlet class (using a class loader) and
executes it to create dynamic HTML to be sent to the browser, as shown in Figure 2.
For this example, the servlet creates a Date object and writes it as a string to
the out object, which is an output stream to the browser.

Figure 2: Request/Response Flow when Calling a JSP


The next time the page is requested, the JSP engine executes the already-loaded
servlet unless the JSP page has changed, in which case it is automatically recompiled
into a servlet and executed.
Scripting Elements
In the date.jsp example the full Date class name is used including the package name,
which may become tedious. If you want to create an instance of Date simply by
using: Date today = new Date(); without having to specify the full class path use
the page directive as follows:
Sample 2 :date2.jsp
Copy
Copied to Clipboard
Error: Could not Copy
<%@page import="java.util.*" %>
<HTML>
<HEAD>
<TITLE>JSP Example</TITLE>
</HEAD>
<BODY BGCOLOR="ffffcc">
<CENTER>
<H2>Date and Time</H2>
<%
java.util.Date today = new java.util.Date();
out.println("Today's date is: "+today);
%>
</CENTER>
</BODY>
</HTML>
Yet, another way of doing the same thing using the <%= tag is by writing:
Sample 3:date3.jsp
Copy
Copied to Clipboard
Error: Could not Copy
<%@page import="java.util.*" %>
<HTML>
<HEAD>
<TITLE>JSP Example</TITLE>
</HEAD>
<BODY BGCOLOR="#ffffcc">
<CENTER>
<H2>Date and Time</H2>
Today's date is: <%= new Date() %>
</CENTER>
</BODY>
</HTML>
As you can see, the same thing can be accomplished using different tags and
techniques. There are several JSP scripting elements. Here are some conventional
rules that will help you use JSP scripting elements effectively:
 Use <% ... %> to handle declarations, expressions, or any other type of valid
snippet of code. Sample 1 above is an example.
 Use the page directive as in <%@page ... %> to define the scripting language.
Also, it can be used to specify import statements. Here is an example:
<%@page language="java" import="java.util.*" %>.
 Use <%! .... %> to declare variables or methods. For example:
<%! int x = 10; double y = 2.0; %>.
 Use <%= ... %> to define an expression and cast the result as a String. For
example:
<%= a+b %> or <%= new java.util.Date() %>.
 Use the include directive as in <%@ include ... %> to insert the contents of
another file in the main JSP file. For example:
<%@include file="copyright.html" %>.
Handling Forms
One of the most common parts of ecommerce applications is an HTML form where the
user enters some information such as name and address. Using JSP, the form's data
(the information the user enters in the form) gets stored in the request object that is sent
from the browser to the JSP container. The request is processed and the result is sent
through the response object back to the browser. These two objects are implicitly
available to you.
To demonstrate how to handle HTML forms using JSP, here is an example form with
two fields: one for name and the other for email. As you can see, the HTML form is
defined in a JSP source file. The request.getParameter method is being used to retrieve
data from the form into variables created using JSP tags.
The process.jsp page prints either a form or the information provided by the user
depending on the values of the form's fields. If the form's values are null the form is
displayed, otherwise, the information provided by the user is displayed. Note that the
form is created and being handled by code in the same JSP file.
Sample 4: process.jsp
Copy
Copied to Clipboard
Error: Could not Copy
<HTML>
<HEAD>
<TITLE>Form Example</TITLE>
</HEAD>
<BODY BGCOLOR="#ffffcc">
<% if (request.getParameter("name")==
null && request.getParameter("email")
== null) { %>
<CENTER>
<H2>User Info Request Form</H2>
<FORM METHOD="GET"
ACTION="/developer/technicalArticles/xml/WebAppDev/process.jsp">
<P>
Your name: <input type="text" name=
"name" size=26>
<P>
Your email: <input type="text" name=
"email" size=26>
<P>
<input type="submit" value="Process">
</FORM>
</CENTER>
<% } else { %>
<%! String name, email; %>
<%
name = request.getParameter("name");
email = request.getParameter("email");
%>
<P>
<B>You have provided the following
info</B>:
<P>
<B>Name</B>: <%= name %><P>
<B>Email</B>: <%= email %>
<% } %>
</BODY>
</HTML>
If process.jsp is requested from a web server, you see something similar to Figure 3.

Figure 3: process.jsp loaded


Enter your name and email and click on Process to submit the form for processing, and
you see something similar to Figure 4.

Figure 4: Form is processed


Reusable Components
The above example form is simple in the sense that there is not much code involved.
When more code is involved, then it is important not to mix business logic with front end
presentation in the same file. Separating business logic from presentation permits
changes to either side without affecting the other. However, production JSP code
should be limited to front end presentation. So, how do you implement the business
logic part?
That is where JavaBeans come in to play. This technology is a portable, platform-
independent component model that lets developers write components and reuse them
everywhere. In the context of JSP, JavaBeans contain business logic that returns data
to a script on a JSP page, which in turn formats the data returned from the JavaBean
component for display by the browser. A JSP page uses a JavaBean component by
setting and getting the properties that it provides.
What are the Benefits
There are several benefits to using JavaBeans to augment JSP pages:
 Reusable components: different applications will be able to reuse the
components.
 Separation of business logic and presentation logic: you can change the way
data is displayed without affecting business logic.
 Protecting your intellectual property by keeping source code secure.
Example: Using JavaBeans with JSP
Now, let's see how to modify the process.jsp example above to use JavaBeans. In the
above form these are two fields: name and email. In JavaBeans, these are called
properties. So, first you write a JavaBean component with setX and getX methods,
where X is the property name. For example, if you have get and set
methods: setName and getName then you have a property known as name. Sample 5
shows a FormBean component.
Good components must be able to interoperate with other components from different
vendors. Therefore, to achieve component reuse, there are two important rules (which
are imposed by the JavaBeans architecture) to follow:
1. Your bean class must provide a constructor with no arguments so it can be
created using Beans.instantiate.
2. Your bean class must support persistence by implementing the
interface Serializable or Externalizable.
Sample 5: FormBean.java
Copy
Copied to Clipboard
Error: Could not Copy
package userinfo;
import java.io.*;
public class FormBean implements Serializable {
private String name;
private String email;
public FormBean() {
name = null;
email = null;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setEmail(String email) {
this.email = email;
}
public String getEmail() {
return email;
}
}
In order to use the FormBean component in the JSP file, you need to instantiate the
bean component. This is done using the <jsp:useBean> tag. The next
line <jsp:setProperty> is executed when the bean is instantiated, and used to initialize
the bean's properties. In this case, both properties ( name and email) are set using a
single statement. Alternatively, it is possible to set the properties one at a time, but first
you need to retrieve the form's date. Here is an example of how you would set
the name property:
Copy
Copied to Clipboard
Error: Could not Copy
<%! String yourname, youremail; %>
<% yourname =
request.getParameter("name"); %>
<jsp:setProperty name=
"formbean" property="name"
value="<%=yourname%>"/>
Once the properties have been initialized with data retrieved from the form, property
values are retrieved for presentation using <jsp:getProperty> in the else part, as shown
in Sample 6.
Sample 6: process2.jsp
Copy
Copied to Clipboard
Error: Could not Copy
<jsp:useBean id="formbean" class=
"userinfo.FormBean"/>
<jsp:setProperty name="formbean" property=
"*"/>
<HTML>
<HEAD>
<TITLE>Form Example</TITLE>
</HEAD>
<BODY BGCOLOR="#ffffcc">
<% if (request.getParameter("name")==null
&& request.getParameter("email") == null) { %>
<CENTER>
<H2>User Info Request Form </H2>
<form method="GET"
action="/developer/technicalArticles/xml/WebAppDev/process2.jsp">
<P>
Your name: <input type="text" name=
"name" size=27>
<p>
Your email: <input type="text" name=
"email" size=27>
<P>
<input type="submit" value="Process">
</FORM>
</CENTER>
<% } else { %>
<P>
<B>You have provided the following info</B>:
<P>
<B>Name</B>: <jsp:getProperty name=
"formbean"
property="name"/>
<P>
<B>Email</B>: <jsp:getProperty
name="formbean" property="email"/>
<% } %>
</BODY>
</HTML>
Conclusion

You might also like