Download PDF Home History |  | API Search Feedback FAQ

> ## JavaBeans Components

> JavaBeans components are Java classes that can be easily reused and composed together into applications. Any Java class that follows certain design conventions is a JavaBeans component.

> JavaServer Pages technology directly supports using JavaBeans components with standard JSP language elements. You can easily create and initialize beans and get and set the values of their properties.

> ### JavaBeans Component Design Conventions

> JavaBeans component design conventions govern the properties of the class and govern the public methods that give access to the properties.

> A JavaBeans component property can be

> - Read/write, read-only, or write-only
> - Simple, which means it contains a single value, or indexed, which means it represents an array of values

> A property does not have to be implemented by an instance variable. It must simply be accessible using public methods that conform to the following conventions:

> - For each readable property, the bean must have a method of the form

>       PropertyClass getProperty() { ... }

> - For each writable property, the bean must have a method of the form

>       setProperty(PropertyClass pc) { ... }

> In addition to the property methods, a JavaBeans component must define a constructor that takes no parameters.

> The Duke's Bookstore application JSP pages `bookstore.jsp`, `bookdetails.jsp`, `catalog.jsp`, and `showcart.jsp` use the `database.BookDB` and `database.BookDetails` JavaBeans components. `BookDB` provides a JavaBeans component front end to the access object `database.BookDBAO`. The JSP pages `showcart.jsp` and `cashier.jsp` access the bean `cart.ShoppingCart`, which represents a user's shopping cart.

> The `BookDB` bean has two writable properties, `bookId` and `database`, and three readable properties: `bookDetails`, `numberOfBooks`, and `books`. These latter properties do not correspond to any instance variables but rather are a function of the `bookId` and `database` properties.

>     package database;
>     public class BookDB {
>       private String bookId = "0";
>       private BookDBAO database = null;
>       public BookDB () {
>       }
>       public void setBookId(String bookId) {
>       this.bookId = bookId;
>       }
>       public void setDatabase(BookDBAO database) {
>       this.database = database;
>       }
>       public BookDetails getBookDetails() throws
>         BookNotFoundException {
>         return (BookDetails)database.getBookDetails(bookId);
>       }
>       public List getBooks() throws BooksNotFoundException {
>         return database.getBooks();
>       }
>       public void buyBooks(ShoppingCart cart)
>         throws OrderException {
>         database.buyBooks(cart);
>       }
>       public int getNumberOfBooks() throws BooksNotFoundException {
>         return database.getNumberOfBooks();
>       }
>     }

> ### Creating and Using a JavaBeans Component

> To declare that your JSP page will use a JavaBeans component, you use a `jsp:useBean` element. There are two forms:

>     <jsp:useBean id="beanName"
>       class="fully_qualified_classname" scope="scope"/>

> and

>     <jsp:useBean id="beanName"
>       class="fully_qualified_classname" scope="scope">
>       <jsp:setProperty .../>
>     </jsp:useBean>

> The second form is used when you want to include `jsp:setProperty` statements, described in the next section, for initializing bean properties.

> The `jsp:useBean` element declares that the page will use a bean that is stored within and is accessible from the specified scope, which can be `application`, `session`, `request`, or `page`. If no such bean exists, the statement creates the bean and stores it as an attribute of the scope object (see Using Scope Objects). The value of the `id` attribute determines the name of the bean in the scope and the identifier used to reference the bean in EL expressions, other JSP elements, and scripting expressions (see Chapter 16). The value supplied for the `class` attribute must be a fully qualified class name. Note that beans cannot be in the unnamed package. Thus the format of the value must be `package_name.class_name`.

> The following element creates an instance of `mypkg.myLocales` if none exists, stores it as an attribute of the application scope, and makes the bean available throughout the application by the identifier `locales`:

>     <jsp:useBean id="locales" scope="application"
>       class="mypkg.MyLocales"/>

> ### Setting JavaBeans Component Properties

> The standard way to set JavaBeans component properties in a JSP page is by using the `jsp:setProperty` element. The syntax of the `jsp:setProperty` element depends on the source of the property value. Table 12-3 summarizes the various ways to set a property of a JavaBeans component using the `jsp:setProperty` element.

> Table 12-3 Valid Bean Property Assignments from String Values
> Value Source | Element Syntax
> --- | ---
> String constant | `<jsp:setProperty name="``beanName``"` `property="``propName``" value="``string constant``"/>`
> Request parameter | `<jsp:setProperty name="``beanName``"` `property="``propName``" param="``paramName``"/>`
> Request parameter name that matches bean property | `<jsp:setProperty name="``beanName``"` `property="``propName``"/>` `<jsp:setProperty name="``beanName``"` `property="*"/>`
> Expression | `<jsp:setProperty name="``beanName``"` `property="``propName``" value="``expression``"/>` `<jsp:setProperty name="``beanName``"` `property="``propName``" >` `<jsp:attribute name="`value`">` `expression` `</jsp:attribute>` `</jsp:setProperty>`
> | 1. `beanName` must be the same as that specified for the `id` attribute in a `useBean` element. 2. There must be a `setPropName``` method in the JavaBeans component. 3. `paramName` must be a request parameter name.

> A property set from a constant string or request parameter must have one of the types listed in Table 12-4. Because constants and request parameters are strings, the Web container automatically converts the value to the property's type; the conversion applied is shown in the table.

> `String` values can be used to assign values to a property that has a `PropertyEditor` class. When that is the case, the `setAsText(String)` method is used. A conversion failure arises if the method throws an `IllegalArgumentException`.

> The value assigned to an indexed property must be an array, and the rules just described apply to the elements.

> Table 12-4 Valid Property Value Assignments from String Values
> Property Type | Conversion on String Value
> --- | ---
> Bean Property | Uses`setAsText(``string-literal``)`
> `boolean` or `Boolean` | As indicated in `java.lang.Boolean.valueOf(String)`
> `byte` or `Byte` | As indicated in `java.lang.Byte.valueOf(String)`
> `char` or `Character` | As indicated in `java.lang.String.charAt(0)`
> `double` or `Double` | As indicated in `java.lang.Double.valueOf(String)`
> `int` or `Integer` | As indicated in `java.lang.Integer.valueOf(String)`
> `float` or `Float` | As indicated in `java.lang.Float.valueOf(String)`
> `long` or `Long` | As indicated in `java.lang.Long.valueOf(String)`
> `short` or `Short` | As indicated in `java.lang.Short.valueOf(String)`
> `Object` | new `String(``string-literal``)`

> You use an expression to set the value of a property whose type is a compound Java programming language type. The type returned from an expression must match or be castable to the type of the property.

> The Duke's Bookstore application demonstrates how to use the `setProperty` element to set the current book from a request parameter in the database bean in `bookstore2/web/bookdetails.jsp`:

>     <c:set var="bid" value="${param.bookId}"/>
>     <jsp:setProperty name="bookDB" property="bookId"
>       value="${bid}" />

> The following fragment from the page `bookstore2/web/bookshowcart.jsp` illustrates how to initialize a `BookDB` bean with a `database` object. Because the initialization is nested in a `useBean` element, it is executed only when the bean is created.

>     <jsp:useBean id="bookDB" class="database.BookDB" scope="page">
>       <jsp:setProperty name="bookDB" property="database"
>         value="${bookDBAO}" />
>     </jsp:useBean>

> ### Retrieving JavaBeans Component Properties

> The main way to retrieve JavaBeans component properties is by using the JSP EL expressions. Thus, to retrieve a book title, the Duke's Bookstore application uses the following expression:

>     ${bookDB.bookDetails.title}

> Another way to retrieve component properties is to use the `jsp:getProperty` element. This element converts the value of the property into a `String` and inserts the value into the response stream:

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

> Note that `beanName` must be the same as that specified for the `id` attribute in a `useBean` element, and there must be a `get` `PropName` method in the JavaBeans component. Although the preferred approach to getting properties is to use an EL expression, the `getProperty` element is available if you need to disable expression evaluation.

Download PDF Home History |  | API Search Feedback FAQ

All of the material in The J2EE(TM) 1.4 Tutorial is copyright-protected and may not be published in other works without express written permission from Sun Microsystems.