© 2010 Marty Hall

Using
g JavaBeans
in JSP
Originals of Slides and Source Code for Examples:
http://courses.coreservlets.com/Course-Materials/csajsp2.html

Customized Java EE Training: http://courses.coreservlets.com/

Servlets, JSP, JSF 2.0, Struts, Ajax, GWT 2.0, Spring, Hibernate, SOAP & RESTful Web Services, Java 6.
2 Developed and taught by well-known author and developer. At public venues or onsite at your location.

© 2010 Marty Hall

For live Java EE training, please see training courses

at http://courses.coreservlets.com/.
Servlets, JSP, Struts, JSF 1.x, JSF 2.0, Ajax (with jQuery, Dojo,
Prototype, Ext-JS, Google Closure, etc.), GWT 2.0 (with GXT),
Java 5, Java 6, SOAP-based and RESTful Web Services, Spring, g
Hibernate/JPA, and customized combinations of topics.
Taught by the author of Core Servlets and JSP, More
Servlets and JSP, JSP and this tutorial.tutorial Available at public
venues,Customized
or customized versions
Java EE Training: can be held on-site at your
http://courses.coreservlets.com/
organization. Contact hall@coreservlets.com for details.
Servlets, JSP, JSF 2.0, Struts, Ajax, GWT 2.0, Spring, Hibernate, SOAP & RESTful Web Services, Java 6.
Developed and taught by well-known author and developer. At public venues or onsite at your location.
 Agenda
• Understanding the benefits of beans
– We will use standalone beans here. Later sections will
cover beans with MVC and the JSP expression language.
• Creating beans
• Installing bean classes on your server
• Accessing bean properties
• Explicitly setting bean properties
• Automatically setting bean properties from
request parameters
• Sharing beans among multiple servlets and
JSP pages
4

Uses of JSP Constructs

• Scripting elements calling servlet

Simple code directly
Application
• Scriptingg elements calling
g servlet
code indirectly (by means of utility
classes)
• Beans
B
• Servlet/JSP combo (MVC)
• MVC with
ith JSP expression
i language
l
Complex • Custom tags
Application • MVC with
ith beans,
b custom
t tags,
t andd
a framework like Struts or JSF
5
 Background: What Are Beans?
• Java classes that follow certain conventions
– Must have a zero-argument (empty) constructor
• You can satisfy this requirement either by explicitly
defining
g such a constructor or by
y omitting
g all constructors
– Should have no public instance variables (fields)
• You should 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 may use isXxx instead of getXxx
• It is the name of the method, not instance var that matters!
– For more on beans, see http://java.sun.com/beans/docs/
6

More on Bean Properties

• Usual rule to turn method name into
property name
– Drop the word “get” or “set” and change the next letter to
lowercase. Again, instance var name is irrelevant.
• Method name: getUserFirstName
• Property name: userFirstName
• Exception
p 1: boolean properties
p p
– If getter returns boolean or Boolean
• Method name: getPrime or isPrime
• Property name: prime
• Exception 2: consecutive uppercase letters
– If two uppercase letters in a row after “get” or “set”
• M
Method
th d name: getURL
tURL
• Property name: URL (not uRL)
7
 Bean Properties: Examples
Method Names Property Name Example JSP Usage
getFirstName firstName <jsp:getProperty … property="firstName"/>
setFirstName <jsp:setProperty … property="firstName"/>
${customer.firstName}

isExecutive executive <jsp:getProperty … property="executive"/>

setExecutive <jsp:setProperty … property="executive"/>
(boolean property) ${customer.executive}

getExecutive executive <jsp:getProperty … property="executive"/>

setExecutive <jsp:setProperty … property="executive"/>
(boolean property) ${customer.executive}

getZIP ZIP <jsp:getProperty … property="ZIP"/>

setZIP <jsp:setProperty … property="ZIP"/>
${address.ZIP}

Note 1: property name does not exist anywhere in your code. It is just a shortcut for the method name.
Note 2: property name is derived only from method name. Instance variable name is irrelevant.

Why You Should Use

Accessors Not Public Fields
Accessors,
• To be a bean, you cannot have public fields
• So, you should replace
public double speed;
• with
Note: in Eclipse, after you create instance variable, if you R-click and choose “Source”,
private double speed; it gives you option to generate getters and setters for you.

public
bli ddouble
bl getSpeed()
d() {
return(speed);
}
public
bli void
id setSpeed(double
tS d(d bl newSpeed)
S d) {
speed = newSpeed;
}
• Y
You should
h ld do
d this
thi in
i all
ll your Java
J code
d
anyhow. Why?
9
 Why You Should Use
Accessors Not Public Fields
Accessors,
• 1) You can put constraints on values
public void setSpeed(double newSpeed) {
if (newSpeed < 0) {
sendErrorMessage(...);
newSpeed = Math.abs(newSpeed);
}
speed = newSpeed;
}

– If users of your class accessed the fields directly, then

they would each be responsible for checking constraints.

10

Why You Should Use

Accessors Not Public Fields
Accessors,
• 2) You can change your internal
representation
i without
ih changing
h i interface
i f
// Now using
g metric units (
(kph,
p , not mph)
p )

public void setSpeed(double newSpeed) {

speedInKPH = convert(newSpeed);
}

public
p blic void
oid setSpeedInKPH(do
setSpeedInKPH(double
ble ne
newSpeed)
Speed) {
speedInKPH = newSpeed;
}

11
 Why You Should Use
Accessors Not Public Fields
Accessors,
• 3) You can perform arbitrary side effects
public double setSpeed(double newSpeed) {
speed = newSpeed;
updateSpeedometerDisplay();
}

– If users of your class accessed the fields directly, then

they would each be responsible for executing side effects.
Too much work and runs huge risk of having display
inconsistent from actual values.

12

Using Beans: Basic Tasks

• jsp:useBean
– IIn the
h simplest
i l case, thishi element
l bbuilds
ild a new bean.
b
It is normally used as follows:
• <jsp:useBean id="beanName" class="package.Class" />
• jsp:setProperty
– This element modifies a bean property (i.e., calls a
setBlah method). It is normally used as follows:
• <jsp:setProperty name="beanName"
property="propertyName"
p p y
value="propertyValue" />
• jsp:getProperty
– This element reads and outputs the value of a bean
property It is used as follows:
property.
• <jsp:getProperty name="beanName"
property="propertyName" />
13
 General Approach with Standalone
Pages and jsp:useBean Tags
• Input form
– User submits form that refers to a JSP page
• <FORM ACTION="SomePage.jsp">
• JSP Page
– JSP page instantiates a bean
• <jsp:useBean
j id="myBean"
y class="…"/>
– You pass some request data to the bean
• <jsp:setProperty name="myBean"
property customerID
property="customerID"
value="…"/>
– You output some value(s) derived from the request data
• <jsp:getProperty name=
name="myBean"
myBean
property="bankAccountBalance"/>
14

Building Beans: jsp:useBean

• Format
– <jsp:useBean id="name" class="package.Class" />
• Purpose
– All
Allow instantiation
i i i off Java
J classes
l without
ih explicit
li i Java
J
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
15
 Setting Simple Bean Properties:
jsp:setProperty
• Format
– <jsp:setProperty name="name"
property="property"
value="value"
value value //>
• Purpose
– Allow settingg of bean properties
p p (i.e.,
( calls to setXxx
methods) without explicit Java programming
• Notes
– <jsp:setProperty
j P name="book1"
"b k1"
property="title"
value="Core Servlets and JavaServer Pages" />
i equivalent
is i l to the
h following
f ll i scriptlet
i l
<% book1.setTitle("Core Servlets and JavaServer Pages"); %>
16

Accessing Bean Properties:

jsp:getProperty
• Format
– <jsp:getProperty name="name" property="property" />
• Purpose
– All
Allow access to bean
b properties
i (i.e.,
(i calls
ll to getXxx
X
methods) without explicit Java programming
• Notes
– <jsp:getProperty name="book1" property="title" />
is equivalent
q to the followingg JSP expression
p
<%= book1.getTitle() %>

17
 Example: StringBean
package coreservlets;
public class StringBean {
private String message = "No message specified";
public String getMessage() {
return(message);
}
public void setMessage(String message) {
this.message
hi = message;
}
}
• Beans installed in normal Java directory
– MyEclipse: src/folderMatchingPackage
p y
– Deployment: WEB-INF/classes/folderMatchingPackage
f g g
• Beans must always be in packages!
18

JSP Page That Uses StringBean

(Code)
<jsp:useBean id="stringBean"
g
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=
name="stringBean"
stringBean
property="message" /></I>
<LI><% stringBean.setMessage
("My favorite: Kentucky Wonder"); %>
Value after setting property with scriptlet:
<I><%= stringBean.getMessage() %></I>
</OL>
19
 JSP Page That Uses StringBean
(Result)

20

Setting Bean Properties Case 1:

Explicit Conversion & Assignment
<!DOCTYPE ...>
...
<jsp:useBean id="entry"
class="coreservlets.SaleEntry" />

<%-- setItemID expects a String --%>

<jsp:setProperty
j p p y
name="entry"
property="itemID"
q g
value='<%= request.getParameter("itemID") %>' />

21
 Setting Bean Properties Case 1:
Explicit Conversion & Assignment
<%
int numItemsOrdered = 1;
try {
numItemsOrdered =
Integer parseInt(request getParameter("numItems"));
Integer.parseInt(request.getParameter( numItems ));
} catch(NumberFormatException nfe) {}
%>

<%-- setNumItems expects an int --%>

<jsp:setProperty
jsp:set ope ty
name="entry"
property="numItems"
value="<%= numItemsOrdered %>" />
/

22

Setting Bean Properties Case 1:

Explicit Conversion & Assignment
<%
double discountCode = 11.0;
0;
try {
String discountString =
request getParameter("discountCode");
request.getParameter( discountCode );
discountCode =
Double.parseDouble(discountString);
} catch(NumberFormatException nfe) {}
%>

<%--
% setDiscountCode
set scou tCode e
expects
pects a doub
double
e --%>
%

<jsp:setProperty
y
name="entry"
property="discountCode"
value="<%= discountCode %>" />
23
 Setting Bean Properties Case 1:
Explicit Conversion & Assignment

24

Case 2: Associating Individual

Properties with Input Parameters
• Use the param attribute of jsp:setProperty
to indicate
i di that
h
– Value should come from specified request parameter
– Simple automatic type conversion should be performed
for properties that expect values of standard types
• boolean, Boolean, byte, Byte, char, Character, double,
D bl int,
Double, i t Integer,
I t float,
fl t Float,
Fl t long,
l or Long.
L

25
 Case 2: Associating Individual
Properties with Input Parameters
<jsp:useBean id="entry"
class="coreservlets SaleEntry" />
class="coreservlets.SaleEntry"
<jsp:setProperty
name="entry"
property="itemID"
param="itemID" />
<jsp:setProperty
name="entry"
property="numItems"
param="numItems" /
p />
<jsp:setProperty
name="entry"
property= discountCode
property="discountCode"
param="discountCode" />
26

Case 3: Associating All Properties

with Input Parameters
• Use "*" for the value of the property
attribute
ib off jjsp:setProperty
P to indicate
i di that
h
– Value should come from request parameter whose name
matches property name
– Simple automatic type conversion should be performed

27
 Case 3: Associating All Properties
with Input Parameters
<jsp:useBean id="entry"
class="coreservlets.SaleEntry"
l " l t S l E t " />
<jsp:setProperty name="entry" property="*" />

• This is extremely convenient for making

"form beans" -- objects whose properties
are filled
fill d in
i from
f a form
f submission.
b i i
– You can even divide the process up across multiple
forms, where each submission fills in part of the object.

28

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

29
 Sharing Beans: Example
• page1.jsp
<jsp:useBean
j B id "f " class="…"
id="foo" l " " scope="application"/>
" li i "/
<jsp:setProperty name="foo" property="message"
value="Hello"/>
<jsp:getProperty name="foo" property="message"/>
• page2.jsp
<jsp:useBean
jp id="foo" class="…" scope="application"/>
p pp
<jsp:getProperty name="foo" property="message"/>
• Possible scenario 1
– JJoe goes tto page 2 ((output
t t is
i "Default
"D f lt Message")
M ")
– Jane goes to page 1 (output is "Hello")
• Possible scenario 2
– Joe goes to page 1 (output is "Hello")
– Jane goes to page 2 (output is "Hello")
30

Values of the scope Attribute

• page (<jsp:useBean … scope="page"/> or
<jsp:useBean…>)
j B )
– 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()).
getServletContext())
ServletContext is shared by all servlets in the same Web
application (or all servlets on server if no explicit Web
applications
li i are defined).
d fi d)

31
 Values of the scope Attribute
• session
( j
(<jsp:useBean
B … scope="session"/>)
" i "/ )
– Bean will be stored in the HttpSession object associated
with the current request,
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

32

Sharing Beans in Four Different

Ways
• Using unshared (page-scoped) beans.
• Sharing request-scoped beans.
• Sharing session-scoped beans.
• Sharing application-scoped (i.e.,
ServletContext-scoped) beans.

• Important:
– Use different names (i.e.,
(i e id in jsp:useBean) for different
beans
33 • Don't store beans in different places with same id
 Sharing Beans Four Ways:
Bean Code
package coreservlets;
…
public class BakedBean implements Serializable {
private String level = "half-baked";
private String goesWith = "hot dogs";

public String getLevel() {

return(level);
}
public void setLevel(String newLevel) {
level = newLevel;
}
public String getGoesWith() {
return(goesWith);
}
public void setGoesWith(String dish) {
goesWith = dish;
}
34 }

Sharing Beans Example 1:

Page-Scoped (Unshared)
• Create the bean
– Use jsp:useBean with scope="page" (or no scope at all,
since page is the default).
• Modify the bean
– Use jsp:setProperty with property="*".
– Then,, supply
pp y request
q parameters
p that match the bean
property names.
• Access the bean
– Use jsp:getProperty.

35
 Sharing Beans Example 1:
Page-Scoped (Unshared)
…
<BODY>
<H1>Baked Bean Values: page-based Sharing</H1>
<jsp:useBean id="pageBean"
class="coreservlets BakedBean" />
class="coreservlets.BakedBean"
<jsp:setProperty name="pageBean" property="*" />
<H2>Bean level:
<j
<jsp:getProperty
tP t name="pageBean"
" B "
property="level" />
</H2>
<H2>Dish
2 bean goes with:
<jsp:getProperty name="pageBean"
property="goesWith" />
</H2>
</BODY></HTML>
36

Sharing Beans Example 1:

Result (Initial Request)

37
 Sharing Beans Example 1:
Result (Later Request)

38

Sharing Beans Example 2:

Request-Based Sharing
• Create the bean
– Use
U jjsp:useBean
B with
ith scope="request".
" t"
• Modify the bean
– Use jjsp:setProperty
p p y with property="*".
p p y
– Then, supply request parameters that match the bean
property names.
• Access the bean in the 1st (main) page
– Use jsp:getProperty.
– Then, use jsp:include to invoke the second page.
• Access the bean in the 2nd (included) page
– Use jsp:useBean with the same id as on the first page,
again with scope
scope="request".
request .
– Then, use jsp:getProperty.
39
 Request-Based Sharing:
Code for Main Page
…
<BODY>
<H1>Baked Bean Values: request-based Sharing</H1>
<jsp:useBean id="requestBean"
class="coreservlets
class= coreservlets.BakedBean
BakedBean"
scope="request" />
<jsp:setProperty name="requestBean"
property="*" />
property
<H2>Bean level:
<jsp:getProperty name="requestBean"
property="level"
p ope ty e e /
/></H2>
/
<H2>Dish bean goes with:
<jsp:getProperty name="requestBean"
property="goesWith"
p p y g /
/></H2>
/
<jsp:include page=
"/WEB-INF/includes/BakedBeanDisplay-snippet.jsp"/>
40 </BODY></HTML>

Request-Based Sharing:
Code for Included Page
<H1>Repeated Baked Bean Values:
request-based Sharing</H1>
<jsp:useBean id="requestBean"
class="coreservlets.BakedBean"
scope="request" />
<H2>Bean level:
<jsp:getProperty name="requestBean"
property="level"
t "l l" />
</H2>
<H2>Dish bean goes with:
<jsp:getProperty name="requestBean"
property="goesWith" />
</H2>

41
 Request-Based Sharing:
Result (Initial Request)

42

Request-Based Sharing:
Result (Later Request)

43
 Sharing Beans Example 3:
Session-Based Sharing
• Create the bean
– Use
U jjsp:useBean
B with
i h scope="session".
" i "
• Modify the bean
– Use jjsp:setProperty
p p y with property="*".
p p y
– Then, supply request parameters that match the bean property
names.
• Access the bean in the initial request
– Use jsp:getProperty in the request in which jsp:setProperty is
invoked.
• Access the bean later
– Use jsp:getProperty in a request that does not include request
parameters and thus does not invoke jsp:setProperty. If this request
is from the same client (within the session timeout),
timeout) the previously
modified value is seen. If this request is from a different client (or
after the session timeout), a newly created bean is seen.
44

Session-Based Sharing: Code

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

46

Session-Based Sharing: Result

(Later Request -- Same Client)

47
 Session-Based Sharing: Result
(Later Request -- New Client)

48

Sharing Beans Example 4:

Application-Based Sharing
• Create the bean
– Use
U jjsp:useBean
B with
i h scope="application".
" li i "
• Modify the bean
– Use jjsp:setProperty
p p y with property="*".
p p y
– Then, supply request parameters that match the bean property
names.
• Access the bean in the initial request
– Use jsp:getProperty in the request in which jsp:setProperty is
invoked.
• Access the bean later
– Use jsp:getProperty in a request that does not include request
parameters and thus does not invoke jsp:setProperty. Whether this
request is from the same client or a different client (regardless of the
session timeout), the previously modified value is seen.
49
 Application-Based Sharing:
Code
<BODY>
<H1>Baked Bean Values:
application-based Sharing</H1>
<jsp:useBean id="applicationBean"
class="coreservlets BakedBean"
class="coreservlets.BakedBean"
scope="application" />
<jsp:setProperty name="applicationBean"
property="*"
t "*" />
<H2>Bean level:
<jsp:getProperty name="applicationBean"
property="level" />
/
</H2>
<H2>Dish bean goes with:
<jsp:getProperty name="applicationBean"
property="goesWith"/>
50 </H2></BODY></HTML>

Application-Based Sharing:
Result (Initial Request)

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

52

Application-Based Sharing: Result

(Later Request -- New Client)

53
 Conditional Bean Operations
• 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,
found the preexisting
bean is simply bound to variable referenced by id.
• Bean p
properties
p conditionally
y set
– <jsp:useBean ... />
replaced by
<jsp:useBean ...>statements</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.

54

Conditional Bean Creation:

AccessCountBean
public class AccessCountBean {
private String
p g firstPage;
g
private int accessCount = 1;

public String getFirstPage() {

return(firstPage);
}

public void setFirstPage(String firstPage) {

this firstPage = firstPage;
this.firstPage
}

public int getAccessCount() {

return(accessCount);
t ( C t)
}

public void setAccessCountIncrement(int increment) {

accessCount = accessCount + increment;
}
}
55
 Conditional Bean Creation:
SharedCounts1 jsp
SharedCounts1.jsp
<jsp:useBean id="counter"
class="coreservlets.AccessCountBean"
scope="application">
<jsp:setProperty name="counter"
property="firstPage"
value="SharedCounts1.jsp"
value SharedCounts1.jsp />
</jsp:useBean>
Of SharedCounts1.jsp (this page),
<A HREF="SharedCounts2.jsp">SharedCounts2.jsp</A>, and
<A HREF="SharedCounts3
HREF="SharedCounts3.jsp">SharedCounts3.jsp</A>,
jsp">SharedCounts3 jsp</A>
<jsp:getProperty name="counter" property="firstPage" />
was the first page accessed.
<P>
C ll ti l
Collectively, th
the th
three pages h
have b
been accessed
d
<jsp:getProperty name="counter" property="accessCount" />
times.
<jsp:setProperty name="counter"
property="accessCountIncrement"
value="1" />
56

Accessing SharedCounts1,
SharedCounts2 SharedCounts3
SharedCounts2,
• SharedCounts2.jsp was accessed first.
• Pages have been accessed twelve previous
times by an arbitrary number of clients

57
 Summary
• Benefits of jsp:useBean
– Hides the Java syntax
– Makes it easier to associate request parameters with Java
objects (bean properties)
– Simplifies sharing objects among multiple requests or
servlets/JSPs
• jsp:useBean
j B
– Creates or accesses a bean
• jsp:setProperty
– Sets bean property (i.e. passes value to setXxx)
• You usually
y use p
property="*"
p y to p
pass in request
q params
p
• jsp:getProperty
58
– Puts bean property (i.e. getXxx call) into servlet output

© 2010 Marty Hall

Questions?

Customized Java EE Training: http://courses.coreservlets.com/

Servlets, JSP, JSF 2.0, Struts, Ajax, GWT 2.0, Spring, Hibernate, SOAP & RESTful Web Services, Java 6.
59 Developed and taught by well-known author and developer. At public venues or onsite at your location.