Creating bean instances

To include a bean in a JSP page, you add a special jsp:useBean tag to the page. In its simplest form, this tag looks like this:

<jsp:useBean id="name" class="package.Class" />

The id attribute provides the name that you use elsewhere in the JSP to refer to the bean, and the class attribute provides the name of the class, qualified with the package name. Here’s a jsp:useBean tag to use the Triangle bean:

<jsp:useBean id="triangle"
class="com.lowewriter.calculators.Triangle" />

The jsp:useBean tag creates an instance of the bean by calling the empty constructor if an instance doesn’t already exist. If the bean does already exist, the existing instance is used instead.

Here are a few additional things you should know about the jsp:useBean tag:

• The jsp:useBean tag can appear anywhere in the JSP document, but it must appear before any other tag that refers to the bean.
• This tag and all bean tags are case-sensitive, so be sure to code them exactly as shown. <jsp:usebean…/> won’t work.
• If Tomcat complains that it can’t find your bean when you run the JSP, double-check the package and class name — they’re case-sensitive, too — and make sure that the bean is stored in a directory under WEB-INFclasses that’s named the same as the package. You might store the Triangle bean’s class file in WEB-INFclassescalculators, for example. (For more info on Tomcat, flip to Book 7, Chapter 2.)
• The jsp:useBean element can have a body containing jsp:setProperty tags that initialize property values. Then the element is formed more like normal HTML, with proper start and end tags, as in this example:

  <jsp:useBean id="t1" class="com.lowewriter.calculators.Triangle" >
<jsp:setProperty name="t1" property="sideA" value="3.0" >
<jsp:setProperty name="t1" property="sideB" value="3.0" >
</jsp:useBean>

  Don’t worry about the details of the jsp:setProperty tags just yet. Instead, just make a note that they’re executed only if a new instance of the bean is actually created by the jsp:useBean tag. If an instance of the bean already exists, the jsp:setProperty tags are not executed.

• The jspuseBean tag also has a scope attribute, which I explain in the section “Scoping Your Beans,” later in this chapter.

Getting property values

To get the value of a bean’s property, you use the jsp:getProperty tag. The form of this tag is straightforward:

<jsp:getProperty name="name" property="property" />

Here’s a tag that gets the sideC property from the Triangle bean created in the preceding section:

<jsp:getProperty name="triangle" property="sideC" />

The name attribute must agree with the value you specify in the id attribute of the jsp:useBean tag that created the bean. Also, the property attribute is used to determine the name of the getter method — in this case, getSideC.

Always begin the property name with a lowercase letter. If you specify property="SideC", you get an error message from the server when you run the page.

In most cases, you use jsp:getProperty to insert the value of a property into a page, but you can also use it to specify the value of an attribute for some other tag in the JSP document, as in this example:

<input type="text" name="sideA"
value="<jsp:getProperty name="triangle"
property="sideA" />" >

Here the value of the sideA property is retrieved and used for the value attribute of an input field named sideA. As a result, when this input field is sent to the browser, its initial value is the value from the Triangle bean.

Be extra careful to match up the quotation marks and the open and close brackets for the tags. In this example, the entire jsp:getProperty tag is enclosed within the quotation marks that indicate the value of the input field’s value attribute. The right bracket that appears at the very end closes the input element itself.

Setting property values

To set a property value, you can use one of several variations of the jsp:setProperty tag. If you want to set the property to a literal string, you write the tag like this:

<jsp:setProperty name="triangle"
property="sideA"
value="4.0" />

Here the name attribute must match the id attribute from the jsp:useBean tag that created the bean; the property attribute is used to determine the name of the setter method (in this case, setSideA); and the value attribute provides the value to be set.

I put this tag on three lines only because it’s too long to fit within the margins of this page on one line. In actual practice, most JSP developers string these tags out on a single line unless they get really long, which doesn’t happen often.

Although this form of the jsp:setProperty tag is useful, the param form is more useful. It lets you set the property to the value entered by the user in a form field or passed to the JSP by way of a query string. If your JSP contains a form that has an input field named FirstSide, you can assign that field’s value to the sideA property like this:

<input type="text" name="FirstSide" >
<jsp:setProperty name="triangle"
property="sideA"
param="FirstSide" />

Here, if the user enters a value in the FirstSide field, that value is assigned to the bean’s sideA property.

In the preceding example, I deliberately use a name other than sideA for the input field so that you won’t be confused by the fact that the property and param attributes specify the same value. In actual practice, you usually give the input field the same name as the property it’s associated with, like this:

<input type="text" name="sideA" >
<jsp:setProperty name="triangle"
property="sideA"
param="sideA" />

If your input fields have names that are identical to the property names, you can assign all of them to their corresponding properties with one tag, like this:

<jsp:setProperty name="triangle" property="*" />

Here the asterisk (*) in the property attribute indicates that all properties that have names identical to form fields (or query-string parameters) are assigned automatically. For forms that have a lot of fields, this form of the jsp:setProperty tag can save you a lot of coding.

Viewing a JSP page that uses a bean

So that you can see how these tags work together, Listing 4-2 shows a complete JSP page using the bean that was presented in Listing 4-2. This page displays two text input fields and a button. When the user enters the lengths of a triangle’s two short sides in the fields and clicks the button, the page displays the sideC property of the bean to show the length of the third side. Figure 4-1 shows how this page appears when the code is run.

LISTING 4-2 The Triangle.jsp Page

<html>
<jsp:useBean id="triangle" →2
class="com.lowewriter.calculators.Triangle" />
<jsp:setProperty name="triangle" property="*" /> →4
<head>
<title>Right Triangle Calculator</title>
</head>
<body>
<h1>The Right Triangle Calculator</h1>
<form action="Triangle.jsp" method="post"> →10
Side A:&nbsp;
<input type="text" name="sideA" →12
value="<jsp:getProperty
name="triangle"
property="sideA" />" >
<br><br>
Side B:&nbsp;
<input type="text" name="sideB" →18
value="<jsp:getProperty
name="triangle"
property="sideB" />" >
<br><br>
Side C:&nbsp;
<jsp:getProperty name="triangle" →24
property="sideC" />
<br><br>
<input type="submit" value="Calculate" > →27
</form>
</body>
</html>

The following paragraphs explain the key lines in this JSP:

1. →2 The jsp:useBean tag creates an instance of the calculators.Triangle bean and names it triangle.
2. →4 The jsp:setProperty tag sets the sideA and sideB properties to the corresponding input fields named sideA and sideB.
3. →10 The form tag creates a form that posts back to the same JSP file using the HTTP POST method.
4. →12 This line creates the first of two input text fields. This one is named sideA, and its initial value is set to the value of the bean’s sideA property.
5. →18 The second input text field is named sideB. Its initial value is set to the value of the bean’s sideB property.
6. →24 This line is where the sideC property is retrieved, thus calculating the length of side C of the triangle based on the length of sides A and B. The result is simply inserted into the document.
7. →27 The Submit button submits the form so that the Triangle bean can do its thing.

A shopping cart application

Figure 4-2 shows a simple shopping cart application in which the user has the option to purchase three of my recent books by clicking one of the three buttons. When the user clicks a button, an item is added to the shopping cart. If the user has already added the book to the cart, the quantity is increased by 1. In the figure, the user has clicked the button for Electronics All-in-One For Dummies once and the button for Networking All-in-One For Dummies twice.

The following paragraphs describe the key techniques that make this shopping cart work:

• The shopping cart itself is a JavaBean that has just two public methods: setBook, which adds a book to the shopping cart, and getList, which returns a string that shows the shopping cart items nicely formatted in an HTML table.
• The shopping cart class contains an inner class that represents a Book object. To keep the application simple, the Book class has the three titles hard-coded into it. In a real shopping cart program, you use a file or database instead of hard-coding these values.
• The list of products that appears at the top of the page is actually three separate forms, one for each product. Each of these forms specifies a parameter passed via a query string to the JSP on the server. The name of this parameter is book, and its value is the code of the book the user ordered. This parameter is bound to the book property of the shopping cart bean, so when the user clicks one of the buttons, the setBook method is called with the value passed via the book parameter. That’s how the shopping cart knows which book the user ordered.
• Below the list of books, the JSP uses a jsp:getProperty tag to get the list property, which displays the shopping cart.

The shopping cart page

Listing 4-3 shows the JSP for the shopping cart page.

LISTING 4-3 BuyMyBook.jsp

<html>
<jsp:useBean id="cart" →2
class="com.lowewriter.books.BookCart" scope="session"/>
<jsp:setProperty name="cart" property="*" /> →4
<head>
<title>Buy My Books!</title>
</head>
<body>
<h1>Which of my books do you want to buy?</h1>
<form action="BuyMyBook.jsp?book=elecaio" →10
method="post">
<input type="submit" value="Buy" >&nbsp;&nbsp;
Electronics All-in-One For Dummies<br><br>
</form>
<form action="BuyMyBook.jsp?book=netaio" →15
method="post">
<input type="submit" value="Buy" >&nbsp;&nbsp;
Networking All-in-One Desk Reference
For Dummies
<br><br>
</form>
<form action="BuyMyBook.jsp?book=wordaio" →21
method="post">
<input type="submit" value="Buy" >&nbsp;&nbsp;
Java All-in-One Desk Reference For Dummies
<br><br>
</form>
<br><h2>Your cart contains:</h2>
<jsp:getProperty name="cart" property="list" /> →28
</body>
</html>

The following paragraphs describe the JSP’s most important lines:

1. →2 The jsp:useBean tag loads the com.lowewriter.books.BookCart JavaBean, specifying that it has session scope. Thus, the bean isn’t deleted after each page is requested. Instead, the user works with the same bean instance for his or her entire session.
2. →4 The parameter properties are set. The first time the user displays the BuyMyBook.jsp page, there are no parameters, so this method doesn’t do anything. But when the user clicks one of the three form buttons, a book parameter is added to the end of the URL that’s posted to the server, so the cart’s setBook method is called. This causes one copy of the selected book to be added to the cart.
3. →10 This line is the form for the first book. Each book has its own form, with a Submit button labeled Buy and a book title. The action attribute specifies that when the Submit button is clicked, the form is posted to BuyMyBook.jsp with the book parameter set to netfd.
4. →15 This line is the second book form. This one specifies netaio as the book parameter value.
5. →21 This line is the form for the third book. This one specifies wordaio as the value of the book parameter.
6. →28 After the forms for the books, a jsp:getProperty tag calls the getList method of the bean. This method returns a string containing an HTML table that displays the current contents of the shopping cart.

The BookCart JavaBean

Now that you’ve seen the JSP for the shopping cart application, take a look at the Java code for the BookCart bean, shown in Listing 4-4.

Listing 4-4 contains two classes: a BookCart class and an inner class named Book. So when you compile the code in Listing 4-4, you get two class files: BookCart.class and BookCart$Book.class. To run this application, you have to copy both class files to a Tomcat directory (a WEB-INFclassesooks directory).

LISTING 4-4 The BookCart JavaBean

package com.lowewriter.books; →1
import java.util.ArrayList;
import java.text.NumberFormat;
public class BookCart
{
private ArrayList<Book> cart; →8
private NumberFormat cf
= NumberFormat.getCurrencyInstance();
public BookCart() →13
{
cart = new ArrayList<Book>();
}
public void setBook(String code) →18
{
boolean found = false;
for (Book b : cart)
if (b.getCode().equals(code))
{
b.addQuantity(1);
found = true;
}
if (!found)
cart.add(new Book(code));
}
public String getList() →31
{
String list = "<table border=2>";
list +="<tr><td>Title</td><td>Qty</td>"
+ "<td>Price</td><td>Total</td></tr>";
double total = 0.0;
for (Book b : cart)
{
list += "<tr><td>"
+ b.getTitle() + "</td>"
+ "<td>" + b.getQuantity() + "</td>"
+ "<td>" + cf.format(b.getPrice())
+ "</td>"
+ "<td>" + cf.format(b.getTotal())
+ "</td>"
+ "</tr>";
total += b.getTotal();
}
list +="<tr><td></td><td></td><td>Total:</td>"
+ "<td>" + cf.format(total)
+ "</td></tr>";
list += "</table>";
return list;
}
private class Book →52
{
private String code; →54
private int quantity;
public Book(String code) →57
{
this.code = code;
this.quantity = 1;
}
public String getCode() →63
{
return this.code;
}
public String getTitle() →68
{
if (code.equals("elecaio"))
return "Electronics All-in-One For Dummies";
else if (code.equals("netaio"))
return "Networking All-in-One For Dummies";
else if (code.equals("javaaio"))
return "Java All-in-One For Dummies";
else
return "Unknown book";
}
public double getPrice() →82
{
if (code.equals("elecaio"))
return 34.99;
else if (code.equals("netaio"))
return 22.99;
else if (code.equals("javaaio"))
return 29.99;
else
return 0.0;
}
public int getQuantity() →94
{
return this.quantity;
}
public void addQuantity(int qty) →99
{
this.quantity += qty;
}
public double getTotal() →104
{
return this.quantity * this.getPrice();
}
}
}

The following paragraphs describe the bean’s high points:

1. →1 The BookCart class lives in the books package.
2. →8 The shopping cart itself is kept inside the BookCart bean as a private array list of Book items.
3. →13 To be a JavaBean, you need a no-parameter constructor. This one simply initializes the cart array list.
4. →18 The setBook method is called to add a book to the shopping cart. The book’s code is passed as a parameter. This method first looks at all the books in the array list to see whether the user has already added a book with this code. If so, that book’s addQuantity method is called to increase the order quantity for that book by 1. If not, a new book with the specified code is created and added to the cart.

5. →31 This method builds a string that contains all the books in the cart presented as an HTML table. If you’re not familiar with HTML tables, all you really need to know is that the <tr> and </tr> tags mark the start and end of each row, and the <td> and </td> tags mark the start and end of each cell within the row. The table includes one row for each book in the cart. Each row contains cells for the title, quantity, price, and total. If you compare the code in this method with the actual table shown in Figure 4-2, you can get an idea of the HTML that’s actually created by this method.

   Notice also that the loop that builds each table row keeps a running total for the entire shopping cart, which is displayed in a separate row at the bottom of the table. Also, a row of headings is displayed at the start of the table.

6. →52 The Book class is defined as an inner class so that it can represent books in the array list.
7. →54 The Book class stores only two items of information for each book: the book code and the quantity. The latter represents the number of books ordered by the user. The other values are calculated by the methods that return them.
8. →57 The constructor accepts a book code and initializes the instance fields. Notice that the quantity is initialized to 1.
9. →63 The getCode method simply returns the code variable.
10. →68 The getTitle method returns one of three book titles, depending on the code. If the code is not one of the three predefined codes, Unknown book is returned.
11. →82 Likewise, the getPrice method returns one of three prices, depending on the code. If the code is not one of the three allowable codes, the book is free!
12. →94 The getQuantity method just returns the quantity variable.
13. →99 The addQuantity method adds a value to the quantity variable.
14. →104 The getTotal method calculates the total by multiplying the price by the quantity.