Download PDF Home History |  | API Search Feedback FAQ

> ## The Example JSP Pages

> To illustrate JSP technology, this chapter rewrites each servlet in the Duke's Bookstore application introduced in The Example Servlets as a JSP page (see Table 12-1).

> Table 12-1 Duke's Bookstore Example JSP Pages
> Function | JSP Pages
> --- | ---
> Enter the bookstore. | `bookstore.jsp`
> Create the bookstore banner. | `banner.jsp`
> Browse the books offered for sale. | `bookcatalog.jsp`
> Add a book to the shopping cart. | `bookcatalog.jsp` and `bookdetails.jsp`
> Get detailed information on a specific book. | `bookdetails.jsp`
> Display the shopping cart. | `bookshowcart.jsp`
> Remove one or more books from the shopping cart. | `bookshowcart.jsp`
> Buy the books in the shopping cart. | `bookcashier.jsp`
> Receive an acknowledgment for the purchase. | `bookreceipt.jsp`

> The data for the bookstore application is still maintained in a database and is accessed through `database.BookDBAO`. However, the JSP pages access `BookDBAO` through the JavaBeans component `database.BookDB`. This class allows the JSP pages to use JSP elements designed to work with JavaBeans components (see JavaBeans Component Design Conventions).

> The implementation of the database bean follows. The bean has two instance variables: the current book and the data access object.

>     package database;
>     public class BookDB {
>       private String bookId = "0";
>       private BookDBAO database = null;

>       public BookDB () throws Exception {
>       }
>       public void setBookId(String bookId) {
>         this.bookId = bookId;
>       }
>       public void setDatabase(BookDAO database) {
>         this.database = database;
>       }
>       public BookDetails getBookDetails()
>         throws Exception {
>         return (BookDetails)database.getBookDetails(bookId);
>       }
>       ...
>     }

> This version of the Duke's Bookstore application is organized along the Model-View-Controller (MVC) architecture. The MVC architecture is a widely used architectural approach for interactive applications that distributes functionality among application objects so as to minimize the degree of coupling between the objects. To achieve this, it divides applications into three layers: model, view, and controller. Each layer handles specific tasks and has responsibilities to the other layers:

> - The model represents business data, along with business logic or operations that govern access and modification of this business data. The model notifies views when it changes and lets the view query the model about its state. It also lets the controller access application functionality encapsulated by the model. In the Duke's Bookstore application, the shopping cart and database access object contain the business logic for the application.
> - The view renders the contents of a model. It gets data from the model and specifies how that data should be presented. It updates data presentation when the model changes. A view also forwards user input to a controller. The Duke's Bookstore JSP pages format the data stored in the session-scoped shopping cart and the page-scoped database bean.
> - The controller defines application behavior. It dispatches user requests and selects views for presentation. It interprets user inputs and maps them into actions to be performed by the model. In a Web application, user inputs are HTTP `GET` and `POST` requests. A controller selects the next view to display based on the user interactions and the outcome of the model operations. In the Duke's Bookstore application, the `Dispatcher` servlet is the controller. It examines the request URL, creates and initializes a session-scoped JavaBeans component--the shopping cart--and dispatches requests to view JSP pages.

> Note: When employed in a Web application, the MVC architecture is often referred to as a Model-2 architecture. The bookstore example discussed in Chapter 11, which intermixes presentation and business logic, follows what is known as a Model-1 architecture. The Model-2 architecture is the recommended approach to designing Web applications.

> In addition, this version of the application uses several custom tags from the JavaServer Pages Standard Tag Library (JSTL), described in Chapter 14:

> - `c:if`, `c:choose`, `c:when`, and `c:otherwise` for flow control
> - `c:set` for setting scoped variables
> - `c:url` for encoding URLs
> - `fmt:message`, `fmt:formatNumber`, and `fmt:formatDate` for providing locale-sensitive messages, numbers, and dates

> Custom tags are the preferred mechanism for performing a wide variety of dynamic processing tasks, including accessing databases, using enterprise services such as email and directories, and implementing flow control. In earlier versions of JSP technology, such tasks were performed with JavaBeans components in conjunction with scripting elements (discussed in Chapter 16). Although still available in JSP 2.0 technology, scripting elements tend to make JSP pages more difficult to maintain because they mix presentation and logic, something that is discouraged in page design. Custom tags are introduced in Using Custom Tags and described in detail in Chapter 15.

> Finally, this version of the example contains an applet to generate a dynamic digital clock in the banner. See Including an Applet for a description of the JSP element that generates HTML for downloading the applet.

> The source code for the application is located in the `<``INSTALL``>/j2eetutorial14/examples/web/bookstore2/` directory (see Building the Examples). A sample `bookstore2.war` is provided in `<``INSTALL``>/j2eetutorial14/examples/web/provided-wars/`. To build the example, follow these steps:

> 1. Build and package the bookstore common files as described in Duke's Bookstore Examples.
> 2. In a terminal window, go to `<``INSTALL``>/j2eetutorial14/examples/web/bookstore2/`.
> 3. Run `asant` `build`. This target will spawn any necessary compilations and will copy files to the `<``INSTALL``>/j2eetutorial14/examples/web/bookstore2/build/` directory.
> 4. Start the Application Server.
> 5. Perform all the operations described in Accessing Databases from Web Applications.

> To package and deploy the example using `asant`, follow these steps:

> 1. Run `asant` `create-bookstore-war`.
> 2. Run `asant` `deploy-war`.

> To learn how to configure the example, use `deploytool` to package and deploy it:

> 1. Start `deploytool`.
> 2. Create a Web application called `bookstore2` by running the New Web Component wizard. Select FileNewWeb Component.
> 3. In the New Web Component wizard:
> 1. Select the Create New Stand-Alone WAR Module radio button.
> 2. Click Browse.
> 3. In the WAR Location field, enter `<``INSTALL``>/j2eetutorial14/examples/web/bookstore2/bookstore2.war`.
> 4. In the WAR Name field, enter `bookstore2`.
> 5. In the Context Root field, enter `/bookstore2`.
> 6. Click Edit Contents.
> 7. In the Edit Contents dialog box, navigate to `<``INSTALL``>/j2eetutorial14/examples/web/bookstore2/build/`. Select the JSP pages `bookstore.jsp`, `bookdetails.jsp`, `bookcatalog.jsp`, `bookshowcart.jsp`, `bookcashier.jsp`, `bookordererror.jsp`, `bookreceipt.jsp`, `duke.books.gif`,`` and the `clock`, `dispatcher`, `database`, `listeners`, and `template` directories and click Add.
> 8. Move `/WEB-INF/classes/clock/` to the root directory of the WAR. By default, `deploytool` packages all classes in `/WEB-INF/classes/`. Because `clock/DigitalClock.class` is a client-side class, it must be packaged in the root directory. To do this, simply drag the `clock` directory from `/WEB-INF/classes/` to the root directory in the pane labeled Contents of `bookstore2`.
> 9. Add the shared bookstore library. Navigate to`<``INSTALL``>/j2eetutorial14/examples/web/bookstore/dist/`. Select `bookstore.jar`, and click Add.
> 10. Click OK.
> 11. Click Next.
> 12. Select the Servlet radio button.
> 13. Click Next.
> 14. Select `dispatcher.Dispatcher` from the Servlet class combo box.
> 15. Click Finish.
> 4. Add the listener class `listeners.ContextListener` (described in Handling Servlet Life-Cycle Events).
> 1. Select the Event Listeners tab.
> 2. Click Add.
> 3. Select the `listeners.ContextListener` class from drop-down field in the Event Listener Classes pane.
> 5. Add the aliases.
> 1. Select the `Dispatcher` Web component.
> 2. Select the Aliases tab.
> 3. Click Add and then type `/bookstore` in the `Aliases` field. Repeat to add the aliases `/bookcatalog`, `/bookdetails`, `/bookshowcart`, `/bookcashier`, `/bookordererror,` and `/bookreceipt`.
> 6. Add the context parameter that specifies the JSTL resource bundle base name.
> 1. Select the Web module.
> 2. Select the Context tab.
> 3. Click Add.
> 4. Enter `javax.servlet.jsp.jstl.fmt.localizationContext` in the Coded Parameter field.
> 5. Enter `messages.BookstoreMessages` in the Value field.
> 7. Set the prelude and coda for all JSP pages.
> 1. Select the JSP Properties tab.
> 2. Click the Add button next to the Name list.
> 3. Enter `bookstore2`.
> 4. Click the Add URL button.
> 5. Enter `*.jsp`.
> 6. Click the Edit Preludes button.
> 7. Click Add.
> 8. Enter `/template/prelude.jspf`.
> 9. Click OK.
> 10. Click the Edit Codas button.
> 11. Click Add.
> 12. Enter `/template/coda.jspf`.
> 13. Click OK.
> 8. Add a resource reference for the database.
> 1. Select the Resource Ref's tab.
> 2. Click Add.
> 3. Enter `jdbc/BookDB` in the Coded Name field.
> 4. Accept the default type `javax.sql.DataSource`.
> 5. Accept the default authorization `Container`.
> 6. Accept the default selected `Shareable`.
> 7. Enter `jdbc/BookDB` in the JNDI name field of the Sun-specific Settings frame.
> 9. Select FileSave.
> 10. Deploy the application.
> 1. Select ToolsDeploy.
> 2. Click OK.

> To run the application, open the bookstore URL `http://localhost:8080/bookstore2/bookstore`. Click on the Start Shopping link and you will see the screen in Figure 12-2.

> Figure 12-2 Book Catalog

> See Troubleshooting for help with diagnosing common problems related to the database server. If the messages in your pages appear as strings of the form `???` `Key``???`, the likely cause is that you have not provided the correct resource bundle base name as a context parameter.

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.