The type 1 driver was one of the first available driver types supporting JDBC for database vendors. This is mostly due to the existing support and availability of ODBC drivers for databases, and the JDBC-ODBC bridge provides a unified API utilizing that support.

The main advantage that the JDBC-ODBC bridge had (which is now obsolete as a result of support for later, more comprehensive driver types across most database vendors) was the availability of ODBC drivers, which were already installed on the client machines that needed to use the database.

However, JDBC-ODBC bridge drivers suffer from a massive performance penalty because the JDBC call is routed through the bridge to the ODBC driver and then to the native database interface. When the database responds, the reverse occurs.

Another significant downside of the JDBC-ODBC bridge drivers is that for each new client machine that is installed, native support must be installed on each of those machines. This makes it much harder to deploy Java-only solutions.

Type 1 drivers are relatively uncommon now, having primarily been replaced by type 3 or type 4 drivers.

The type 2 driver was a step up from the type 1 driver, where custom Java driver code was integrated with native database client code to provide a hybrid driver for communicating with the database.

Many type 2 drivers suffer from disadvantages similar to those of the type 1 client: low performance and the requirement for native code installation on the client. However, some of the type 2 drivers, notably the Oracle OCI drivers, have optimized native code for specific platforms, and so perform quite well.

The advantage that type 2 drivers have over type 1 drivers is an increase in performance. Like type 1 drivers, type 2 drivers represent a significant minority, especially for modern versions of the popular databases.

The type 3 driver is the first of all Java drivers available for JDBC access. A type 3 driver communicates with special database-specific middleware that converts JDBC calls to database-specific calls. The main advantage the type 3 driver provides is that the client code is all Java; no native client install is required, so distribution and configuration of Java applications is vastly simplified.

The middleware server can serve many different versions of databases and can act as a gateway to multiple database servers.

In general, the type 3 drivers are significantly faster than the type 1 or 2 drivers.

The type 4 driver, like the type 3 driver, provides an all-Java driver for the client. The main difference between the type 4 and type 3 drivers is that the type 4 driver communicates directly with the database, converting the JDBC calls to database-specific protocols within the JDBC driver.

One theoretical disadvantage of the type 4 drivers over type 3 is the need for specific drivers for each of the databases supported, whereas a type 3 driver could potentially serve many databases behind the middleware server. In practice, this isn't much of an issue.

Connecting to a database using JDBC can be performed in one of two ways. The first is to load the JDBC driver directly. The second is to use the J2EE container to provide an abstraction and obtain a DataSource object via JNDI.

The advantages of obtaining a DataSource from the container include the following:

A Web container is not required to provide a JNDI resource pool containing a DataSource. Most do provide this facility, but to cover all the bases, the following examples highlight the differences between the two approaches. Both end up with a Connection object, and both examples are quite simple.

The following code fragment shows how to load a JDBC driver and obtain a Connection directly:

Connection conn = null;
try
{
    Class.forName("com.mysql.jdbc.Driver").newInstance();
    conn = DriverManager.getConnection("jdbc:mysql://localhost/mysql?params");
}
catch (SQLException unexpected)
{
    System.out.println("Error occurred obtaining connection");
    System.out.println(unexpected.getMessage());
}
...

The following code fragment shows how to locate a JDBC driver via a JNDI lookup, and obtain a Connection from the DataSource:

Connection conn = null;
try
{
    Context initialContext = new InitialContext();
    Context env = (Context) initialContext.lookup("java:comp/env");
    DataSource source = (DataSource) env.lookup("jdbc/FootyDB");
    conn = source.getConnection();
}
catch (SQLException unexpected)
{
    System.out.println("Error occurred obtaining connection");
    System.out.println(unexpected.getMessage());
}
....

Notice that the structure and layout of the code is almost identical. There's only a minor difference between the two approaches in obtaining a Connection.

At this point, not much can be done without setting up a database. The remaining examples assume that this setup and configuration are handled. This is not a comprehensive guide to setting up MySQL; for additional assistance, the MySQL Web site (www.mysql.org) provides very detailed instructions for installation and troubleshooting.

To download MySQL, go to www.mysql.org.

For Microsoft Windows:

For Linux systems, the standard RPM tools will install the MySQL binaries and distribution to the appropriate places.

The procedure for installing a JDBC driver depends on the application server that is installed for the examples. In general, it requires making the classes available to the application server so that they can be found and utilized by the server.

The Tomcat Web application server recommends placing the driver JAR file into <Tomcat Installation Directory>/common/lib; this enables it to take advantage of loading through the JNDI DataSource.

If there is no need or any interest in using the JNDI DataSource for locating and loading the driver, then the Connector/J JAR file can be packaged with the WAR during deployment.

All the following examples require that the driver JAR be installed with the application server, as the code will obtain a DataSource according to a JNDI lookup. This will enable the examples to be relatively independent of any database-specific setup or classes.

Starting MySQL is as simple as running mysqld.exe (Windows) or safe_mysql (UNIX). Using the RPM installation under Linux will create scripts to automatically start and stop the database when the system is started and shut down.

Windows users can install MySQL as a service, which provides the same lifecycle functionality.

This set of packages contains the core classes and interfaces that are necessary when dealing with databases. These elements relate to tasks such as the following:

This set of packages contains the classes and interfaces that are used for server-side data source access. The javax.sql packages are now included in Java 1.4, but are also required as part of J2EE environments. The main inclusion as part of javax.sql is the DataSource provided as an alternative to DriverManager. However, it also includes such things as connection pooling, distributed transactions, and the -RowSet implementation.

The following table describes some of the more common classes and interfaces used to obtain database connections and perform queries on the database.

The following table describes the common Java data types that are needed to support the SQL data types. Using these Java classes may be required when obtaining information from a ResultSet.

Now that you are familiar with the descriptions of common components used when working with databases in Java, you can experiment with the following Try It Out example, which includes many of the concepts that have been covered.

CREATE DATABASE footydb;

GRANT ALL ON footydb.* TO footy@localhost IDENTIFIED BY 'footy';

CREATE TABLE `roster` (
  `id` int(11) NOT NULL auto_increment,
  `teamname` varchar(100) NOT NULL default '',
  PRIMARY KEY  (`id`)
) TYPE=MyISAM;

CREATE TABLE `round` (
  `id` int(11) NOT NULL auto_increment,
  `number` int(11) NOT NULL default '0',
  `startdate` date NOT NULL default '0000-00-00',
  `enddate` date NOT NULL default '0000-00-00',
  PRIMARY KEY  (`id`)
) TYPE=MyISAM;

CREATE TABLE `fixture` (

`id` int(11) NOT NULL auto_increment,
  `roundid` int(11) NOT NULL default '0',
  `hometeam` int(11) NOT NULL default '0',
  `awayteam` int(11) NOT NULL default '0',
  `venueid` int(11) NOT NULL default '0',
  PRIMARY KEY  (`id`)
) TYPE=MyISAM;

CREATE TABLE `venue` (
  `id` int(11) NOT NULL auto_increment,
  `location` varchar(100) NOT NULL default '',
  PRIMARY KEY  (`id`)
) TYPE=MyISAM;

Figure 23-1 shows the components of the application that will be built to support the addition of teams to the roster table.

Figure 23.1. Roster administration

chapter23/
          src/
          web/
             WEB-INF/
                     lib/

<?xml version='1.0' encoding='utf-8'?>
<Context docBase="/path/to/chapter23/web"
  path="/chapter23"
  reloadable="true"
  workDir="/path/to/chapter23/work">

  <Resource name="jdbc/FootyDB"
      type="javax.sql.DataSource"
      auth="Container"
      />

  <ResourceParams name="jdbc/FootyDB">
      <parameter>
          <name>username</name>
          <value>footy</value>
      </parameter>
      <parameter>
          <name>password</name>
          <value>footy</value>
      </parameter>
      <parameter>
          <name>driverClassName</name>
          <value>com.mysql.jdbc.Driver</value>
      </parameter>
      <parameter>
          <name>url</name>
          <value>jdbc:mysql://localhost/footydb?autoReconnect=true</value>
      </parameter>
  </ResourceParams>

</Context>

<Context docBase="c:/dev/begjsp/chapter23/web"

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app version="2.4" uri="http://java.sun.com/xml/ns/j2ee" >

  <servlet>
    <servlet-name>AdminServlet</servlet-name>
    <display-name>Football administration servlet</display-name>
    <description>Football administration servlet</description>
    <servlet-class>com.wrox.begjsp.ch23.football.AdminServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>AdminServlet</servlet-name>
    <url-pattern>/admin</url-pattern>
  </servlet-mapping>

  <resource-ref>
    <res-ref-name>jdbc/FootyDB</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
  </resource-ref>

</web-app>

<!--
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
-->
<jsp:useBean id="roster" class="java.util.ArrayList" scope="request" />
<jsp:useBean id="SERVLET_PATH" class="java.lang.String" scope="request" />
<c:set value="Team Roster Management" var="title" />
<html>
  <head>
    <script type="text/javascript" >
      function modifyTeam(id) {
      var roster = document.rosterlist;
      roster.ACTION.value="ROSTER_MODIFY";
      roster.teamid.value=id;
      var elementName = "teamname_"+id;
      var name = roster.elements[elementName].value;

roster.teamname.value=name;
      roster.submit();
      }

      function deleteTeam() {
      document.rosterlist.ACTION.value="ROSTER_DELETE";
      document.rosterlist.submit();
      }
    </script>
    <title><c:out value="${title}" /></title>
  </head>
  <body>
    <h1><c:out value="${title}" /></h1>
    <table border="1">
      <tr>
        <th>Team ID</th>
        <th>Team Name</th>
        <th>New Name</th>
        <th colspan="2">&nbsp;</th>
      </tr>
      <form name="rosterlist" action="<c:out value="${SERVLET_PATH}" />"
            method="POST">
        <input type="hidden" name="ACTION" value="ROSTER" />
        <input type="hidden" name="teamid" value="" />
        <input type="hidden" name="teamname" value="" />

        <c:forEach var="team" items="${roster}" >
          <tr>
          <td>${team.id}</td>
          <td>${team.name}</td>
          <td><input id="teamname_${team.id}" type="text" size="20" /></td>
          <td><input type="button" value="Modify"
                     onclick="modifyTeam('${team.id}')" /></td>
          <td><input name="DELETE_LIST" type="checkbox" value="${team.id}" /></td>
          </tr>
        </c:forEach>
        <tr>
          <td align="right" colspan="4">Delete selected items</td>
          <td><input type="button" value="Delete Checked"
                     onclick="deleteTeam()" /></td>
        </tr>
      </form>
      <form action="<c:out value="${SERVLET_PATH}" />" method="POST">
      <input type="hidden" name="ACTION" value="ROSTER_ADD" />
      <tr>
        <td colspan="2"><b>Add new Team</b></td>
        <td><input name="teamname" type="text" size="20" /></td>
        <td><input name="ADD" type="submit" value="Add" /></td>
        <td>&nbsp;</td>
      </tr>
    </table>
  </body>
</html>

package com.wrox.begjsp.ch23.football;

import java.io.IOException;
import java.sql.SQLException;
import java.util.List;

import javax.naming.NamingException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AdminServlet extends HttpServlet
{
    private static final String ROSTER_PAGE       = "roster.jsp";

    private static final String ACTION_TOKEN      = "ACTION";

    private static final String ACTION_ROSTER     = "ROSTER_LIST";
    private static final String ACTION_ROSTER_ADD = "ROSTER_ADD";
    private static final String ACTION_ROSTER_MOD = "ROSTER_MODIFY";
    private static final String ACTION_ROSTER_DEL = "ROSTER_DELETE";


    private FootyJDBCHelper     _jdbcHelper       = null;

    public void init() throws ServletException
    {
        try
        {
            _jdbcHelper = new FootyJDBCHelper();
        }
        catch (NamingException unexpected)
        {
            throw new ServletException("Cannot locate required database : " +
                                        unexpected);
        }
    }

public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException
    {
        doPost(request, response);
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException
    {
        String action = findAction(request);

        if (ACTION_ROSTER_ADD.equals(action))
        {
            String newNameString = request.getParameter("teamname");
            if (isValidString(newNameString))
            {
                processRosterAdd(newNameString);
            }
        }
        else if (ACTION_ROSTER_DEL.equals(action))
        {
            String deleteIDs[] = request.getParameterValues("DELETE_LIST");
            if (deleteIDs != null)
            {
                for (int i = 0; i < deleteIDs.length; i++)
                {
                    String idString = deleteIDs[i];
                    int id = Integer.parseInt(idString);
                    processRosterDelete(id);
                }
            }
        }
        else if (ACTION_ROSTER_MOD.equals(action))
        {
            String modIdString = request.getParameter("teamid");
            int modId = Integer.parseInt(modIdString);
            String modTeamName = request.getParameter("teamname");
            if (isValidString(modTeamName) && (modId > 0))
            {
                processRosterModify(new Team(modId, modTeamName));
            }
        }
        processRosterList(request);
        performRedirect(ROSTER_PAGE, request, response);
    }


    private void processRosterList(HttpServletRequest request)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();
            List teams = manager.getTeamsInRoster();

request.setAttribute("roster", teams);
        }
        catch (DataException unexpected)
        {
            log("Error processing roster list : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }
        }
    }

    private void processRosterDelete(int teamId)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();
            manager.deleteTeamFromRoster(teamId);
        }
        catch (DataException unexpected)
        {
            log("Error adding new team to roster : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }
        }
    }

    private void processRosterAdd(String newTeam)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();
            manager.addNewTeamToRoster(new Team(0, newTeam));
        }
        catch (DataException unexpected)
        {
            log("Error adding new team to roster : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }

}
    }

    private void processRosterModify(Team team)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();
            manager.modifyTeamInRoster(team);
        }
        catch (DataException unexpected)
        {
            log("Error modifying team in roster : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }
        }
    }

    private RosterManager getRosterManager() throws DataException
    {
        RosterManager manager;
        try
        {
            manager =
                RosterManagerFactory.createRosterManager(
                    _jdbcHelper.getConnection());
        }
        catch (SQLException connectionFailure)
        {
            throw new DataException(connectionFailure.getMessage());
        }
        return manager;
    }


    private boolean isValidString(String input)
    {
        return ((input != null) && (input.length() > 0));
    }

    private String findAction(HttpServletRequest request)
    {
        String action;
        if ((action = request.getParameter(ACTION_TOKEN)) == null)
        {
            action = ACTION_ROSTER;
        }
        return action;

}

    private void performRedirect(String path, HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException
    {
        if (path != null)
        {
            request.setAttribute("SERVLET_PATH", request.getContextPath()
                    + request.getServletPath());
            RequestDispatcher dispatch = request.getRequestDispatcher(path);
            dispatch.forward(request, response);
        }
    }
}

The AdminServlet is the coordination point for the application. It receives requests from the browser, checks for errors, and sends the request off to the appropriate method for processing.

The init() method creates an instance of the FootyJDBCHelper(). This object provides a simple means of looking up and getting database connections. The details for FootyJDBCHelper are shown in a later section of code.

The doPost() method identifies the appropriate action, and then calls the appropriate method to process the data from the browser. This works well for this simple example. More complicated applications with more actions and processes will find that an approach like this quickly becomes cumbersome. Jakarta Struts may be an appropriate framework to manage this complexity, and is described in detail in Chapter 19, "Struts Framework." However, Struts may be overkill for some applications, so a simplified mechanism for dealing with this complexity is shown in later sections.

processRosterList() is the first in a group of methods that are very similar. The all use an implementation of the RosterManager and a connection from the JDBC helper. The RosterManager provides an encapsulation of the database-specific code. RosterManager is an interface, and the reasons behind this choice will become more apparent as the chapter progresses. processRosterDelete(), processRosterAdd(), and processRosterModify() provide the additional methods that process the commands coming from the browser.

A very, very important consideration when building code that works with databases is cleaning up the resources used with each database interaction. Not closing the connection in the manner shown previously can lead to resource starvation.

Management of externally located resources is an important consideration for Web application development. Correctly identifying the error paths and exception paths through code, and making sure that the resources are always cleaned up, is a time-consuming, but necessary activity.

Comprehensive unit testing can assist with locating issues like resource mismanagement, and Chapters 25, "Performance," and 26, "Best Practices and Tools," contain some additional tips on this topic for readers who are curious to explore this further.

The method getRosterManager() is worthy of a little explanation. This method could be implemented by just creating a specific implementation of a RosterManager, as shown here:

private RosterManager getRosterManager()
    {
        return new JDBCRosterManager(
                              _jdbcHelper.getConnection());
    }

However, when the implementation changes to another mechanism—for example, a HibernateRosterManager—then it is necessary to change the AdminServlet. RosterManagerFactory implements all the logic for determining which version of the RosterManager will be used by the application.

This can be configured externally by an XML file, a properties file, or even by using deployment descriptor parameters. Not only can the application be installed on different application servers, it now can choose which mechanism it wants to use to persist the data, all of which is isolated in a couple of support classes, rather than scattered throughout the business logic of the application.

Some readers may consider this additional work excessive for small applications. The Web application shown here is about as small as it gets, and the additional work consisted of creating an interface and a very simple factory class to provide the concrete classes. When coupled with the testing advantages this approach provides, it should be considered a useful addition to even the smallest Web applications.

The remaining methods in AdminServlet are some utility methods for processing inputs and redirecting to an output page.

The final class to be entered is the most interesting in the context of database development. The JDBCRosterManager class contains all the JDBC-specific persistence code. This is where the application utilizes the JDBC objects for communicating with the database.

In the next section, this class is examined in more detail than the previous classes were because a number of new concepts are introduced.

package com.wrox.begjsp.ch23.football;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

public class JDBCRosterManager implements RosterManager
{
    private Connection _connection;

    public JDBCRosterManager(Connection connection)
    {
        _connection = connection;
    }
    public List getTeamsInRoster() throws DataException
    {
        List results = new ArrayList();
        Statement statement = null;
        try
        {
            statement = _connection.createStatement();
            ResultSet teams =
                    statement.executeQuery("SELECT * FROM roster ORDER BY id ASC");
            if (teams != null)
            {
                while (teams.next())
                {
                    int id = teams.getInt("id");
                    String name = teams.getString("teamname");
                    Team team = new Team(id, name);
                    results.add(team);
                }
            }
        }
        catch (SQLException unexpected)
        {
            throw new DataException(unexpected.getMessage());
        }
        finally
        {
            safeClose(statement);
        }
        return results;
    }
    private void safeClose(Statement statement)
    {
        try
        {
            if (statement != null)
            {

statement.close();
            }
        }
        catch (SQLException unexpected)
        {
            // ignore this
        }
    }

    public void releaseResources()
    {
        if (_connection != null)
        {
            try
            {
                _connection.close();
            }
            catch (SQLException unexpected)
            {
                // ignore this
            }
        }
    }
    public boolean addNewTeamToRoster(Team newTeam) throws DataException
    {
        PreparedStatement statement = null;
        boolean result = false;
        try
        {
            statement = _connection.prepareStatement(
                         "INSERT INTO roster (teamname) values (?)");
            statement.setString(1, newTeam.getName());

            result = statement.execute();
        }
        catch (SQLException unexpected)
        {
            throw new DataException(unexpected.getMessage());
        }
        finally
        {
            safeClose(statement);
        }
        return result;
    }

    public boolean modifyTeamInRoster(Team modifyTeam) throws DataException
    {
        PreparedStatement statement = null;
        boolean result = false;
        try
        {
            statement = _connection.prepareStatement(
                         "UPDATE roster set teamname = ? where id = ?");

statement.setString(1, modifyTeam.getName());
            statement.setInt(2, modifyTeam.getId());

            result = statement.execute();
        }
        catch (SQLException unexpected)
        {
            throw new DataException(unexpected.getMessage());
        }
        finally
        {
            safeClose(statement);
        }
        return result;
    }

    public boolean deleteTeamFromRoster(int teamId) throws DataException
    {
        PreparedStatement statement = null;
        boolean result = false;
        try
        {
            statement = _connection.prepareStatement(
                        "DELETE from roster where id = ?");
            statement.setInt(1, teamId);

            result = statement.execute();
        }
        catch (SQLException unexpected)
        {
            throw new DataException(unexpected.getMessage());
        }
        finally
        {
            safeClose(statement);
        }
        return result;
    }
}

The constructor for JDBCRosterManager allows the Connection to be provided to the object. This gives the controlling code much greater scope for determining what capabilities JDBCRosterManager will provide. For example, in testing JDBCRosterManager, there is the capacity to provide a Connection that checks to see if it has been closed correctly. This helps to ensure that the code using JDBCRosterManager and the JDBC Connection will operate correctly in a production environment.

The method getTeamsInRoster() is used to process the request for the list of teams. The creation of the Statement from the Connection enables a SQL statement to be processed by the database. The results of the query are returned in a ResultSet. The data in the ResultSet is processed to return a List of Team objects.

It may be very tempting to just return the ResultSet and let the JSP extract the data required. While this might be an appropriate solution for an application of limited complexity, writing applications in this manner causes implementation details that affect the database structure to be reflected in the display logic of the application. This unnecessarily causes ripple effects when changes are made to the database during development, or enhancements are added to the application.

Creating a layer that deals with database access, and then produces results in terms of the business domain—in our case, the Team object—enables the persistence mechanism to be transparently changed without affecting the rest of the application.

In the section on Hibernate (another persistence mechanism), the benefits of this decision will become apparent, as it can be implemented, replacing the JDBCRosterManager, without changing the rest of the application.

The getTeamsInRoster() method completes with a call to safeClose(). This again follows the approach of releasing resources as soon as practical. Closing the Statement will also close the ResultSet that is associated with the Statement.

The safeClose() and releaseResources() methods ignore the SQLException that can be thrown by the close() methods. In general, ignoring a SQLException is not a good practice, but if the close fails, there is little the application can do to address the situation. In a more production-focused application, it would be worth logging the SQLException, as this might indicate more fundamental problems with the environment and assist with locating the issue.

Adding the logging code to this example would not add to our discussion here, and may end up obscuring the more important concepts in this section.

addNewTeamToRoster(), modifyTeamInRoster(), and deleteTeamFromRoster() all use the PreparedStatement for sending commands to the database.

The PreparedStatement enables precompilation of the SQL, and the use of parameters to allow for different values to be included as part of the processing.

The final classes and interfaces for this Web application are included here for completeness. These are the RosterManager interface, and the RosterManagerFactory and FootyJDBCHelper classes.

Create the file RosterManager.java in the src/com/wrox/begjsp/ch23/football directory with the following contents:

package com.wrox.begjsp.ch23.football;

import java.util.List;

public interface RosterManager
{

    void releaseResources();

    List getTeamsInRoster() throws DataException;
    boolean addNewTeamToRoster(Team newTeam) throws DataException;
    boolean modifyTeamInRoster(Team modifyTeam) throws DataException;
    boolean deleteTeamFromRoster(int teamId) throws DataException;
}
This interface will expand over time. After the teams, the venue, round and fixture access methods need to be added as more functionality is developed.

Create the file RosterManagerFactory.java in the src/com/wrox/begjsp/ch23/football directory with the following contents:

package com.wrox.begjsp.ch23.football;

import java.sql.Connection;

public class RosterManagerFactory
{
    public static final String JDBC_MANAGER      = "JDBC";
    public static final String HIBERNATE_MANAGER = "HIBERNATE";

    private static String      _currentManager   = JDBC_MANAGER;

    public static void setRosterManagerType(String type)
    {
        _currentManager = type;
    }

    public static RosterManager createRosterManager(Connection connection)
    {
        if (JDBC_MANAGER.equals(_currentManager))
        {
            return new JDBCRosterManager(connection);
        }
        throw new IllegalStateException(_currentManager +
                                        " persistence not implemented");
    }
}

The RosterManagerFactory provides a transparent means of selecting the persistence mechanism. At this stage of the application, the only choice is the JDBCRosterManager. Later in the application, development of an alternative persistence mechanism will be implemented.

Create the file FootyJDBCHelper.java in the src/com/wrox/begjsp/ch23/football directory with the following contents:

package com.wrox.begjsp.ch23.football;

import java.sql.Connection;
import java.sql.SQLException;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

public class FootyJDBCHelper
{
    private DataSource _dataSource;

    public FootyJDBCHelper() throws NamingException
    {
        Context context = new InitialContext();
        Context applicationEnv = (Context)context.lookup("java:comp/env");
        _dataSource = (DataSource)applicationEnv.lookup("jdbc/FootyDB");
    }

    public Connection getConnection() throws SQLException
    {
        return _dataSource.getConnection();
    }
}

The FootyJDBCHelper provides a means to obtain a Connection from a JNDI DataSource, and is just a simple utility class to put the external lookup code in one place.

Running the application

To run the Web application, make sure the MySQL database is running, and that the Web application is deployed correctly to Tomcat, which is also running.

Browse to the following URL:

http://localhost:8080/chapter23/roster.jsp

This will display a page similar to Figure 23-2.

Figure 23.2. Roster management for football administration

It may seem that there was a lot of code written to perform a very simple Web input screen. The infrastructure code in the AdminServlet and the JDBCRosterManager provide a level of separation between the requests and responses to the Web front end and the loading and storing of data in the database. A small application does not do justice to the value of this separation; however, in later sections of this chapter, you will see the benefits of this separation as additional code is added to the Web application with a very small amount of effort.

This Web application uses a number of different JDBC classes and interfaces:

• DataSource: FootyJDBCHelper locates a DataSource via a JNDI lookup, and maintains a reference so that Connection objects can be obtained.

• Connection: FootyJDBCHelper.getConnection() returns a Connection so that it can be used by JDBCRosterManager to query the database.

• Statement, PreparedStatement: JDBCRosterManager uses a Connection to create Statements that execute SQL, which may return a ResultSet.

• ResultSet: JDBCRosterManager.getTeamsInRoster() loops through a ResultSet extracting the returned data and creating objects that will be used by the rest of the application.

Another important lesson is that database resources need to be managed carefully. If you fail to do this, you will end up with a very unreliable Web application.

The next section examines some of the aspects of building database-backed Web applications. Due to the multi-threaded, multi-user nature of a Web application, many of the more complex elements are immediately important and relevant to even the smallest Web application.

After discovering the power of the transaction to keep the data in the database and the application in a consistent, valid state, one might be tempted to use transactions everywhere. Again, there is no such thing as a free lunch, and transactions require careful use to avoid significant performance issues.

Imagine that for every read of the database, all of the data that was to be read was locked so no changes were possible. What benefit would that be for most applications? Certainly for a multi-user reporting application with no data updates, this would severely impact the performance, as each user has to wait for the previous user to complete the read.

The effects of isolation on a transaction can result in the application performing worse than it would without using transaction control at all. However, any JDBC query from a database will require a transaction. It appears that we've reached an impasse!

Luckily, there is a solution; the transaction isolation can be relaxed, lessening the constraints on the changes that can occur during the transaction. This relaxation, however, can produce other potential problems for the application:

With these potential problems identified, JDBC supports four isolation levels, as well as support for no transactions, but databases are not required to support these isolation levels, or even indicate what level of support they provide.

These isolation levels (including no transactions) are as follows:

The transaction isolation level is not set by the JDBC driver, but the default value is provided by the database, and can be updated by a call to Connection.setTransactionIsolation().

To run the Web application, make sure the MySQL database is running, and that the Web application is deployed correctly to Tomcat, which is also running.

Browse to the following URL:

http://localhost:8080/chapter23/round-input.jsp

This will display a page similar to Figure 23-3.

Figure 23.3. Round input management

Entering data in the input fields and clicking the Update button on round-input.jsp will post the form data to round-process.jsp. This provides an example of writing a Web application using no Java code at all.

The preceding code is very simple and took very little time to implement. There is limited checking of input data, and any data that isn't correctly formatted or of the correct value (for example, using xxx as the round number) produces erroneous results.

If we examine round-process.jsp, we see that it is possible to introduce logic to check the inputs for validity and redirect to error pages. However, the nature of writing more complex code in a JSP will rapidly lead to cumbersome pages that will become a maintenance nightmare over time. This is why it is recommended to use JSP for data capture and presentation, and servlets for the controlling logic for applications that have more complex requirements, and a longer active life.

Using this technique for developing Web applications is fantastic for prototyping and for working with customers or other developers to elicit further requirements. Rapid feedback of the visual interface, complete with realistic data, can assist in furthering the application's development.

Venue is a standard-looking JavaBean, except for the provision of the private setters and the default no-argument constructor. The Venue objects are immutable, and Hibernate can work with objects such as these in two ways. The method used in Venue.java is to provide private setters. Hibernate can then use those setters to populate the objects. The second method is shown in the file containing the Hibernate XML for Team.java shown previously. Hibernate can directly manipulate the fields of the object when the XML configuration for the property includes the access="field" attribute and value, as shown in the following example:

<property name="_name" column="teamname" access="field" type="string" />

Hibernate's developers do not recommend using the access="field" attribute, but this is for reasons of encapsulation, rather than any underlying technical issue. The choice of which approach to take is left in the hands of the application developer.

The next Try It Out example uses the persistent object just configured to create, load, and update data stored in the database. This section introduces the simple API that Hibernate provides to perform these operations.

package com.wrox.begjsp.ch23.football;

import java.util.List;

public interface RosterManager
{
    void releaseResources();

    List getVenuesInRoster() throws DataException;
    boolean addNewVenueToRoster(Venue venue) throws DataException;
    boolean deleteVenueFromRoster(int venueId) throws DataException;
    boolean modifyVenueInRoster(Venue venue) throws DataException;

}

package com.wrox.begjsp.ch23.football;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;

import net.sf.hibernate.HibernateException;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.Query;
import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.Transaction;
import net.sf.hibernate.cfg.Configuration;

public class HibernateRosterManager implements RosterManager
{
    private Connection     _connection;
    private SessionFactory _sessionFactory;
    private Session        _currentSession;

    public HibernateRosterManager(Connection connection)
    {
        _connection = connection;

        Configuration configuration = new Configuration();
        try
        {
            configuration.addClass(Venue.class);

}
        catch (MappingException mappingFailure)
        {
            throw new IllegalArgumentException(
                    "Cannot find required object classes, check CLASSPATH : " +
                     mappingFailure);
        }
        Properties props = new Properties();
        props.put("hibernate.dialect", "net.sf.hibernate.dialect.MySQLDialect");
        props.put("hibernate.statement_cache.size", "0");
        configuration.setProperties(props);

        try
        {
            _sessionFactory = configuration.buildSessionFactory();
        }
        catch (HibernateException sessionFailure)
        {
            throw new IllegalArgumentException(
                    "Cannot build session factory, check configuration : " +
                     sessionFailure);
        }
    }
    /*-- getting objects --*/
    public List getVenuesInRoster() throws DataException
    {
        return getAllItems("from Venue as venue order by venue.id asc");
    }

    private List getAllItems(String query) throws DataException
    {
        initSession();
        List list = null;
        try
        {
            Query allItems = _currentSession.createQuery(query);
            list = allItems.list();
        }
        catch (HibernateException unexpected)
        {
            throw new DataException(unexpected.getMessage());
        }
        finally
        {
            flushSession();
        }
        return list;
    }
    /*-- adding and modifying objects --*/
    public boolean addNewVenueToRoster(Venue venue) throws DataException
    {
        addOrModifyVenue(venue, "ADD");
    }

public boolean modifyVenueInRoster(Venue venue) throws DataException
    {
        addOrModifyVenue(venue, "MODIFY");
    }

    private boolean addOrModifyVenue(Venue venue, String action)
    {
        initSession();
        Transaction tx = null;
        try
        {
            tx = _currentSession.beginTransaction();
            _currentSession.saveOrUpdate(venue);
            tx.commit();
        }
        catch (HibernateException cannotSaveOrUpdate)
        {
            try
            {
                tx.rollback();
            }
            catch (HibernateException cannotRollback)
            {
                // log this error
            }
            throw new DataException("Unable to "+action+" venue : "+
                                     cannotSaveOrUpdate.getMessage());
        }
        finally
        {
            flushSession();
        }

        return false;
    }
    /*-- delete objects --*/
    public boolean deleteVenueFromRoster(int id) throws DataException
    {
        initSession();
        Transaction tx = null;
        try
        {
            tx = _currentSession.beginTransaction();
            Venue deleted = _currentSession.load(Venue.class, new Integer(id));
            _currentSession.delete(deleted);
            tx.commit();
        }
        catch (HibernateException cannotDelete)
        {
            try
            {
                tx.rollback();
            }
            catch (HibernateException cannotRollback)

{
                // log this error
            }
            throw new DataException("Unable to delete venue ["+id+"]: "+
                                     cannotDelete.getMessage());
        }
        finally
        {
            flushSession();
        }
        return false;
    }

    /*-- utility methods --*/
    private void initSession()
    {
        if (_currentSession == null)
        {
            _currentSession = _sessionFactory.openSession(_connection);
        }
    }

    private void flushSession()
    {
        try
        {
            if (_currentSession != null)
            {
                _currentSession.flush();
            }
        }
        catch (HibernateException sessionFlushFailure)
        {
            // log this error
        }
    }

    public void releaseResources()
    {
        if (_connection != null)
        {
            try
            {
                if (_currentSession != null)
                {
                    _currentSession.connection().close();
                    _currentSession.close();
                    _currentSession = null;
                }
                _connection.close();

            }
            catch (HibernateException sessionCloseFailure)
            {

// log this error
            }
            catch (SQLException connectionCloseFailure)
            {
                // log this error
            }
        }
    }
}

The HibernateRosterManager file contains all the code required to set up a Hibernate connection, find the configuration for the persistent objects, and work with the objects. The constructor contains all the necessary code for setting up Hibernate ready for use.

There are two ways to configure Hibernate. In this Try It Out example, you implement the programmatic method. This involves creating a Configuration object and setting the appropriate properties. The most common method is to create a Hibernate configuration file that is loaded. Hibernate supports a Properties format file (hibernate.properties), as well as an XML format configuration file (hibernate.cfg.xml).

The configuration must include the objects that are to be persisted. You do this by specifying the classes (as shown previously), or by specifying the hbm.xml files. If the hbm.xml files are in the same location as the objects, then Hibernate will locate them and load the mapping correctly.

Finally, the specific configuration for the database is required. hibernate.dialect is used so that Hibernate will generate the correct SQL and use the correct sequence generators (if available) when communicating with the database. To maintain interface compatibility with the JDBCRosterManager, the sessionFactory creates sessions with a provided Connection object. The second configuration item prevents PreparedStatements from being cached. This is required when an external Connection object is used to create sessions. Session creation is handled by the openSession() method on a session factory; an example of this is found later in the initSession() method.

To keep this example simple, the creation of the SessionFactory is included in the construction of the HibernateRosterManager.

The Session object created by the SessionFactory is used to perform all the actions on the persistent objects. This object provides the Hibernate methods to enable retrieval, addition, deletion, and modification of the data.

In the method getVenuesInRoster() is a call to a private method getAllItems(), with an appropriately structured query. The public interface for obtaining a list of Venue objects has been separated from the private implementation. This enables easy extension as more methods are added to the public interface, and allows the implementation to be changed if required without affecting the client code. This is an important concept when developing infrastructure so that other developers using the persistence layers do not have to continually update code as the persistence infrastructure matures

The methods addNewVenueToRoster () and modifyVenueInRoster () both use the same underlying private method addOrModifyVenue() to save or update the data. Hibernate provides a saveOrUpdate() method to deal with inserting new objects or updating existing object data. This reduces the amount of duplicated code that exists when using save() or update() methods independently. The second parameter to the public methods is only to provide additional information if the Hibernate methods fail.

Deleting objects is also simple and straightforward. The method deleteVenueFromRoster provides an example of how this is performed. The object is first loaded to confirm that it is exists; it would be a good idea to use additional error-checking prior to deleting a potentially nonexistent object. Then a call to the delete() method removes the object.

The methods initSession(), flushSession(), and releaseResources() are utility methods for dealing with the session and releasing resources as required. As with previous examples in this chapter, exceptions are caught and then ignored. This is not good practice, but for the sake of focusing on the important concepts in the example (the data interface), exception handling is deliberately ignored.

The next Try It Out example shows the data display and entry JSP for the venue data. This example ties together all the previous sections to create a working Web application.

<!--
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
-->
<jsp:useBean id="venues" class="java.util.ArrayList" scope="request" />
<jsp:useBean id="SERVLET_PATH" class="java.lang.String" scope="request" />
<c:set value="Team Venue Management" var="title" />
<html>
  <head>
    <script type="text/javascript" >
      function modifyVenue(id) {
      var venue = document.venuelist;
      venue.ACTION.value="VENUE_MODIFY";
      venue.venueid.value=id;
      var elementName = "venue_"+id;

var name = venue.elements[elementName].value;
      venue.venuename.value=name;
      venue.submit();
      }
      function deleteVenue() {
      document.venuelist.ACTION.value="VENUE_DELETE";
      document.venuelist.submit();
      }
    </script>
    <title><c:out value="${title}" /></title>
  </head>
  <body>
    <h1><c:out value="${title}" /></h1>
    <table border="1">
      <tr>
        <th>Venue ID</th>
        <th>Venue Name</th>
        <th colspan="2">&nbsp;</th>
      </tr>
      <form name="venuelist"
            action="<c:out value="${SERVLET_PATH}" />" method="POST">
        <input type="hidden" name="ACTION" value="VENUE" />
        <input type="hidden" name="venueid" value="" />
        <input type="hidden" name="venuename" value="" />
        <c:forEach var="venue" items="${venues}" >
          <tr>
            <td>${venue.id}</td>
            <td>${venue.location}</td>
            <td><input id="venue_${venue.id}" type="text" size="20" /></td>
            <td><input type="button"
                       value="Modify" onclick="modifyVenue('${venue.id}')" /></td>
            <td><input name="DELETE_LIST"
                       type="checkbox" value="${venue.id}" /></td>
          </tr>
        </c:forEach>
        <tr>
          <td align="right" colspan="4">Delete selected items</td>
          <td><input name="DELETE_BUTTON" type="button"
                     value="Delete Checked" onclick="deleteVenue()" /></td>
        </tr>
      </form>
      <form action="<c:out value="${SERVLET_PATH}" />" method="POST">
      <input type="hidden" name="ACTION" value="VENUE_ADD" />
      <tr>
        <td colspan="2"><b>Add new Venue</b></td>
        <td><input name="venuename" type="text" size="20" /></td>
        <td><input name="ADD" type="submit" value="Add" /></td>
        <td>&nbsp;</td>
      </tr>
    </table>
    <a href="menu.html">Main Menu</a>
  </body>
</html>

package com.wrox.begjsp.ch23.football;

import java.io.IOException;

import javax.naming.NamingException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AdminServlet extends HttpServlet
{
    private static final String DEFAULT_PAGE       = "menu.html";

    private static final String ACTION_TOKEN     = "ACTION";

    private static final String VENUE_ACTIONS    = "VENUE";
    private FootyJDBCHelper     _jdbcHelper      = null;

    public void init() throws ServletException
    {
        RosterManagerFactory.
                      setRosterManagerType(RosterManagerFactory.HIBERNATE_MANAGER);
        try
        {
            _jdbcHelper = new FootyJDBCHelper();
        }
        catch (NamingException unexpected)
        {
            throw new ServletException("Cannot locate required database : " +
                                        unexpected);
        }
    }

public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException
    {
        doPost(request, response);
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException
    {
        String action = findAction(request);

        ProcessingCommand command = null;
        if (action != null)
        {
            if (action.startsWith(VENUE_ACTIONS))
            {
                command = new VenueProcessingCommand(_jdbcHelper);
            }

            if (command != null)
            {
                command.execute(request, response, action);
                return;
            }
        }
        RequestDispatcher menu = request.getRequestDispatcher(DEFAULT_PAGE);
        menu.forward(request, response);
    }

    private String findAction(HttpServletRequest request)
    {
        return request.getParameter(ACTION_TOKEN);
    }
}

package com.wrox.begjsp.ch23.football;

import java.io.IOException;

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

public abstract class AbstractProcessingCommand implements ProcessingCommand
{

public abstract void execute(HttpServletRequest request,
                                 HttpServletResponse response,
                                 String action)
    throws ServletException, IOException;

    public final boolean isValidString(String input)
    {
        return ((input != null) && (input.length() > 0));
    }

    public final void performRedirect(String path, HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException
    {
        if (path != null)
        {
            request.setAttribute("SERVLET_PATH", request.getContextPath()
                    + request.getServletPath());
            RequestDispatcher dispatch = request.getRequestDispatcher(path);
            dispatch.forward(request, response);
        }
    }

}

package com.wrox.begjsp.ch23.football;

import java.io.IOException;
import java.sql.SQLException;
import java.util.List;

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

import org.apache.log4j.Logger;

public class VenueProcessingCommand extends AbstractProcessingCommand
{
    private static final Logger LOG = Logger.getLogger(
                                      VenueProcessingCommand.class);

    private static final String VENUE_PAGE       = "venue.jsp";
    private static final String VENUE_LIST_TOKEN = "venues";

    private static final String ACTION_VENUE_ADD = "VENUE_ADD";
    private static final String ACTION_VENUE_MOD = "VENUE_MODIFY";
    private static final String ACTION_VENUE_DEL = "VENUE_DELETE";

    private FootyJDBCHelper     _helper          = null;

public VenueProcessingCommand(FootyJDBCHelper helper)
    {
        _helper = helper;
    }

    public void execute(HttpServletRequest request,
                        HttpServletResponse response, String action)
            throws ServletException, IOException
    {
        if (ACTION_VENUE_ADD.equals(action))
        {
            String newNameString = request.getParameter("venuename");
            if (isValidString(newNameString))
            {
                processVenueAdd(newNameString);
            }
        }
        else if (ACTION_VENUE_DEL.equals(action))
        {
            String deleteIDs[] = request.getParameterValues("DELETE_LIST");
            if (deleteIDs != null)
            {
                for (int i = 0; i < deleteIDs.length; i++)
                {
                    String idString = deleteIDs[i];
                    int id = Integer.parseInt(idString);
                    processVenueDelete(id);
                }
            }
        }
        else if (ACTION_VENUE_MOD.equals(action))
        {
            String modIdString = request.getParameter("venueid");
            int modId = Integer.parseInt(modIdString);
            String modVenue = request.getParameter("venuename");
            if (isValidString(modVenue) && (modId > 0))
            {
                processVenueModify(new Venue(modId, modVenue));
            }
        }
        processVenueList(request);
        performRedirect(VENUE_PAGE, request, response);
    }
    private void processVenueModify(Venue venue)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();
            manager.modifyVenueInRoster(venue);
        }
        catch (DataException unexpected)
        {

LOG.error("Error modifying venue : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }
        }
    }

    private void processVenueDelete(int teamId)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();
            manager.deleteVenueFromRoster(teamId);
        }
        catch (DataException unexpected)
        {
            LOG.error("Error deleting venue : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }
        }
    }

    private void processVenueAdd(String newVenue)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();
            manager.addNewVenueToRoster(new Venue(0, newVenue));
        }
        catch (DataException unexpected)
        {
            LOG.error("Error adding new venue : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }
        }
    }

    private void processVenueList(HttpServletRequest request)

{
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();
            List venue = manager.getVenuesInRoster();
            request.setAttribute(VENUE_LIST_TOKEN, venue);
        }
        catch (DataException unexpected)
        {
            LOG.error("Error processing venue list : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }
        }
    }

    private RosterManager getRosterManager() throws DataException
    {
        RosterManager manager;
        try
        {
            manager = RosterManagerFactory.createRosterManager(
                                           _helper.getConnection());
        }
        catch (SQLException connectionFailure)
        {
            throw new DataException(connectionFailure.getMessage());
        }
        return manager;
    }
}

<html>
  <head>Football Administration Menu</head>
  <body>
    <ul>
      <li><a href="round-input.jsp">Round</a></li>
      <li><a href="admin?ACTION=VENUE_LIST">Venue</a></li>
    </ul>
  </body>
</html>

The first part of the servlet defines some constants for working with the different requests from the Web browser. Notice how the definitions of the ROSTER_ACTIONS and VENUE_ACTIONS are strings that represents the first part of the group of actions for that type of data. The venue.jsp has a number of actions such as VENUE_ADD and VENUE_DELETE, which are used in the AdminServlet.doPost() method to determine which operation to perform. A very simple HTML-based menu called menu.html has been created and is used to select between the various administration tasks.

The actions that are specific to each particular data-entry screen have been removed from the AdminServlet and moved to classes that will process the data-entry requirements for each data-entry area. This is an important step in keeping complexity under control; imagine how large the AdminServlet would become if there were ten different data-entry screens, each having a list, add, modify, and delete action.

The code in AdminServlet.doPost() replaces all the previous roster processing code and also includes the venue processing code. As more processing is required, implementations of ProcessingCommand can be provided for each group of actions. This enables the AdminServlet to focus on determining which command to execute, with the commands themselves containing the processing code.

AdminServlet.findAction() has been simplified in this version to identify when a request is made without supplying an action. In this case, the method will return null to indicate that status and is handled by the AdminServlet.doPost() method by redirecting to the menu page. It would have been possible to create a NullProcessingCommand() to deal with this option, but this was simpler.

The ProcessingCommands are now responsible for processing each of the groups of actions for a particular set of data. The example of the VenueProcessingCommand shows a template for how the remaining ProcessingCommands should be implemented.

The VenueProcessingCommand now contains all the constants that were defined in the AdminServlet specific to the processing of requests relating to the venue data. This enables the AdminServlet to focus on coordination and the ProcessingCommand to work with the required data.

The changes to the code are long, but are reasonably simple; the code that was in AdminServlet.doPost() has been moved to the VenueProcessingCommand.execute() method. The AdminServlet selects a command to run and then invokes a method to run the command. The remaining methods are the workers that perform the tasks for the identified actions, finding a persistence manager and then calling the appropriate method.

Browse to the following URL:

http://localhost:8080/chapter23/menu.html

This will display the simple menu available. Click the link for Venue and after a short delay while the database connection is established and the Hibernate mapping files are processed, this should display a page similar to the one shown in Figure 23-4.

Figure 23.4. Venue management

package com.wrox.begjsp.ch23.football;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

public class Round
{
    private int  _id;
    private int  _roundNumber;
    private Date _startDate;
    private Date _endDate;

    public Round(int id, int roundNumber, Date startDate, Date endDate)
    {
        _id = id;
        _roundNumber = roundNumber;
        _startDate = startDate;
        _endDate = endDate;
    }

    public int getId()
    {
        return _id;
    }

    public Date getStartDate()
    {
        return _startDate;
    }

    public int getRoundNumber()
    {
        return _roundNumber;
    }

    public Date getEndDate()
    {
        return _endDate;
    }

    public boolean equals(Object obj)
    {

if (obj instanceof Round)
        {
            Round compare = (Round)obj;
            return (_id == compare.getId());
        }
        return false;
    }

    public int hashCode()
    {
        int hash = 7;
        hash = 31 * hash + _id;
        hash = 31 * hash + _roundNumber;
        return hash;
    }

    public String toString()
    {
        return getClass() + "[" + _id + "] : [" + _roundNumber + "]";
    }

    private Round()
    {
        // required for hibernate
    }

    private void setEndDate(Date endDate)
    {
        _endDate = endDate;
    }

    private void setRoundNumber(int roundNumber)
    {
        _roundNumber = roundNumber;
    }

    private void setStartDate(Date startDate)
    {
        _startDate = startDate;
    }

    private void setId(int id)
    {
        _id = id;
    }
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
   "-//Hibernate/Hibernate Mapping DTD//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
  <class name="com.wrox.begjsp.ch23.football.Round" table="round">
    <id name="id" column="id" type="integer" unsaved-value="0">
      <generator class="native" />
    </id>
    <property name="roundNumber" column="number" type="int" />
    <property name="startDate" column="startdate" type="date" />
    <property name="endDate" column="enddate" type="date" />
  </class>
</hibernate-mapping>

package com.wrox.begjsp.ch23.football;

public class Team
{
    private int    _id;
    private String _name;

    public Team(int id, String name)
    {
        _id = id;
        _name = name;
    }

    public int getId()
    {
        return _id;
    }

    public String getName()
    {
        return _name;
    }

    public boolean equals(Object obj)
    {
        if (obj instanceof Team)
        {
            Team compare = (Team)obj;
            return (_id == compare.getId());
        }
        return false;
    }

    public int hashCode()

{
        return _name.hashCode();
    }

    public String toString()
    {
        return getClass() + "[" + _id + "] : [" + _name + "]";
    }

    private Team()
    {
        // required for hibernate
    }

    private void setId(int id)
    {
        _id = id;
    }

    private void setName(String name)
    {
        _name = name;
    }
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
   "-//Hibernate/Hibernate Mapping DTD//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
  <class name="com.wrox.begjsp.ch23.football.Team" table="roster">
    <id name="id" column="id" type="integer" unsaved-value="0">
      <generator class="native" />
    </id>
    <property name="name" column="teamname" type="string" />
  </class>
</hibernate-mapping>

package com.wrox.begjsp.ch23.football;

public class Fixture
{
    private int   _id;
    private Round _round;
    private Team  _homeTeam;

private Team  _awayTeam;
    private Venue _venue;

    public Fixture(int id, Round round, Team homeTeam, Team awayTeam, Venue venue)
    {
        _id = id;
        _round = round;
        _homeTeam = homeTeam;
        _awayTeam = awayTeam;
        _venue = venue;
    }

    public Team getAwayTeam()
    {
        return _awayTeam;
    }

    public Team getHomeTeam()
    {
        return _homeTeam;
    }

    public int getId()
    {
        return _id;
    }

    public Round getRound()
    {
        return _round;
    }

    public Venue getVenue()
    {
        return _venue;
    }

    public boolean equals(Object obj)
    {
        if (obj instanceof Fixture)
        {
            Fixture compare = (Fixture)obj;
            return (_id == compare.getId());
        }
        return false;
    }

    public int hashCode()
    {
        int hash = 7;
        hash = 31 * hash + _id;
        hash = 31 * hash + (_round == null ? 0 : _round.hashCode());
        hash = 31 * hash + (_homeTeam == null ? 0 : _homeTeam.hashCode());
        hash = 31 * hash + (_awayTeam == null ? 0 : _awayTeam.hashCode());

hash = 31 * hash + (_venue == null ? 0 : _venue.hashCode());
        return hash;
    }

    public String toString()
    {
        return getClass() + "[" + _id + "]";
    }

    private Fixture()
    {
        // required for hibernate
    }

    private void setAwayTeam(Team awayTeam)
    {
        _awayTeam = awayTeam;
    }

    private void setHomeTeam(Team homeTeam)
    {
        _homeTeam = homeTeam;
    }

    private void setId(int id)
    {
        _id = id;
    }

    private void setRound(Round round)
    {
        _round = round;
    }

    private void setVenue(Venue venue)
    {
        _venue = venue;
    }
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
   "-//Hibernate/Hibernate Mapping DTD//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
  <class name="com.wrox.begjsp.ch23.football.Fixture" table="fixture">
    <id name="id" column="id" type="integer" unsaved-value="0">
      <generator class="native" />
    </id>
    <many-to-one name="round" column="roundid" />
    <many-to-one name="homeTeam" column="hometeam" />
    <many-to-one name="awayTeam" column="awayteam" />
    <many-to-one name="venue" column="venueid" />
  </class>
</hibernate-mapping>

package com.wrox.begjsp.ch23.football;

import java.io.IOException;
import java.sql.SQLException;
import java.util.List;

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

import org.apache.log4j.Logger;

public class FixtureProcessingCommand extends AbstractProcessingCommand
{
    private static final Logger LOG = Logger.getLogger(
                                             FixtureProcessingCommand.class);

    private static final String FIXTURE_PAGE       = "fixture.jsp";

    // for the dropdown menus
    private static final String ROUND_LIST_TOKEN   = "rounds";
    private static final String TEAM_LIST_TOKEN    = "teams";
    private static final String VENUE_LIST_TOKEN   = "venues";
    private static final String FIXTURE_LIST_TOKEN = "fixtures";

    private static final String ACTION_FIXTURE_ADD = "FIXTURE_ADD";
    private static final String ACTION_FIXTURE_DEL = "FIXTURE_DELETE";

    private FootyJDBCHelper     _helper            = null;

    public FixtureProcessingCommand(FootyJDBCHelper helper)
    {
        _helper = helper;
    }

    public void execute(HttpServletRequest request,
                        HttpServletResponse response, String action)

throws ServletException, IOException
    {
        if (ACTION_FIXTURE_ADD.equals(action))
        {
            String roundIdString = request.getParameter("round_id");
            String awayTeamIdString = request.getParameter("away_team_id");
            String homeTeamIdString = request.getParameter("home_team_id");
            String venueIdString = request.getParameter("venue_id");

            processFixtureAdd(Integer.parseInt(roundIdString),
                        Integer.parseInt(awayTeamIdString),
                        Integer.parseInt(homeTeamIdString),
                        Integer.parseInt(venueIdString));
        }

        else if (ACTION_FIXTURE_DEL.equals(action))
        {
            String deleteIDs[] = request.getParameterValues("DELETE_LIST");
            if (deleteIDs != null)
            {
                for (int i = 0; i < deleteIDs.length; i++)
                {
                    String idString = deleteIDs[i];
                    int id = Integer.parseInt(idString);
                    processFixtureDelete(id);
                }
            }
        }
        processFixtureList(request);
        performRedirect(FIXTURE_PAGE, request, response);
    }

    private void processFixtureDelete(int fixtureId)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();
            manager.deleteFixtureFromRoster(fixtureId);
        }
        catch (DataException unexpected)
        {
            LOG.error("Error deleting fixture : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }
        }
    }

private void processFixtureAdd(int roundId, int homeTeamId,
                                   int awayTeamId, int venueId)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();

            Round round = manager.getRoundById(roundId);
            Team homeTeam = manager.getTeamById(homeTeamId);
            Team awayTeam = manager.getTeamById(awayTeamId);
            Venue venue = manager.getVenueById(venueId);

            manager.addNewFixtureToRoster(new Fixture(0, round,
                                              homeTeam, awayTeam, venue));
        }
        catch (DataException unexpected)
        {
            LOG.error("Error adding new fixture : " + unexpected);
        }
        finally
        {
            if (manager != null)
            {
                manager.releaseResources();
            }
        }
    }

    private void processFixtureList(HttpServletRequest request)
    {
        RosterManager manager = null;
        try
        {
            manager = getRosterManager();

            List venues = manager.getVenuesInRoster();
            List teams = manager.getTeamsInRoster();
            List rounds = manager.getRoundsInRoster();
            List fixtures = manager.getFixturesInRoster();

            request.setAttribute(FIXTURE_LIST_TOKEN, fixtures);
            request.setAttribute(TEAM_LIST_TOKEN, teams);
            request.setAttribute(ROUND_LIST_TOKEN, rounds);
            request.setAttribute(VENUE_LIST_TOKEN, venues);
        }
        catch (DataException unexpected)
        {
            LOG.error("Error processing fixture list : " + unexpected);
        }
        finally
        {
            if (manager != null)

{
                manager.releaseResources();
            }
        }
    }


    private RosterManager getRosterManager() throws DataException
    {
        RosterManager manager;
        try
        {
            manager = RosterManagerFactory.createRosterManager(
                                           _helper.getConnection());
        }
        catch (SQLException connectionFailure)
        {
            throw new DataException(connectionFailure.getMessage());
        }
        return manager;
    }
}

package com.wrox.begjsp.ch23.football;

import java.util.List;

public interface RosterManager
{
    void releaseResources();

    List getTeamsInRoster() throws DataException;
    boolean addNewTeamToRoster(Team newTeam) throws DataException;
    boolean modifyTeamInRoster(Team modifyTeam) throws DataException;
    boolean deleteTeamFromRoster(int teamId) throws DataException;

    List getVenuesInRoster() throws DataException;
    boolean addNewVenueToRoster(Venue venue) throws DataException;
    boolean deleteVenueFromRoster(int venueId) throws DataException;
    boolean modifyVenueInRoster(Venue venue) throws DataException;

    List getFixturesInRoster() throws DataException;
    boolean addNewFixtureToRoster(Fixture fixture) throws DataException;
    boolean deleteFixtureFromRoster(int fixtureId) throws DataException;
    boolean modifyFixtureInRoster(Fixture fixture) throws DataException;

}

package com.wrox.begjsp.ch23.football;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;

import net.sf.hibernate.HibernateException;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.Query;
import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.Transaction;
import net.sf.hibernate.cfg.Configuration;

public class HibernateRosterManager implements RosterManager
{
    private static final String ADD_DATA_ACTION    = "ADD";
    private static final String MODIFY_DATA_ACTION = "MODIFY";

    private Connection          _connection;
    private SessionFactory      _sessionFactory;
    private Session             _currentSession;

    public HibernateRosterManager(Connection connection)
    {
        _connection = connection;

        Configuration configuration = new Configuration();
        try
        {
            configuration.addClass(Team.class);
            configuration.addClass(Venue.class);
            configuration.addClass(Round.class);
            configuration.addClass(Fixture.class);
        }
        catch (MappingException mappingFailure)
        {
            throw new IllegalArgumentException(
                    "Cannot find required object classes, check CLASSPATH : " +
                     mappingFailure);
        }

        Properties props = new Properties();
        props.put("hibernate.dialect", "net.sf.hibernate.dialect.MySQLDialect");
        props.put("hibernate.statement_cache.size", "0");
        configuration.setProperties(props);

        try
        {

_sessionFactory = configuration.buildSessionFactory();
        }
        catch (HibernateException sessionFailure)
        {
            throw new IllegalArgumentException(
                    "Cannot build session factory, check configuration : " +
                     sessionFailure);
        }
    }

    /*-- getting objects --*/
    public List getTeamsInRoster() throws DataException
    {
        return getAllItems("from Team as team order by team.name asc");
    }

    public List getVenuesInRoster() throws DataException
    {
        return getAllItems("from Venue as venue order by venue.location asc");
    }

    public List getRoundsInRoster() throws DataException
    {
        return getAllItems("from Round as round order by round.roundNumber asc");
    }

    public List getFixturesInRoster() throws DataException
    {
        return getAllItems("from Fixture as fixture order by fixture.id asc");
    }

    private List getAllItems(String query) throws DataException
    {
        initSession();
        List list = null;
        try
        {
            Query allTeams = _currentSession.createQuery(query);
            list = allTeams.list();
        }
        catch (HibernateException unexpected)
        {
            throw new DataException(unexpected.getMessage());
        }
        finally
        {
            flushSession();
        }
        return list;
    }

    /*-- adding and modifying objects --*/
    public boolean addNewTeamToRoster(Team team) throws DataException
    {

return addOrModifyObject(team, ADD_DATA_ACTION);
    }

    public boolean addNewVenueToRoster(Venue venue) throws DataException
    {
        return addOrModifyObject(venue, ADD_DATA_ACTION);
    }

    public boolean modifyTeamInRoster(Team team) throws DataException
    {
        return addOrModifyObject(team, MODIFY_DATA_ACTION);
    }

    public boolean modifyVenueInRoster(Venue venue) throws DataException
    {
        return addOrModifyObject(venue, MODIFY_DATA_ACTION);
    }

    public boolean addNewFixtureToRoster(Fixture newFixture) throws DataException
    {
        return addOrModifyObject(newFixture, ADD_DATA_ACTION);
    }

    public boolean modifyFixtureInRoster(Fixture fixture) throws DataException
    {
        throw new UnsupportedOperationException(
                "Modify a Fixture not supported, use delete, then add");
    }

    private boolean addOrModifyObject(Object object, String action)
    throws DataException
    {
        initSession();
        Transaction tx = null;
        try
        {
            tx = _currentSession.beginTransaction();
            _currentSession.saveOrUpdate(object);
            tx.commit();
        }
        catch (HibernateException cannotSaveOrUpdate)
        {
            try
            {
                tx.rollback();
            }
            catch (HibernateException cannotRollback)
            {
                // log this error
            }
            throw new DataException("Unable to " + action + " : " +
                                     cannotSaveOrUpdate.getMessage());
        }

finally
        {
            flushSession();
        }

        return false;
    }

    /*-- loading by id --*/
    public Round getRoundById(int id) throws DataException
    {
        return (Round)loadObjectById(Round.class, id);
    }

    public Team getTeamById(int id) throws DataException
    {
        return (Team)loadObjectById(Team.class, id);
    }

    public Venue getVenueById(int id) throws DataException
    {
        return (Venue)loadObjectById(Venue.class, id);
    }

    public Fixture getFixtureById(int id) throws DataException
    {
        return (Fixture)loadObjectById(Fixture.class, id);
    }

    private Object loadObjectById(Class clazz, int id) throws DataException
    {
        initSession();
        Object rv = null;
        try
        {
            rv = _currentSession.load(clazz, new Integer(id));
        }
        catch (HibernateException unexpected)
        {
            throw new DataException(unexpected.getMessage());
        }
        finally
        {
            flushSession();
        }
        return rv;
    }

    /*-- delete objects --*/
    public boolean deleteTeamFromRoster(int id) throws DataException
    {
        return deleteObject(Team.class, id);
    }

public boolean deleteVenueFromRoster(int id) throws DataException
    {
        return deleteObject(Venue.class, id);
    }

    public boolean deleteFixtureFromRoster(int id) throws DataException
    {
        return deleteObject(Fixture.class, id);
    }

    private boolean deleteObject(Class clazz, int id) throws DataException
    {
        initSession();
        Transaction tx = null;
        try
        {
            tx = _currentSession.beginTransaction();
            Object aboutToBeDeleted = loadObjectById(clazz, id);
            _currentSession.delete(aboutToBeDeleted);
            tx.commit();
        }
        catch (HibernateException cannotDelete)
        {
            try
            {
                tx.rollback();
            }
            catch (HibernateException cannotRollback)
            {
                // log this error
            }
            throw new DataException("Unable to delete  : " +
                                    cannotDelete.getMessage());
        }
        finally
        {
            flushSession();
        }
        return false;
    }

    /*-- utility methods --*/
    private void initSession()
    {
        if (_currentSession == null)
        {
            _currentSession = _sessionFactory.openSession(_connection);
        }
    }

    private void flushSession()
    {
        try

{
            if (_currentSession != null)
            {
                _currentSession.flush();
            }
        }
        catch (HibernateException sessionFlushFailure)
        {
            // log this error
        }
    }

    public void releaseResources()
    {
        if (_connection != null)
        {
            try
            {
                if (_currentSession != null)
                {
                    _currentSession.connection().close();
                    _currentSession.close();
                    _currentSession = null;
                }
                _connection.close();

            }
            catch (HibernateException sessionCloseFailure)
            {
                // log this error
            }
            catch (SQLException connectionCloseFailure)
            {
                // log this error
            }
        }
    }
}

<!--
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
-->
<jsp:useBean id="fixtures" class="java.util.ArrayList" scope="request" />
<jsp:useBean id="teams" class="java.util.ArrayList" scope="request" />
<jsp:useBean id="rounds" class="java.util.ArrayList" scope="request" />
<jsp:useBean id="venues" class="java.util.ArrayList" scope="request" />
<jsp:useBean id="SERVLET_PATH" class="java.lang.String" scope="request" />

<c:set value="Team Fixture Management" var="title" />
<html>
  <head>
    <title><c:out value="${title}" /></title>
  </head>
  <body>
    <h1><c:out value="${title}" /></h1>
    <table border="1">
      <tr>
        <th>Fixture ID</th>
        <th>Round #</th>
        <th>Home Team</th>
        <th>Away Team</th>
        <th>Venue</th>
        <th colspan="2">&nbsp;</th>
      </tr>
      <form name="fixturelist" action="<c:out value="${SERVLET_PATH}" />"
            method="POST">
        <input type="hidden" name="ACTION" value="FIXTURE_DELETE" />
        <c:forEach var="fixture" items="${fixtures}" >
          <tr>
            <td>${fixture.id}</td>
            <td>${fixture.round.roundNumber}</td>
            <td>${fixture.homeTeam.name}</td>
            <td>${fixture.awayTeam.name}</td>
            <td>${fixture.venue.location}</td>
            <td><input name="DELETE_LIST" type="checkbox"
                 value="${fixture.id}" /></td>
          </tr>
        </c:forEach>
        <tr>
          <td align="right" colspan="5">Delete selected items</td>
          <td><input name="DELETE_BUTTON" type="submit"
               value="Delete Checked" /></td>
        </tr>
      </form>
      <form action="<c:out value="${SERVLET_PATH}" />" method="POST">
      <input type="hidden" name="ACTION" value="FIXTURE_ADD" />
      <tr>
        <td>&nbsp;</td>
        <td>
          <select name="round_id">
            <c:forEach var="round" items="${rounds}" >
              <option value="${round.id}">${round.roundNumber}</option>
            </c:forEach></select>
        </td>
        <td>
          <select name="home_team_id">
            <c:forEach var="homeTeam" items="${teams}" >
              <option value="${homeTeam.id}">${homeTeam.name}</option>
            </c:forEach>
          </select>
        </td>

<td>
          <select name="away_team_id">
            <c:forEach var="awayTeam" items="${teams}" >
              <option value="${awayTeam.id}">${awayTeam.name}</option>
            </c:forEach>
          </select>
        </td>
        <td>
          <select name="venue_id">
            <c:forEach var="venue" items="${venues}" >
              <option value="${venue.id}">${venue.location}</option>
            </c:forEach>
          </select>
        </td>
        <td><input name="ADD" type="submit" value="Add Fixture" /></td>
      </tr>
    </table>
    <a href="menu.html">Main Menu</a>
  </body>
</html>

<html>
  <head>Football Administration Menu</head>
  <body>
    <ul>
      <li><a href="round-input.jsp">Round</a></li>
      <li><a href="admin?ACTION=VENUE_LIST">Venue</a></li>
      <li><a href="admin?ACTION=FIXTURE_LIST">Fixture</a></li>
    </ul>
  </body>
</html>

The Web application has grown to a reasonably complex application, with a significant proportion of the functionality required to manage the data for the football roster implemented. The fixture data management shows how Hibernate can manage relationships between objects in a very convenient way for the Web application developer without having to resort to cumbersome and repetitive SQL. Under the covers of the Hibernate libraries, SQL is still issued to the database via the JDBC interfaces. The Hibernate team has done a comprehensive job of shielding the developer from needing to understand the complexity of the underlying SQL.

Notice how the Fixture class is very "Java-like." It's an object, and it contains other objects. It was difficult to see this in previous parts of the example, as the other objects map very closely to their relational database representations with only simple fields. The persistence of different types of objects with relationships between objects is where Hibernate shines.

In many projects, the Fixture class would be implemented with the following fields:

private int   _id;
    private int   _roundId;
    private int   _homeTeamId;
    private int   _awayTeamId;
    private int   _venueId;

This would make it very easy to map to a database and avoid much of the complicated JDBC code normally found with hand-built ORM, but it sacrifices the advantages of using Java as the programming language.

Hibernate removes the complication, enabling Java developers to express their business objects in a far more expressive and natural manner.

The Fixture.hbm.xml mapping file should appear quite familiar, except for the new element, many-to-one, that has been introduced. The choice of the many-to-one element may seem a little unusual. However, that's the relationship that Fixture has with Round (or Team and Venue), a unidirectional many-to-one association. The relationship is only one way (from Fixture to Round) and the column roundid in the fixture table is a foreign key for the primary key column for the Round object.

Notice how the <many-to-one> elements specify only the field (round, homeTeam, and so on) that contains the object. Hibernate uses runtime reflection to determine the actual class name, locates the appropriate mapping file, and then performs the appropriate mapping for the foreign key. How cool is that!

The class attribute can be used in the <many-to-one> mapping to make the relationship more explicit:

<many-to-one name="homeTeam" class="Team" column="hometeam" />

Browse to the following URL:

http://localhost:8080/chapter23/menu.html

This will display the simple menu available. Click the link for Fixture. This should show a screen similar to the one shown in Figure 23-5.

Similar to the other JSP output shown previously, the table contains the list of existing fixtures, with check boxes for the deletion of fixtures and addition of new fixtures. However, unlike other JSP examples the fixtures are all added via drop-down lists of currently available records.

Figure 23.5. Team fixture management

The adding of fixtures is done by using existing data created by other screens. The drop-down menus contain lists of data that are chosen to create the fixture. The Fixture processing is managed in a symmetrical way to the Venue processing, via the implementation of a ProcessingCommand.

The FixtureProcessingCommand is very similar to the existing VenueProcessingCommand, converting the parameters contained in the HttpServletRequest into the correct values and invoking the appropriate RosterManager methods.

The Strings defined at the start of the class are used by fixture.jsp to load lists of data obtained from the database.

The add action occurs when the action parameter equals the constant ACTION_FIXTURE_ADD, obtaining the parameters from the fixture.jsp POST and converting it into objects that represent the foreign key values. In a production quality system, better checking of the input values would be mandatory, but for this example they are skipped for clarity.

To add the new Fixture, the processFixtureAdd() method is called, and the parameters obtained from the Web application are used to load the objects from the database. Again, this would be a good place to add some error-checking to ensure that the objects returned exist prior to adding the new Fixture.

The processFixtureList() method loads a number of collections of objects into request scope so the fixture.jsp can render the lists appropriately. The fixtures list is used to display the currently existing fixtures, and the venues, teams, and rounds are used to display the drop-down lists on the page.

The HibernateRosterManager has been modified to include the new fixture processing functionality. The new elements are highlighted in the following code.

The configuration created in the constructor now includes all four objects requiring persistence.

The value in extracting out the common functionality for the query of objects becomes more apparent as more objects are added. The getXXXInRoster() methods all call the same method to perform the work. Adding extra objects now only requires minor additions to the HibernateRosterManager, which can be done safely and without spending significant time.

Moving down the class, more common functionality is performed in one method: addXXXToRoster() and modifyXXXInRoster() both call the addOrModifyObject() method. The alternative is to have four separate implementations of addOrModifyObject(), one for each persistent object. This would cause excessive code duplication, which makes modification more complex and error prone.

Similarly, the loadObjectById() method provides a common method for the associated type-specific public interfaces. The use of the Class as a parameter to _currentSession.load() provides the necessary information to Hibernate to correctly locate the appropriate object based on the primary key. This is a very powerful feature of Hibernate that provides convenient implementation options for the developer. Instead of having to write conditional code for each object type, this is handled transparently by Hibernate, which significantly reduces the work of the Web application developer and greatly reduces the likelihood of errors creeping into the code.

The pattern repeats for the deleteObject() method. However, to obtain the appropriate object to delete, the loadObjectById() method is called. This will find the object to be deleted to ensure that it exists. This is a slightly different pattern from the other methods, and at first glance seems very strange. Why create an object just for the purpose of deleting it?

The alternative is to create an identity object holding just the id in the deleteXXXXFromRoster() methods. However, that may require the addition of a specific constructor that takes only the id as a parameter, as shown here:

deleteObject(new Team(id));

Alternatively, you can relax the error-checking in the constructor, allowing null values to be passed into the object:

deleteObject(new Team(id, null);

Finally, you can enable the construction of temporary objects specifically for deletion:

deleteObject(new Team(id, "deleteMe"));

While these options are possible, none of them are particularly clean; and with more complex objects, they start to look far less attractive:

deleteObject(new Fixture(id, (Round)null, (Team)null, (Team)null, (Venue)null));

The downside of creating an identity object is that these techniques make it impossible for the rest of the application to now rely on the consistent state of the persistent objects. Creating an identity object might be appropriate for very short-lived objects that exist only in the persistence management layer of the application. However, another developer may choose to use one of the identity object creation methods in another part of the application, causing major errors to occur. It is not a good idea to create objects that exist in an illegal state under most circumstances, especially when there are alternatives.

Hibernate will work with any of the preceding options, but these are generally considered a workaround to enable persistence, and it is a better idea to load the object prior to deletion.

The fixture.jsp is similar to the previous JSP, but the use of the collections of objects to create the drop-down lists is something not shown before. Nonetheless, it's a very common feature to be found in Web applications accessing databases. Single and multiple selections of data from lists drive many Web user interfaces.

When developing the Web application, remember that even though the data from the database was used to create the initial lists, there is no guarantee that when the form data is sent back to the server the information represented by the keys exists. The data may have been deleted or the user may be maliciously trying to cause errors. This is another good reason to be vigilant about checking the data coming from Web browsers, and validating the use of that data within the Web application.

The Hibernate example shown in this chapter only scratches the surface of the power available to the developer using this tool. Additionally, Hibernate provides support for collections of data, lazy-loading of child objects to prevent a cascade of objects from loading with the parent object, and many-to-many relationships. The Hibernate Query Language (HQL) also provides extensive means for working with selecting complex graphs of objects.

Developers with a further interest in this topic should read Professional Hibernate by Eric Pugh and Joseph Gradecki (Wrox, 2004).