JSP Part 2

Java/J2EE Programming Training
Including File and Applet in JSP Pages

Classification: Restricted
Agenda
• Including Files at Request Time: jsp:include
• Understanding jsp:include vs. <%@ include … %>
• Options for Deploying Applets
• Using jsp:plugin
• Attributes of
the jsp:plugin Element
• Using JavaBeans Components in JSP Documents
• Background: What Are Beans?
• Using Beans: Basic Tasks
• Setting Simple Bean Properties: jsp:setProperty
• JSP Page That Uses StringBean(Code)
• Conditional Bean Operations
• Sharing Beans in Four Different Ways
• Session-Based Sharing: Code
• Application-Based Sharing: Code
• Application-Based Sharing: Result

• Format
– <jsp:include page="Relative URL" />
• Purpose
– To reuse JSP, HTML, or plain text content
– To permit updates to the included content without changing the main JSP
page(s)
• Notes
– JSP content cannot affect main page:
only output of included JSP page is used
– Don't forget that trailing slash
– Relative URLs that starts with slashes are interpreted relative to the Web
app, not relative to the server root.
– You are permitted to include files from WEB-INF
Including Files at Request Time: jsp:include

• …
• <BODY>
• <TABLE BORDER=5 ALIGN="CENTER">
• <TR><TH CLASS="TITLE">
• What's New at JspNews.com</TABLE>
• <P>
• Here is a summary of our three
• most recent news stories:
• <OL>
• <LI><jsp:include page="/WEB-INF/Item1.html" />
• </OL>
• </BODY></HTML>
jsp:include Example: A News Headline Page (Main Page)

A News Headline Page: Result

• Use jsp:include whenever possible
– Changes to included page do not require any
manual updates
– Speed difference between jsp:include and the include directive
(@include) is insignificant
• The include directive (<%@ include …%>) has additional power, however
– Main page
• <%! int accessCount = 0; %>
– Included page
• <%@ include file="snippet.jsp" %>
• <%= accessCount++ %>
Which Should You Use?

• Footer defined the accessCount field (instance variable)
•
• If main pages used accessCount, they would have to use @include
– Otherwise accessCount would be undefined
• In this example, the main page did not use accessCount
– So why did we use @include?
Understanding jsp:include vs. <%@ include … %>

• Develop the applets with JDK 1.1 or even 1.02 (to support really old
browsers).
– Works with almost any browser
– Uses the simple APPLET tag
• Have users install version 1.4 of the Java Runtime Environment (JRE), then
use JDK 1.4 for the applets.
– Requires IE 5 or later or Netscape 6 or later
– Uses the simple APPLET tag
• Have users install any version of the Java 2 Plug-in, then use Java 2 for the
applets.
– Works with almost any browser
– Uses ugly OBJECT and EMBED tags
Options for Deploying Applets

• Simple APPLET-like tag
– Expands into the real OBJECT and EMBED tags
• APPLET Tag
– <APPLET CODE="MyApplet.class"
WIDTH=475 HEIGHT=350>
</APPLET>
• Equivalent jsp:plugin
– <jsp:plugin type="applet"
code="MyApplet.class"
width="475" height="350">
</jsp:plugin>
• Reminder
– JSP element and attribute names are case sensitive
– All attribute values must be in single or double quotes
– This is like XML but unlike HTML
Using jsp:plugin

<jsp:plugin type="applet"
code="SomeApplet.class"
</jsp:plugin>
jsp:plugin: Source Code

• …
• <BODY>
• <CENTER>
• <TABLE BORDER=5>
• <TR><TH CLASS="TITLE">
• Using jsp:plugin</TABLE>
• <P>
• <jsp:plugin type="applet"
• code="PluginApplet.class"
• width="370" height="420">
• </jsp:plugin>
• </CENTER></BODY></HTML>
jsp:plugin: Example (JSP Code)

• import javax.swing.*;
• /** An applet that uses Swing and Java 2D
• * and thus requires the Java Plug-in.
• */
• public class PluginApplet extends JApplet {
• public void init() {
• WindowUtilities.setNativeLookAndFeel();
• setContentPane(new TextPanel());
• }
• }
• Where are .class files installed?
jsp:plugin: Example (Java Code)

• type
– For applets, this should be "applet".
Use "bean" to embed JavaBeans elements in Web pages.
• code
– Used identically to CODE attribute of APPLET, specifying the top-level
applet class file
• width, height
– Used identically to WIDTH, HEIGHT in APPLET
• codebase
– Used identically to CODEBASE attribute of APPLET
• align
– Used identically to ALIGN in APPLET and IMG
Attributes of the jsp:plugin Element

• hspace, vspace
– Used identically to HSPACE, VSPACE in APPLET,
• archive
– Used identically to ARCHIVE attribute of APPLET, specifying a JAR file from
which classes and images should be loaded
• name
– Used identically to NAME attribute of APPLET, specifying a name to use
for inter-applet communication or for identifying applet to scripting
languages like JavaScript.
• title
– Used identically to rarely used TITLE attribute
Attributes of the jsp:plugin Element (Cont.)

• jreversion
– Identifies version of the Java Runtime Environment (JRE) that is required.
Default is 1.2.
• iepluginurl
– Designates a URL from which plug-in for Internet Explorer can be
downloaded. Users who don’t already have the plug-in installed will be
prompted to download it from this location. Default value will direct user
to Sun site, but for intranet use you might want to direct user to a local
copy.
• nspluginurl
– Designates a URL from which plug-in for Netscape can be downloaded.
Default value will direct user to Sun site, but for intranet use you might
want local copy.
Attributes of the jsp:plugin Element (Cont.)

• PARAM Tags
– <APPLET CODE="MyApplet.class"
WIDTH=475 HEIGHT=350>
<PARAM NAME="PARAM1" VALUE="VALUE1">
<PARAM NAME="PARAM2" VALUE="VALUE2">
</APPLET>
• Equivalent jsp:param
– <jsp:plugin type="applet"
code="MyApplet.class"
<jsp:params>
<jsp:param name="PARAM1" value="VALUE1" />
<jsp:param name="PARAM2" value="VALUE2" />
</jsp:params>
</jsp:plugin>
The jsp:param and jsp:params Elements

Using JavaBeans Components
in JSP Documents

• Scripting elements calling servlet code directly
• Scripting elements calling servlet code indirectly (by means of
utility classes)
• Beans
• Servlet/JSP combo (MVC)
• MVC with JSP expression language
• Custom tags
Simple
Application
Complex
Application
Uses of JSP Constructs

• Java classes that follow certain conventions
– Must have a zero-argument (empty) constructor
• You can satisfy this requirement either by explicitly defining such a
constructor or by omitting all constructors
– Should have no public instance variables (fields)
• I hope you already follow this practice and use accessor methods
instead of allowing direct access to fields
– Persistent values should be accessed through methods called getXxx and
setXxx
• If class has method getTitle that returns a String, class is said to have a
String property named title
• Boolean properties use isXxx instead of getXxx
– For more on beans, see
http://java.sun.com/beans/docs/
Background: What Are Beans?

• jsp:useBean
– In the simplest case, this element builds a new bean.
It is normally used as follows:
• <jsp:useBean id="beanName" class="package.Class" />
• jsp:getProperty
– This element reads and outputs the value of a bean property.
It is used as follows:
• <jsp:getProperty name="beanName" property="propertyName" />
• jsp:setProperty
– This element modifies a bean property (i.e., calls a method of the form
setXxx). It is normally used as follows:
• <jsp:setProperty name="beanName"
• property="propertyName"
• value="propertyValue" />
Using Beans: Basic Tasks

• Format
– <jsp:useBean id="name" class="package.Class" />
• Purpose
– Allow instantiation of Java classes without explicit Java programming
(XML-compatible syntax)
• Notes
– Simple interpretation:
<jsp:useBean id="book1" class="coreservlets.Book" />
can be thought of as equivalent to the scriptlet
<% coreservlets.Book book1 = new coreservlets.Book(); %>
– But jsp:useBean has two additional advantages:
• It is easier to derive object values from request parameters
• It is easier to share objects among pages or servlets
Building Beans: jsp:useBean

• Format
– <jsp:getProperty name="name" property="property" />
• Purpose
– Allow access to bean properties (i.e., calls to getXxx methods) without
explicit Java programming
• Notes
– <jsp:getProperty name="book1" property="title" />
is equivalent to the following JSP expression
<%= book1.getTitle() %>
Accessing Bean Properties: jsp:getProperty

• Format
– <jsp:setProperty name="name"
property="property"
value="value" />
• Purpose
– Allow setting of bean properties (i.e., calls to setXxx methods) without
explicit Java programming
• Notes
– <jsp:setProperty name="book1"
property="title"
value="Core Servlets and JavaServer Pages" />
is equivalent to the following scriptlet
<% book1.setTitle("Core Servlets and JavaServer Pages"); %>
Setting Simple Bean Properties: jsp:setProperty

• package coreservlets;
• public class StringBean {
• private String message = "No message specified";
• public String getMessage() {
• return(message);
• }
• public void setMessage(String message) {
• this.message = message;
• }
• }
• Beans installed in normal Java directory
– …/WEB-INF/classes/directoryMatchingPackageName
• Beans (and utility classes) must always be in packages!
Example: StringBean

• <jsp:useBean id="stringBean"
• class="coreservlets.StringBean" />
• <OL><LI>Initial value (from jsp:getProperty):
• <I><jsp:getProperty name="stringBean"
• property="message" /></I>
• <LI>Initial value (from JSP expression):
• <I><%= stringBean.getMessage() %></I>
• <LI><jsp:setProperty name="stringBean"
• property="message"
• value="Best string bean: Fortex" /> Value after setting property with
jsp:setProperty:
• <I><jsp:getProperty name="stringBean"
• property="message" /></I>
• <LI><% stringBean.setMessage
• ("My favorite: Kentucky Wonder"); %>
• Value after setting property with scriptlet:
• <I><%= stringBean.getMessage() %></I>
• </OL>
JSP Page That Uses StringBean (Code)

• You can use the scope attribute to specify additional places where bean is
stored
– Still also bound to local variable in _jspService
– <jsp:useBean id="…" class="…"
scope="…" />
• Lets multiple servlets or JSP pages
share data
• Also permits conditional bean creation
– Creates new object only if it can't find existing one
Sharing Beans

• page (<jsp:useBean … scope="page"/> or
<jsp:useBean…>)
– Default value. Bean object should be placed in the PageContext object for
the duration of the current request. Lets methods in same servlet access
bean
• application
(<jsp:useBean … scope="application"/>)
– Bean will be stored in ServletContext (available through the application
variable or by call to getServletContext()). ServletContext is shared by all
servlets in the same Web application (or all servlets on server if no explicit
Web applications are defined).
Values of the scope Attribute

• session
(<jsp:useBean … scope="session"/>)
– Bean will be stored in the HttpSession object associated with the current
request, where it can be accessed from regular servlet code with
getAttribute and setAttribute, as with normal session objects.
• request
(<jsp:useBean … scope="request"/>)
– Bean object should be placed in the ServletRequest object for the
duration of the current request, where it is available by means of
getAttribute
Values of the scope Attribute

• Bean conditionally created
– jsp:useBean results in new bean being instantiated only if no bean with
same id and scope can be found.
– If a bean with same id and scope is found, the preexisting bean is simply
bound to variable referenced by id.
• Bean properties conditionally set
– <jsp:useBean ... />
replaced by
<jsp:useBean ...>statements</jsp:useBean>
– The statements (jsp:setProperty elements) are executed only if a new
bean is created, not if an existing bean is found.
Conditional Bean Operations

• Using unshared (page-scoped) beans.
• Sharing request-scoped beans.
• Sharing session-scoped beans.
• Sharing application-scoped (i.e., ServletContext-scoped) beans.
Note:
– Use different names (i.e., id in jsp:useBean) for different beans
Sharing Beans in Four Different Ways

• …
• <BODY>
• <H1>Baked Bean Values: session-based Sharing</H1>
• <jsp:useBean id="sessionBean"
• class="coreservlets.BakedBean"
• scope="session" />
• <jsp:setProperty name="sessionBean"
• property="*" />
• <H2>Bean level:
• <jsp:getProperty name="sessionBean"
• property="level" />
• </H2>
• <H2>Dish bean goes with:
• <jsp:getProperty name="sessionBean"
• property="goesWith" />
• </H2></BODY></HTML>
Session-Based Sharing: Code

• <BODY>
• <H1>Baked Bean Values:
• application-based Sharing</H1>
• <jsp:useBean id="applicationBean"
• class="coreservlets.BakedBean"
• scope="application" />
• <jsp:setProperty name="applicationBean"
• property="*" />
• <H2>Bean level:
• <jsp:getProperty name="applicationBean"
• property="level" />
• </H2>
• <H2>Dish bean goes with:
• <jsp:getProperty name="applicationBean"
• property="goesWith"/>
• </H2></BODY></HTML>
Application-Based Sharing: Code

Application-Based Sharing: Result (Later Request -- Same Client)

Client
Browser
1. Request
4. Response
JSP
2. Create
JavaBeans
3. Retrieve data
DB
Application Server
The JSP Model 1 Architecture

JavaBeans
Client
Browser
1. Request
6. Response
Servlet
(Controller
2. Create
JavaBeans
DB
Application Server
JSP (View)
4.Invoke JSP
5.Use
JavaBeans
3.Retrieve
data
The JSP Model 2 Architecture

Thank You

JSP Part 2

More Related Content

What's hot (20)

Similar to JSP Part 2 (20)

More from DeeptiJava (13)

Recently uploaded (20)

JSP Part 2