Making your code modular means separating it into units of code that provide distinct functionality with little or no overlap between modules. Separating your code into distinct modules means that if changes need to be made to one area of functionality in your application, they can be made with little or no impact on other areas of your application.

In a storefront, one of the functions used frequently is calculating shipping for an order. Shipping costs are typically based on the carrier used, the location of the purchaser, and the type of delivery desired.

One way to approach calculating shipping is to have the shopping cart code tally the shipping costs along the way. The cart knows what products are being shipped and has information about the user, so it should be able to use that information to calculate shipping. However, this approach isn't modular because the shopping cart code now contains code for two unrelated functions: storing products from a user's shopping session and managing shipping information. If, in the future, the store switches to another shipping company, the shopping cart code would need to be updated to accommodate this change. Thus, the chances that some of the shopping cart functionality is inadvertently changed and bugs are introduced into your application increase.

A better approach would be to separate the shipping code into its own module. The shopping cart code would provide the shipping module information about the products being shipped and the customer's address, and the shipping module would return shipping costs for the various delivery types offered. Now, if the store were to change shipping companies, the shopping cart code wouldn't need to change. Instead, the shipping code would change, and the shopping cart code could continue to use it as though nothing had changed.

One of the most important development practices, especially for those building large or complex applications, is to write code that's reusable across many areas of an application or even across different applications.

Consider this example: The application you build in this chapter is a storefront, which allows customers to view products, add them to a shopping cart, and purchase them. The data about the products is stored in a database. Suppose that this store is just one of many owned by a parent company. Each store has its own database, and a scheduled nightly job collects data about the products and sales for each day into a data warehouse so that the sales and marketing departments at the parent company can determine which products are selling well, which prices may need to be adjusted, etc.

The sales department might ask you to build a Web application to help it visualize and work with the data in the data warehouse. Many of the operations and objects, such as lists of products and contents of shopping carts, used by the storefront are relevant to the data the sales department would want to analyze. By writing these modules of code in a way that's reusable, you can create a set of objects that's useable in both the storefront and the data warehouse applications.

Part of the process of writing modular code, and one way to write reusable code, is to separate the interface from the implementation. In simple terms, the interface is what something does, and the implementation is how it does that something. The interface defines what methods are available, what parameters they require, and what values they return. It's the contract between code that calls into your application and the implementation code within your application. Code that calls into the application rarely cares about how something is done; it just wants to receive some value based on parameters it provides.

The code that talks to the database when writing the storefront has an interface that defines methods to obtain a list of products, see details of a specific product, and retrieve a user's shopping cart. The implementation contains code that performs these functions. In the previous example, if the store front application had been written without interfaces, much of it would not be reusable. The service code that requests information from the database access module would need to be changed to request information from a different module that works with the data warehouse instead of the store database. By using interfaces, the service would just be calling a function on the interface, and the code would work the same way for both the store application and the data warehouse. When deploying the data warehouse application, you would only need to swap out the implementation of the database access code with the correct version for the data warehouse. Application code dealing with the interface wouldn't need to change.

The MySQL database consists of four tables, one for each of the value objects in the application. These tables are related to one another through foreign key relationships. The cart table contains a user_id field that maps to the user table so that each cart is owned by a user. The cart_item table contains a product_id field that maps to the product table and a cart_id field that maps to the cart table.

To create the MySQL database and the product table for the storefront application, follow these steps:

Figure 12.3. The MySQL Table Editor dialog box is where the tables for the application are created.

Figure 12.4. Once you type id as the name of the first column and press the Tab key, the rest of the columns in this row of the Columns and Indices tab are populated with appropriate default values, and the column is set as the primary key of the table.

Figure 12.5. The MySQL Table Editor dialog box should look like this once all the columns have been added to the product table.

You can see the newly created table by clicking the arrow next to the store database to expand it in the Schemata tab. Clicking the arrow next to the product table expands it to display the set of columns that make up the table.

Figure 12.6. The Confirm Table Edit dialog box shows the SQL statement that's used to create the product table.

Now create the user table by following these steps:

Figure 12.7. The MySQL Table Editor dialog box should look like this once all the columns have been added to the user table.

Next is the cart table. A couple of extra steps are required for this table to create the foreign key from the cart table to the user table. Follow these steps to create the cart table:

Finally, the cart_item table contains foreign keys to both the cart table and the product table. Follow these steps to create the cart_item table:

Figure 12.9. After the columns have been added and the foreign keys to the cart and product tables have been created, the MySQL Table Editor dialog box should look like this.

The database is now ready to be used by the application, but it won't be of much use without any data in it. You can use the MySQL Query Browser tool to write a SQL script to add some data to the database. Choose File

INSERT INTO store.USER(first_name, last_name, user_name, password)
VALUES('Charles','Christiansen','charles','selrahc'),

INSERT INTO store.USER(first_name, last_name, user_name, password)
VALUES('Matthew','Keefe','matthew','wehttam'),

INSERT INTO store.PRODUCT(name, description, category, price)

VALUES('Plasma Television','65 inch screen with
   1080p','electronics',3000.00);

INSERT INTO store.PRODUCT(name, description, category, price)
VALUES('Surround Sound Stereo','7.1 surround sound receiver with
   wireless speakers','electronics',1000.00);

INSERT INTO store.PRODUCT(name, description, category, price)
VALUES('Refrigerator','Bottom drawer freezer with water and ice on
   the door','appliances',1200.00);

INSERT INTO store.PRODUCT(name, description, category, price)
VALUES('Dishwasher','Large capacity with water saver
   setting','appliances',500.00);

INSERT INTO store.PRODUCT(name, description, category, price)
VALUES('Leather Sectional','Plush leather with room for 6
   people','furniture',1500.00);

Click the green Execute button in the top-right corner of the MySQL Query Browser. The script runs, and the sample data is added to the database. No sample data is added to the cart or cart_item tables. These tables don't need sample data because they're populated by adding items to the cart by using the application. You can verify that the data was inserted by clicking the X on the Script tab to close it and then dragging the user and product tables onto the Resultset tab. Dragging these tables onto the Resultset tab displays all the data in the table, as shown for the product table in Figure 12.10.

Figure 12.10. Dragging the product table onto the Resultset tab displays all the data in the table. You can see that all the sample data from your SQL script has been added.

Before starting to develop the application, you need to set up a new project in Eclipse that contains the code, configuration files, and build scripts for the Web application. The project contains the standard folder structure for a Java Web application. After creating the project, you must add all the libraries that the project depends on to compile and run. These libraries are:

Finally, once the libraries have been added to the project, you must configure the project's build path to use some of those libraries when compiling the code for the project.

Open Eclipse, and create a new Spring project. When entering the project properties in the New Spring Project dialog box, change the output folder for the project to web/WEB-INF/classes. When you change the output directory to web/WEB-INF/classes, Eclipse outputs the compiled Java class files to that directory. This directory is where Web applications typically look for the Java files they need to run. When the application is bundled up as a WAR file, the class files are already in the correct location.

Once the project is created, you need to add all the libraries that the Web application needs to run to a lib folder beneath the WEB-INF folder. There are a number of steps below, but the same pattern of steps is repeated throughout. Use the Eclipse Import from File system dialog box to navigate to a folder containing some library JAR files, select them, and then repeat for other library locations.

You will open the Import from File system dialog box several times. Each time, the steps are the same. To open the Import from File system dialog box, follow these steps:

Use these steps any time you need to open the Import from File system dialog box to add libraries to the web/WEB-INF/lib folder.

Figure 12.12. The Import Select dialog box allows you to import resources for your project from a variety of sources.

Six sets of libraries need to be added to the project. First, add the Spring Framework core library and the Spring ORM and Spring Web MVC libraries by following these steps:

Next, import the MySQL Connector/J JDBC Driver JAR file by following these steps:

Next, import the Hibernate JAR file and the libraries required by Hibernate:

Next, import the Jakarta standard and JSTL tag library files by following these steps:

Finally, import the SLF4J libraries:

When you have finished importing all the libraries, the Project Explorer view should look like Figure 12.16.

Figure 12.16. Once all the required libraries have been added to the web/WEB-INF/lib folder, the Project Explorer view should look like this.

These libraries are now available to the Web application at runtime, but Eclipse can't use them to compile your Java classes until you add them to the build path for the project. Once they're added to the build path, the Eclipse project configuration is complete.

To configure the Java build path for your project, follow these steps:

Figure 12.17. Choosing Java Build Path from the left pane of the Properties dialog box opens the Java Build Path tabbed dialog box in the right pane.

Figure 12.18. Click spring.jar, spring-webmvc.jar, spring-orm.jar, and hibernate3.jar under web/WEB-INF/lib in the JAR Selection dialog box to add them to the build library path for your project.

The model is the part of the Model-View-Controller (MVC) application that contains the value objects and business logic that compose the application. For this Web application, there are four objects that correspond to the four tables in the MySQL database previously created.

Because the Flex client is expecting XML from the Web application, each of these objects should provide a method that returns an XML representation of the object. Because this functionality is common to all the objects and is required, you can create an interface that each object implements. The interface has a single toXml() method. Classes that implement this interface provide an implementation for the toXml() method that returns the XML representation of that object.

To create the IXmlSerializable interface, follow these steps:

Remember that implementing the Serializable interface is a best practice when using Hibernate to store and retrieve objects from a database. Because the IXmlSerializable interface extends the Serializable interface, any class that implements IXmlSerializable is also considered to have implemented Serializable. Therefore, the value object classes you create only need to implement IXmlSerializable.

Figure 12.20. The Extended Interfaces Selection dialog box allows you to choose an interface to extend.

Edit the IXmlSerializable interface to match this code listing:

/**
 *
 */
package com.wiley.jfib.ch12.store.vo;

import java.io.Serializable;

/**
 * @author Chuck
 *
 */
public interface IXmlSerializable extends Serializable {

   /**
     * Return this object as an XML string
     * @return an XML string representing this object
     */
   public String toXml();

}

Now you can create the four value object classes that implement the IXmlSerializable interface. Use the New Java Class dialog box to create each of the four value object classes used by this application: User, Product, Cart, and CartItem. The same steps are used to create each of these classes. To create the value objects, follow these steps for each of the four classes:

Figure 12.21. In the New Java Class dialog box, type the name for the value object class you're creating. The package name is filled in for you.

Figure 12.22. The Implemented Interfaces Selection dialog box allows you to choose an interface to implement.

Here are the code listings for each of these objects:

User.java

/**
  *
  */
 package com.wiley.jfib.ch12.store.vo;


 /**
  * @author Chuck
  *
  */
 public class User implements IXmlSerializable {

     private static final long serialVersionUID = 1L;
     private int id;
     private String firstName;
     private String lastName;
     private String userName;
     private String password;

     /**
      *
      */
     public User() {
     }

     /**

* @return the userId
      */
     public int getId() {
            return id;
     }

     /**
      * @param userId the userId to set
      */
     public void setId(int id) {
            this.id = id;
     }

     /**
      * @return the firstName
      */
     public String getFirstName() {
           return firstName;
     }

     /**
      * @param firstName the firstName to set
      */
     public void setFirstName(String firstName) {
            this.firstName = firstName;
     }

     /**
      * @return the lastName
      */
     public String getLastName() {
            return lastName;
     }

     /**
      * @param lastName the lastName to set
      */
     public void setLastName(String lastName) {
            this.lastName = lastName;
     }

     /**
      * @return the userName
      */
     public String getUserName() {
            return userName;
     }

     /**

* @param userName the userName to set
      */
     public void setUserName(String userName) {
            this.userName = userName;
     }

     /**
      * @return the password
      */
     public String getPassword() {
            return password;
     }

     /**
      * @param password the password to set
      */
     public void setPassword(String password) {
            this.password = password;
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.vo.IXmlSerializable#toXml()
      */
     @Override
     public String toXml() {
            String xml = "<user>";
            xml += "<id>" + id + "</id>";
            xml += "<firstname>" + firstName + "</firstname>";
            xml += "<lastname>" + lastName + "</lastname>";
            xml += "</user>";
            return xml;
     }

}

Product.java

/**
 *
 */
package com.wiley.jfib.ch12.store.vo;


/**
 * @author Chuck
 *
 */
public class Product implements IXmlSerializable {

private static final long serialVersionUID = 1L;
     private int id;
     private String category;
     private String name;
     private String description;
     private double price;

     public Product() {
     }

     /**
      * @return the id
      */
     public int getId() {
            return id;
     }

     /**
      * @param id the id to set
      */
     public void setId(int id) {
            this.id = id;
     }

     /**
      * @return the category
      */
     public String getCategory() {
            return category;
     }

     /**
      * @param category the category to set
      */
     public void setCategory(String category) {
            this.category = category;
     }

     /**
      * @return the name
      */
     public String getName() {
            return name;
     }

     /**
      * @param name the name to set
      */
     public void setName(String name) {

this.name = name;
     }

     /**
      * @return the description
      */
     public String getDescription() {
            return description;
     }

     /**
      * @param description the description to set
      */
     public void setDescription(String description) {
            this.description = description;
     }

     /**
      * @return the price
      */
     public double getPrice() {
            return price;
     }

     /**
      * @param price the price to set
      */
     public void setPrice(double price) {
            this.price = price;
     }

     /* (non-Javadoc)
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
     public boolean equals(Object arg0) {
            return this.id == ((Product)arg0).getId();
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.vo.IXmlSerializable#toXml()
      */
     @Override
     public String toXml() {
            String xml = "<product>";
            xml += "<id>" + id + "</id>";
            xml += "<cat>" + category + "</cat>";
            xml += "<name>" + name + "</name>";
            xml += "<desc>" + description + "</desc>";

xml += "<price>$" + price + "</price>";
          xml += "</product>";
          return xml;
     }
}

CartItem.java

/**
  *
  */
 package com.wiley.jfib.ch12.store.vo;

 /**
  * @author Chuck
  *
  */
 public class CartItem implements IXmlSerializable {

     private static final long serialVersionUID = 1L;
     private int id;
     private int cartId;
     private Product product;
     private int quantity;

     /**
      *
      */
     public CartItem() {
     }

     /**
      * @return the id
      */
     public int getId() {
            return id;
     }

     /**
      * @param id the id to set
      */
     public void setId(int id) {
            this.id = id;
     }

     /**
      * @return the cartId
      */
     public int getCartId() {

return cartId;
     }

     /**
      * @param cartId the cartId to set
      */
     public void setCartId(int cartId) {
            this.cartId = cartId;
     }

     /**
      * @return the product
      */
     public Product getProduct() {
            return product;
     }

     /**
      * @param product the product to set
      */
     public void setProduct(Product product) {
            this.product = product;
     }

     /**
      * @return the quantity
      */
     public int getQuantity() {
            return quantity;
     }

     /**
      * @param quantity the quantity to set
      */
     public void setQuantity(int quantity) {
            this.quantity = quantity;
     }

     /**
      * Retrieve the total cost for this cart item
      * @return
      */
     public double getItemTotal()
     {
            return product.getPrice() * quantity;
     }


     /**

*
      */
     public boolean equals(Object obj)
     {
            CartItem item2 = (CartItem)obj;
            return cartId == item2.cartId
                            && product.getId() ==
                            item2.getProduct().getId();
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.vo.IXmlSerializable#toXml()
      */
     @Override
     public String toXml() {
            String xml = "<item>";
            xml += product.toXml();
            xml += "<quantity>" + quantity + "</quantity>";
            xml += "<item_total>$"
                   + this.getItemTotal()
                   + "</item_total>";
            xml += "</item>";
            return xml;
     }
}

Cart.java

/**
  *
  */
 package com.wiley.jfib.ch12.store.vo;

 import java.util.Collection;
 import java.util.HashSet;

 /**
  * @author Chuck
  *
  */
 public class Cart implements IXmlSerializable {
     private static final long serialVersionUID = 1L;
     private int id;
     private int userId;
     private Collection<CartItem> items;

     /**
      *
      */
     public Cart() {

items = new HashSet<CartItem>();
     }

     /**
      * @return the id
      */
     public int getId() {
            return id;
     }

     /**
      * @param id the id to set
      */
     public void setId(int id) {
            this.id = id;
     }

     /**
      * @return the userId
      */
     public int getUserId() {
            return userId;
     }

     /**
      * @param userId the userId to set
      */
     public void setUserId(int userId) {
            this.userId = userId;
     }

     /**
      * @return the items
      */
     public Collection<CartItem> getItems() {
            return items;
     }

     /**
      * @param items the items to set
      */
     public void setItems(Collection<CartItem> items) {
            this.items = items;
     }

     /**
      *
      * @param item
      */

public void addItem(CartItem item) {
          boolean itemExists = false;
          for(CartItem existingItem : items)
          {
                  if(item.equals(existingItem))
                  {
                         existingItem.setQuantity
                           (existingItem.getQuantity()
                           + item.getQuantity());
                         itemExists = true;
                         break;
                  }
          }
          if(!itemExists)
                  items.add(item);
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.vo.IXmlSerializable#toXml()
      */
     @Override
     public String toXml() {
            double cartTotal = 0.0;
            String xml = "<cart>";
            xml += "<userid>" + userId + "</userid>";
            xml += "<items>";
            for (CartItem item : items)
            {
                    xml += item.toXml();
                    cartTotal += item.getItemTotal();
          }
          xml += "</items>";
          xml += "<total>$" + cartTotal + "</total>";
          xml += "</cart>";
          return xml;
     }

}

As you can see, each of these four value objects has properties and getter and setter methods corresponding to the columns in each of the database tables. They also all implement the toXml() method from the IXmlSerializable interface. Each of the implementations of toXml() returns a string of XML representing that object. The CartItem class has one additional method, getItemTotal(), that calculates the total cost of the item by multiplying the unit price by the quantity. This value is returned to the Flex client in the XML created by the toXml() method.

To store and retrieve these objects by using Hibernate, you need to create a Hibernate mapping file for each of them. Remember that Hibernate mapping files are XML files that by convention have an .hbm.xml suffix and contain information mapping the properties of the object to columns in the database. The process for creating the Hibernate mapping file is the same for all four classes, aside from the filename. To create the Hibernate mapping files, follow these steps:

Figure 12.23. The Select a wizard dialog box lets you choose the kind of object you want to create. Select File from below General in the list.

Figure 12.24. The New File dialog box lets you create a new empty file.

Here are the code listings for each of the Hibernate mapping files:

Cart.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping
   DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-
   3.0.dtd" >
<hibernate-mapping>
   <class name="com.wiley.jfib.ch12.store.vo.Cart" table="CART">
         <id name="id" column="id" type="java.lang.Integer">
               <generator class="increment"/>
         </id>
         <property name="userId" column="user_id"
               type="java.lang.Integer" />
         <set name="items" lazy="false" cascade="all-delete-orphan">
               <key column="cart_id" not-null="true"/>
               <one-to-many
                      class="com.wiley.jfib.ch12.store.vo.CartItem"/>

</set>
     </class>
</hibernate-mapping>

CartItem.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping
   DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping>
   <class name="com.wiley.jfib.ch12.store.vo.CartItem"
         table="CART_ITEM">
         <id name="id" column="id" type="java.lang.Integer">
               <generator class="increment"/>
         </id>
         <property name="cartId" insert="false" update="false"
   column="cart_id" type="java.lang.Integer" />
         <many-to-one lazy="false" name="product"
                class="com.wiley.jfib.ch12.store.vo.Product"
                column="product_id"/>
         <property name="quantity" column="quantity"
                type="java.lang.Integer" />
   </class>
</hibernate-mapping>

Product.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping
   DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-
   3.0.dtd" >
<hibernate-mapping>
   <class name="com.wiley.jfib.ch12.store.vo.Product"
   table="PRODUCT">
         <id name="id" column="id" type="java.lang.Integer">
                 <generator class="increment"/>
         </id>
         <property name="category" column="category"
                type="java.lang.String" />
         <property name="name" column="name"
                type="java.lang.String" />
         <property name="description" column="description"
                type="java.lang.String" />
         <property name="price" column="price"
                type="java.lang.Double" />
   </class>
</hibernate-mapping>

User.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping
   DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-
   3.0.dtd" >
<hibernate-mapping>
   <class name="com.wiley.jfib.ch12.store.vo.User" table="USER">
         <id name="id" column="id" type="java.lang.Integer">
               <generator class="increment"/>
         </id>
         <property name="firstName" column="first_name"
                type="java.lang.String" />
         <property name="lastName" column="last_name"
                type="java.lang.String" />
         <property name="userName" column="user_name"
                type="java.lang.String" />
         <property name="password" column="password"
                type="java.lang.String" />
   </class>
</hibernate-mapping>

The Hibernate mapping files contain <property> tags for each property in the object, mapping them to columns in the database table. The mapping file for the Cart class contains a <set> tag that establishes that a single Cart can contain a set of one or more CartItem objects. The mapping file for the CartItem class contains a <many-to-one> tag that establishes that many CartItem objects can contain the same Product class.

Hibernate also needs a log4j.properties file to configure the logging that it does. To create the log4j.properties file, follow these steps:

Here's the code listing for the log4j.properties file:

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.rootLogger=debug, stdout

log4j.logger.org.hibernate=error
log4j.logger.org.hibernate.SQL=error
log4j.logger.org.hibernate.type=error
log4j.logger.org.hibernate.cache=error

In this properties file, log4j is configured to output any logging messages to the JBoss console view, which is referred to as stdout, for standard output. Logging for Hibernate is set to output to the console only when an error occurs. This setting results in a minimal amount of information output to the console. To display more information, the logging level can be changed from error to warn, which displays both errors and warnings; debug, which displays errors, warnings, and any debugging information from Hibernate; and info, which is the most verbose level of output.

Finally, the application needs a Hibernate configuration file to allow it to set up communication between Hibernate and the database. The Hibernate configuration file should be named hibernate.cfg.xml. You create it in the root of the src folder. When the project is built, it's placed in the root of the web/WEB-INF/classes folder, where it's accessible on the classpath along with the compiled class files. The configuration is read in when JBoss is started, and the communication with the database is set up at that time.

To create the hibernate.cfg.xml configuration file, follow these steps:

Here's the code listing for the hibernate.cfg.xml file:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>

       <!-- Database connection settings -->

<property name="connection.driver_class">
   com.mysql.jdbc.Driver
</property>

<property name="connection.url">
   jdbc:mysql://localhost:3306/store
</property>

<property name="connection.username">root</property>
<property name="connection.password">toor</property>
<property name="connection.autocommit">true</property>

<!-- SQL dialect -->
<property name="dialect">
   org.hibernate.dialect.MySQLDialect
</property>

<!-- Enable Hibernate's automatic session context management -->
<property name="current_session_context_class">jta</property>

<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true
</property>

<mapping
   resource="com/wiley/jfib/ch12/store/vo/Cart.hbm.xml"/>
<mapping
   resource="com/wiley/jfib/ch12/store/vo/CartItem.hbm.xml"/>
<mapping
   resource="com/wiley/jfib/ch12/store/vo/Product.hbm.xml"/>
<mapping
   resource="com/wiley/jfib/ch12/store/vo/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>

The data access layer is the part of the application that communicates with the database. For this application, an interface called IStoreDao defines the data access functions available to the service layer of the application. A class called StoreDao implements this interface and provides the implementations of these data access functions. Remember, when you separate the interface from the implementation, if the need ever arises to change the way the data for the application is accessed, the StoreDao implementation can be changed without needing to change any of the service layer code, which uses the interface and isn't dependent on the implementation of the interface behind the scenes.

The IStoreDao interface contains one method for each of the services in the application. To create the IStoreDao interface, follow these steps:

Edit the IStoreDao interface so that it matches the following code listing:

/**
  *
  */
 package com.wiley.jfib.ch12.store.dao;

 import java.util.Collection;

 import com.wiley.jfib.ch12.store.vo.Cart;
 import com.wiley.jfib.ch12.store.vo.Product;
 import com.wiley.jfib.ch12.store.vo.User;

 /**
  * @author Chuck
  *
  */
 public interface IStoreDao {
     /**
      *
      * @param category
      * @return
      */
     public Collection<Product> getProductList(String category);

     /**
      *
      * @param productId
      * @return
      */
     public Product getProductDetails(String productId);

     /**
      *
      * @param username
      * @param password
      * @return
      */
public User logIn(String username, String password);

/**
      *
      * @param userId
      * @return
      */
     public Cart retrieveCart(String userId);

     /**
      *
      * @param userId
      * @param product
      */
     public Cart addProductToCart(String userId, Product product,
     String quantity);

     /**
      *
      * @param userId
      * @param product
      */
     public Cart addProductToCart(String userId, String productId,
     String quantity);

     /**
      *
      * @param product
      * @return
      */
     public Product saveOrUpdateProduct(Product product);

     /**
      *
      * @param productId
      * @return
      */
     public void deleteProduct(int productId);
}

To create the StoreDao class, follow these steps:

Figure 12.25. The Superclass Selection dialog box lets you choose a superclass for your Java classes. The superclass for the StoreDao class is the HibernateDaoSupport class found in the Spring ORM library.

Edit the StoreDao class so that it matches this code listing:

/**
 *
 */

package com.wiley.jfib.ch12.store.dao;

import java.util.Collection;

import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.
   HibernateDaoSupport;

import com.wiley.jfib.ch12.store.vo.Cart;
import com.wiley.jfib.ch12.store.vo.CartItem;
import com.wiley.jfib.ch12.store.vo.Product;
import com.wiley.jfib.ch12.store.vo.User;

/**
 * @author Chuck
 *
 */
public class StoreDao extends HibernateDaoSupport implements
  IStoreDao {

  /**
   *
   */
  public StoreDao() {
  }

  /* (non-Javadoc)
   * @see com.wiley.jfib.ch12.store.dao.
  IStoreDao#addProductToCart(java.lang.String, com.wiley.jfib.ch12.
  store.vo.Product)
   */
  @Override
  @SuppressWarnings("unchecked")
  public Cart addProductToCart(String userId, Product product,
        String quantity) {
          DetachedCriteria criteria =
               DetachedCriteria.forClass(Cart.class)
               .add(Restrictions.eq("userId",
                      Integer.parseInt(userId)));
          Collection<Cart> carts = getHibernateTemplate().
               findByCriteria(criteria, 0, 1);
          Cart cart = new Cart();
          cart.setUserId(Integer.parseInt(userId));
          if(carts.size() > 0)
               cart = carts.iterator().next();
          CartItem item = new CartItem();
          item.setCartId(cart.getId());
          item.setProduct(product);

item.setQuantity(Integer.parseInt(quantity));
          cart.addItem(item);
          getHibernateTemplate().saveOrUpdate(cart);
          return cart;
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.dao.
     IStoreDao#addProductToCart(java.lang.String, com.wiley.jfib.ch12.
     store.vo.Product)
       */
     @Override
     public Cart addProductToCart(String userId, String productId,
     String quantity) {
           Product product = getProductDetails(productId);
           return addProductToCart(userId,product,quantity);
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.dao.IStoreDao#getProductDetails
     (java.lang.String)
       */
     @Override
     public Product getProductDetails(String productId) {
           return (Product)getHibernateTemplate()
                  .get(Product.class, Integer.parseInt(productId));
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.dao.
     IStoreDao#getProductList(java.lang.String)
      */
     @Override
     @SuppressWarnings("unchecked")
     public Collection<Product> getProductList(String category) {
           DetachedCriteria criteria =
                  DetachedCriteria.forClass(Product.class);
           if(category != null)
              criteria = criteria.add(Restrictions.eq("category", category));
                  return getHibernateTemplate().findByCriteria(criteria);
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.dao.IStoreDao#logIn(java.lang.
     String, java.lang.String)
      */
     @Override
     @SuppressWarnings("unchecked")

public User logIn(String username, String password) {
           DetachedCriteria criteria =
                  DetachedCriteria.forClass(User.class)
                  .add(Restrictions.eq("userName", username))
                  .add(Restrictions.eq("password", password));
           Collection<User> user = getHibernateTemplate().
                  findByCriteria(criteria, 0, 1);
           if(user.size() == 0)
              return null;
           else
              return user.iterator().next();
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.dao.IStoreDao#retrieveCart(java.
     lang.String)
      */
     @Override
     @SuppressWarnings("unchecked")
     public Cart retrieveCart(String userId) {
           DetachedCriteria criteria =
                  DetachedCriteria.forClass(Cart.class)
                  .add(Restrictions.eq("userId",
                         Integer.parseInt(userId)));
           Collection<Cart> carts =
                  getHibernateTemplate().findByCriteria(criteria, 0, 1);
           Cart cart = new Cart();
           cart.setUserId(Integer.parseInt(userId));
           if(carts.size() > 0)
                   cart = carts.iterator().next();
           return cart;
     }

     @Override
     public Product saveOrUpdateProduct(Product product) {
           getHibernateTemplate().saveOrUpdate(product);
           return product;
     }

     /* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.dao.IStoreDao#deleteProduct(int)
      */
     @Override
     public void deleteProduct(int productId) {
           // TODO Auto-generated method stub
           Product product = (Product) getHibernateTemplate().
                  get(Product.class, productId);

if(product != null)
                  getHibernateTemplate().delete(product);
     }

}

The methods in the StoreDao class use Hibernate's DetachedCriteria class to define the criteria to be used when retrieving objects. For example, in the getProductList() method, first the DetachedCriteria is created by using the Product class. Then the category passed in is selected, and if it's not null, a restriction is added to the DetachedCriteria to retrieve only the Products in the given category. Finally, the Hibernate template is retrieved, and its findByCriteria method is called by using the DetachedCriteria object to retrieve the Products that fit the criteria. The rest of the methods in the StoreDao class follow this same general pattern.

The service layer contains five service classes that handle requests from the Flex client and return XML data that fits into a well-defined structure. The outermost tag is a <result> tag that contains a type attribute that indicates success or failure. Inside the <result> tag is the XML for the actual result of the operation. For successful operations, this is the XML representation of the object being retrieved. For failure, some well-defined error XML containing the error message is returned.

Because much of the XML structure is the same for all the services, you can separate that code out into its own class and then let each of the services extend that class. This base class is responsible for creating the <result> tag and the standard error XML. Each of the service classes that extend it is responsible for providing the XML from the objects it retrieves. The base class will be abstract, meaning that it can't be instantiated directly. An abstract class typically contains one or more abstract methods, which extending classes are required to provide implementations for. In this way, an abstract class acts much like an interface that provides some implementation code itself.

To create the abstract StoreBaseService class, follow these steps:

Edit the StoreBaseService class so that it matches the following code listing:

/**
  *
  */
 package com.wiley.jfib.ch12.store.service;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import org.springframework.web.servlet.ModelAndView;
 import org.springframework.web.servlet.mvc.Controller;

 import com.wiley.jfib.ch12.store.dao.IStoreDao;

 /**
  * @author Chuck
  *
  */
 public abstract class StoreBaseService implements Controller {
     private IStoreDao storeDao;

     @Override
     public ModelAndView handleRequest(HttpServletRequest arg0,
                  HttpServletResponse arg1) throws Exception
     {
           String xmlString = "";
           try {
                  xmlString = getResultXmlHeader();
                  xmlString += getXmlFromOperation(arg0,arg1);
                  xmlString += getResultXmlFooter();
           } catch (Exception e) {
                  xmlString = getErrorXml(e.getMessage());
           }
           return new ModelAndView("WEB-INF/jsp/xml.jsp",
                  "xmlString",xmlString);
     }

     protected String getErrorXml(String message)
     {
          String errorXml = "<?xml version="1.0"
     encoding="ISO-8859-1"?>";
          errorXml += "<result type="error">";
          errorXml += "<message>";
          errorXml += message;
          errorXml += "</message>";
          errorXml += "</result>";
          return errorXml;
     }

protected String getResultXmlHeader()
     {
          String resultXml = "<?xml version="1.0"
                 + encoding="ISO-8859-1"?>";
          resultXml += "<result type="success">";
          return resultXml;
     }

     protected abstract String getXmlFromOperation
          (HttpServletRequest request,
          HttpServletResponse response) throws Exception;

     protected String getResultXmlFooter()
     {
          return "</result>";
     }

     /**
      * @return the storeDao
      */
     public IStoreDao getStoreDao() {
           return storeDao;
     }

     /**
      * @param storeDao the storeDao to set
      */
     public void setStoreDao(IStoreDao storeDao) {
           this.storeDao = storeDao;
     }
}

The StoreBaseService class implements the Spring Framework's Controller interface, which is part of the Spring Web MVC module. Classes that implement the Controller interface handle requests dispatched to them from the Spring Dispatcher servlet. This class constructs some header XML and then calls an abstract method called getXmlFromOperation(). No implementation is provided for this method. The service classes that extend StoreBaseService are required to provide an implementation for it. This is where the services return the XML representations of the objects they retrieve.

You use the New Java Class dialog box to create each of the five service classes used by this application. These service classes are as follows:

The same steps are used to create each of these classes. To create the services, follow these steps for each of the five classes:

Here are the code listings for each of these services:

AddProductToCartService.java

/**
  *
  */
 package com.wiley.jfib.ch12.store.service;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import com.wiley.jfib.ch12.store.vo.Cart;

 /**
  * @author Chuck
  *
  */
 public class AddProductToCartService extends StoreBaseService {

    /* (non-Javadoc)
     * @see com.wiley.jfib.ch12.store.service.StoreBaseService#getXml
    FromOperation(javax.servlet.http.HttpServletRequest, javax.
    servlet.http.HttpServletResponse)

*/
     @Override
     protected String getXmlFromOperation(HttpServletRequest request,
                 HttpServletResponse response) throws Exception {
           String productId = request.getParameter("productid");
           String userId = request.getParameter("userid");
           String quantity = request.getParameter("quantity");
           Cart cart = getStoreDao().addProductToCart(userId,
     productId, quantity);
           return cart.toXml();
     }
}

LogInService.java

/**
  *
  */
 package com.wiley.jfib.ch12.store.service;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import com.wiley.jfib.ch12.store.vo.User;

 /**
  * @author Chuck
  *
  */
 public class LogInService extends StoreBaseService {

    /* (non-Javadoc)
     * @see com.wiley.jfib.ch12.store.service.StoreBaseService#getXml
    FromOperation(javax.servlet.http.HttpServletRequest, javax.
    servlet.http.HttpServletResponse)
     */
    @Override
    protected String getXmlFromOperation(HttpServletRequest request,
                 HttpServletResponse response) throws Exception {
          String username = request.getParameter("username");
          String password = request.getParameter("password");
          User user = getStoreDao().logIn(username, password);
          if(user == null)
                 throw new Exception
                        ("Invalid credentials - login failed.");
          return user.toXml();
     }
}

ProductDetailsService.java

/**
  *
  */
 package com.wiley.jfib.ch12.store.service;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import com.wiley.jfib.ch12.store.vo.Product;

 /**
  * @author Chuck
  *
  */
 public class ProductDetailsService extends StoreBaseService {
    /* (non-Javadoc)
     * @see com.wiley.jfib.ch12.store.service.StoreBaseService#getXml
    FromOperation(javax.servlet.http.HttpServletRequest, javax.
    servlet.http.HttpServletResponse)
     */
    @Override
    protected String getXmlFromOperation(HttpServletRequest request,
                 HttpServletResponse response) throws Exception {
          String productId = request.getParameter("id");
          Product product = getStoreDao().
                 getProductDetails(productId);
          return product.toXml();
    }
}

ProductListService.java

/**
  *
  */
 package com.wiley.jfib.ch12.store.service;

 import java.util.Collection;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import com.wiley.jfib.ch12.store.vo.Product;

 /**
  * @author Chuck
  *
  */
 public class ProductListService extends StoreBaseService {

/* (non-Javadoc)
      * @see com.wiley.jfib.ch12.store.service.StoreBaseService#getXml
     FromOperation(javax.servlet.http.HttpServletRequest, javax.
     servlet.http.HttpServletResponse)
       */
      @Override
      protected String getXmlFromOperation(HttpServletRequest request,
                   HttpServletResponse response) throws Exception {
            String xmlString = "";
            String category = request.getParameter("cat");
            Collection<Product> products = getStoreDao().
                   getProductList(category);
            xmlString += "<products>";
            for(Product product : products)
                   xmlString += product.toXml();
            xmlString += "</products>";
            return xmlString;
    }
}

RetrieveCartService.java

/**
  *
  */
 package com.wiley.jfib.ch12.store.service;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import com.wiley.jfib.ch12.store.vo.Cart;

 /**
  * @author Chuck
  *
  */
 public class RetrieveCartService extends StoreBaseService {
    /* (non-Javadoc)
     * @see com.wiley.jfib.ch12.store.service.StoreBaseService#getXml
    FromOperation(javax.servlet.http.HttpServletRequest, javax.
    servlet.http.HttpServletResponse)
     */
    @Override
    protected String getXmlFromOperation(HttpServletRequest request,
                 HttpServletResponse response) throws Exception {
          String userId = request.getParameter("userid");
          Cart cart = getStoreDao().retrieveCart(userId);
          return cart.toXml();
    }
}

The only method implemented by the service classes is the abstract getXmlFromOperation() method in the StoreBaseService base class. Each service uses the IStoreDao interface provided by the base class to retrieve the data it needs and then calls the toXml() method on the returned object to get the XML representation of the object. The StoreBaseService class then places this XML inside the <result> tags, and this XML block is returned to the client.

As you saw in the StoreBaseService class, the view for all these services is a JSP file named xml.jsp. This JSP file simply outputs the XML string so that the Flex client can use it. To create the xml.jsp file, follow these steps:

The code listing for the xml.jsp file follows. The code should be entered on a single line and without breaks:

<?xml version="1.0" encoding="ISO-8859-1" ?><%@ page language="java"
    contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%><%@ taglib prefix="c" uri="http://
    java.sun.com/jsp/jstl/core" %><c:out value="${xmlString}"/>

The JSP page uses the JSTL tag library to output the value of the variable xmlString passed in from the Controller. The Flex client receives this block of XML, parses it, and displays the data to the user.

There are two configuration files needed for a Spring Web MVC Web application. The first is web.xml, which is the standard configuration file for all Web applications. In the web.xml file, you set up a servlet registration and mapping for the Spring dispatcher servlet. This servlet handles all incoming requests to the Web application and delegates them to the appropriate service class based on the URL of the request. The mapping for each of the service classes as well as the Hibernate template configuration is handled in the second configuration file: spring-dispatcher-servlet.xml. In this file, each URL is mapped to a specific controller, and the Hibernate configuration for the Hibernate session and template is defined.

First, create spring-dispatcher-servlet.xml by following these steps:

Here's the code listing for the spring-dispatcher-servlet.xml file:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <bean id="sessionfactory"
          class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
         <property name="configLocation">
            <value>classpath:/hibernate.cfg.xml</value>
       </property>
    </bean>
    <bean id="hibernatetemplate"
          class="org.springframework.orm.hibernate3.HibernateTemplate">
          <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean name="storeDao"
          class="com.wiley.jfib.ch12.store.dao.StoreDao">
          <property name="hibernateTemplate"
                 ref="hibernateTemplate"/>
    </bean>
    <bean name="/add-product.htm"
          class="com.wiley.jfib.ch12.store.service.AddProductToCartService">
          <property name="storeDao" ref="storeDao"/>
    </bean>
    <bean name="/cart.htm"
          class="com.wiley.jfib.ch12.store.service.RetrieveCartService">
          <property name="storeDao" ref="storeDao"/>
    </bean>
    <bean name="/product-list.htm"
          class="com.wiley.jfib.ch12.store.service.ProductListService">
          <property name="storeDao" ref="storeDao"/>
    </bean>

<bean name="/product-details.htm" class="com.wiley.jfib.ch12.store.service.ProductDetailsService">
         <property name="storeDao" ref="storeDao"/>
    </bean>
    <bean name="/login.htm"
          class="com.wiley.jfib.ch12.store.service.LogInService">
          <property name="storeDao" ref="storeDao"/>
    </bean>
</beans>

This configuration file defines the Spring beans for the Hibernate template and session by using the hibernate.cfg.xml file to provide them with the Hibernate configuration. It also maps a URL to each service class and then sets up the StoreDao property each service uses to retrieve the data it needs.

Now create the web.xml configuration file by following the same steps you used to create spring-dispatcher-servlet.xml. The code listing for web.xml follows:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
         http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" >
 <servlet>
   <servlet-name>spring-dispatcher</servlet-name>
   <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
   </servlet-class>
   <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
   <servlet-name>spring-dispatcher</servlet-name>
   <url-pattern>*.htm</url-pattern>
</servlet-mapping>
</web-app>

This configuration file defines the Spring DispatcherServlet and maps it to a URL pattern that says that any URL ending in .htm is handled by this servlet.

Now that the setup is finished, you can create the Ant build properties file and the build.xml file. To create these two files, follow these steps:

The properties contained in the store-build.properties file are used by the build.xml build file, so first edit the store-build.properties file to match this code listing:

# Ant build properties for store
src.dir=src
web.dir=web
build.dir=${web.dir}/WEB-INF/classes

name=store

appserver.home=${env.JBOSS_HOME}/server/default
appserver.lib=${appserver.home}/lib
deploy.path=${appserver.home}/deploy

This properties file contains properties for the Java source and Web file directories in the project, the build output directory, the application name, the JBoss home, and the application deployment path.

Now edit the build.xml file to match this code listing:

<?xml version="1.0" encoding="UTF-8"?>
<project name="store" basedir="." default="usage">
    <property environment="env"/>
     <property file="store-build.properties"/>

     <path id="cp">

<fileset dir="${web.dir}/WEB-INF/lib">
            <include name="*.jar"/>
     </fileset>
     <fileset dir="${appserver.lib}">
          <include name="servlet*.jar"/>
     </fileset>
     <pathelement path="${build.dir}"/>
   </path>

   <target name="usage">
      <echo message=""/>
      <echo message="${name} build file"/>
      <echo message="-----------------------------------"/>
      <echo message=""/>
      <echo message="Available targets are:"/>
      <echo message=""/>
      <echo message="build     --> Build the application"/>
      <echo message="deploy      --> Deploy application as a WAR
   file"/>
      <echo message=""/>
   </target>

   <target name="build" description="Compile main source tree java
  files">
   <mkdir dir="${build.dir}"/>
   <javac destdir="${build.dir}" source="1.5" target="1.5"
    debug="true" deprecation="false" optimize="false"
    failonerror="true">
   <src path="${src.dir}"/>
   <classpath refid="cp"/>
   </javac>
 </target>

 <target name="deploy" depends="build" description="Deploy
application as a WAR file">
    <war destfile="${name}.war"
            webxml="${web.dir}/WEB-INF/web.xml">
          <fileset dir="${web.dir}">
              <include name="**/*.*"/>
          </fileset>
    </war>
    <copy todir="${deploy.path}" preservelastmodified="true">
       <fileset dir=".">
          <include name="*.war"/>
       </fileset>
    </copy>
  </target>
</project>