AJavaBean is a special type of Java class that you can use in several interesting ways to simplify program development. Some beans, such as Swing components, are designed to be visual components that you can use in a GUI editor to quickly build user interfaces. Other beans, known as Enterprise JavaBeans, are designed to run on special EJB servers and can run the data access and business logic for large Web applications.

In this chapter, I look at a more modest type of JavaBean that's designed to simplify the task of building Java Server Pages. In a nutshell, you can use the simple JavaBeans to build Java Server Pages without writing any Java code in the JSP itself. JavaBeans let you access Java classes by using special HTML-like tags in the JSP page.

What Is a JavaBean?

Simply put, a JavaBean is any Java class that conforms to the following rules:

• It must have an empty constructor. That is, a constructor that accepts no parameters. If the class doesn't have any constructors at all, it qualifies because the default constructor has no parameters. But if the class has at least one constructor that accepts one or more parameters, it must also have a constructor that has no parameters to qualify as a JavaBean.
• It must have no public instance variables. All the instance variables defined by the class must be either private or protected.
• It must provide methods named get Property and set Property to get and set the value of any properties the class provides, except for boolean properties that use is Property to get the property value. The term property isn't really an official Java term. In a nutshell (or should that be, in a beanpod?), a property is any value of an object that-can be retrieved by a get method (or an is method if the property is boolean) or set with a set method. For example, if a class has a property named lastName, it should use a method named getLastName to get the last name and setLastName to set the last name. Or, if the class has a boolean property named taxable, the method to set it is called setTaxable, and the method to retrieve it is isTaxable.

  Note that a class doesn't have to have any properties to be a JavaBean, but if it does, the properties have to be accessed according to this naming pattern. Also, not all properties must have both a get and a set accessor. A read-only property can have just a get accessor, and a write-only property can have just a set accessor.

  REMEMBER

  The property name is capitalized in the methods that access it, but the property name itself isn't. Thus setAddress sets a property named address, not Address.

That's all there is to it. More advanced beans can also have other characteristics that allow them to have a visual interface so they can be used drag-and-drop style in an IDE. And some beans implement an interface that allows their state to be written to an output stream so they can be re-created later. But those features are optional; any class that meets the three criteria stated here is a bean and can be used as a bean in JSP pages.

You've already seen plenty of classes that have methods with names like getCount and setStatus. These names are part of a design pattern called the Accessor pattern, which is covered in Book III, Chapter 2. Thus you've seen many examples of beans throughout this book, and you've probably written many bean classes yourself already.

Looking Over a Sample Bean

Listing 4-1 shows a sample JavaBean class named Triangle that calculates the Pythagorean Theorem, which calculates the long side of a right triangle if you know the length of the two short sides. This class defines three properties: sideA and sideB represent the two short sides of the triangle, and sideC represents the long side. The normal way to use this bean is to first use the setSideA and setSideB methods to set the sideA and sideB properties to the lengths of the short sides, and then use the getSideC method to get the length of the long side.

Listing 4-1: The Triangle Bean

package calculators; → 1 public class Triangle { private double sideA; → 5 private double sideB; public Triangle() → 8 { this.sideA = 0.0; this.sideB = 0.0; } public String getSideA() → 14 { return Double.toString(this.sideA); } public void setSideA(String value) → 19 { try { this.sideA = Double.parseDouble(value); } catch (Exception e) { this.sideA = 0.0; } } public String getSideB() → 31 { return Double.toString(this.sideB); } public void setSideB(String value) → 36 { try { this.sideB = Double.parseDouble(value); } catch (Exception e) { this.sideB = 0.0; } } public String getSideC() → 48 { if (sideA == 0.0 || sideB == 0.0) return "Please enter both sides."; else { Double sideC; sideC = Math.sqrt( (sideA * sideA) + (sideB * sideB)); return Double.toString(sideC); } } }

The following paragraphs point out the highlights of this bean class:

Open table as spreadsheet

Using Beans with JSP Pages

To work with a bean in a JSP page, you add special tags to the page to create the bean, set its properties, and retrieve its properties. Table 4-1 lists these tags, and the following sections describe the details of using each one.

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:

name" emphasis">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. For example, here's a jsp:useBean tag to use the Triangle bean:

The jsp:useBean tag creates an instance of the bean by calling the empty constructor if an instance doesn't already exist. However, if the bean already exists, 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 and all bean tags are case-sensitive, so be sure to code them exactly as shown. 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 the bean is stored in a directory under WEB-INFclasses that's named the same as the package. For example, store the Triangle bean's class file in WEB-INFclassescalculators.
• The jsp:useBean element can have a body that contains jsp: setProperty tags that initialize property values. Then the element is formed more like normal HTML, with proper start and end tags. For example:

   

  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 later in this chapter, in the section "Scoping Your Beans."

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:

For example, here's a tag that gets the sideC property from the Triangle bean created in the previous section:

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

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

" >

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.

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:

Here the name attribute must match up to 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.

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 into a form field or passed to the JSP by way of a query string. For example, 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:

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

In the previous example, I purposely used a name other than sideA for the input field so you wouldn'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:

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:

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

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 that uses the bean that was presented in Listing 4-1. 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 it is run.

Figure 4-1: The Triangle. jsp page displayed in a browser.

Listing 4-2: The Triangle.jsp Page

→ 2 /> → 4Right Triangle Calculator

The Right Triangle Calculator

→ 10 Side A:  → 12 value="" >

Side B:  → 18 value="" >

Side C:  → 24 property="sideC" />

→ 27

The following paragraphs explain the key lines in this JSP:

Open table as spreadsheet

Scoping Your Beans

The scope of a JavaBean indicates how long the bean is kept alive. You specify the scope by using the scope attribute on the jsp:useBean tag. The scope attribute can have any of the four values listed in Table 4-2.

The default scope is page, which means that the bean is created and destroyed each time the user requests a new page. However, session scope can be very useful for Web applications that need to keep track of information about a user from one page to the next. The best-known example of that is a shopping cart, in which a user can select items he or she wants to purchase. The contents of the shopping cart can be kept in a session bean.

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 one. In the figure, the user has clicked the button for Networking All-in-One Desk Reference For Dummies twice and Networking For Dummies once.

Figure 4-2: A super-simple shopping cart application.

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.
• Beneath 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

→ 2 scope="session"/> → 4Buy My Books!

Which of my books do you want to buy?

→ 10 method="post">    Networking For Dummies

→ 15 method="post">    Networking All-in-One Desk Reference For Dummies

→ 21 method="post">    Word 2003 All-In-One Desk Reference For Dummies

Your cart contains:

→ 28

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

Open table as spreadsheet

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. It's shown in Listing 4-4.

Listing 4-4: The BookCart JavaBean

package books; → 1 import java.util.ArrayList; import java.text.NumberFormat; public class BookCart { private ArrayList cart; → 8 private NumberFormat cf = NumberFormat.getCurrencyInstance(); public BookCart() → 13 { cart = new ArrayList(); } 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 = ""; list +="" + ""; double total = 0.0; for (Book b : cart) { list += "" + "" + "" + "" + ""; total += b.getTotal(); } list +="" + ""; list += "

"; 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("netfd")) return "Networking For Dummies"; else if (code.equals("netaio")) return "Networking All-in-One Desk " + "Reference For Dummies"; else if (code.equals("wordaio")) return "Word 2003 All-in-One Desk " + "Reference For Dummies"; else return "Unknown book"; } public double getPrice() → 82 { if (code.equals("netfd")) return 24.99; else if (code.equals("netaio")) return 34.99; else if (code.equals("wordaio")) 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:

and tags mark the start and end of each row, and the 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.

Open table as spreadsheet