Professional Java.JDK.5.Edition (Wrox)

Chapter 6

Once a connection is established through the DBDatabase.load method, it will call the DBDatabase.readTable method to get the table and column meta data:

// Setup and retrieve the metadata info DatabaseMetaData metadata = null;

metadata = currentConnection.getMetaData();

String[] names = {“TABLE”};

ResultSet tableNames = metadata.getTables(null,”%”, “%”, names);

while (tableNames.next()) {

String sTName = tableNames.getString(“TABLE_NAME”); if (sTName != null) {

DBTable dTable = new DBTable(sTName); readTableColumns(metadata, dTable); m_alTables.add((DBTable) dTable);

}

}

Each DBTable object that is created will call the DBDatabase.readTableColumns automatically to create DBColumns objects for the given DBTable:

ResultSet columns = meta.getColumns(null, “%”, table.getTableName(), “%”);

while (columns.next()) {

String columnName = columns.getString(“COLUMN_NAME”); String datatype = columns.getString(“TYPE_NAME”);

int datasize = columns.getInt(“COLUMN_SIZE”); int digits = columns.getInt(“DECIMAL_DIGITS”);

int nullable = columns.getInt(“NULLABLE”); boolean bNull = (nullable == 1);

DBColumn dCol = new DBColumn((String)table.getTableName(), columnName, datatype, datasize, digits, bNull);

table.addColumn((DBColumn)dCol);

}

2.Once you have created a connection and obtained the table and column meta data you need, then execute the DBDatabase.searchAllByKeyword method to search the entire data source for the given keyword in all tables and all columns:

public ArrayList searchAllByKeyword(String saKeyword)

{

try {

//Clear result list m_alResults.clear();

//Get size of Tables ArrayList int nSize = m_alTables.size();

//Create our basic SQL statement

306

Persisting Your Application Using Databases

String sStartSQL = “Select * from “;

DBTable dbTable;

for (int i = 0; i < nSize; i++) { String sSQL = sStartSQL;

// Get table

dbTable = (DBTable) m_alTables.get(i); if (dbTable == null) {

break;

}

// Add the table name

sSQL = sSQL + “[“ + dbTable.getTableName() + “] WHERE “;

// Get column objects

ArrayList alCols = dbTable.getColumns();

if (alCols == null) { continue;

}

int nColSize = alCols.size(); if (nColSize <= 0) {

continue;

}

String sSQLColumns = “”;

// Get individual columns for table and add to SQL for (int k = 0; k < nColSize; k++) {

DBColumn dbCol = (DBColumn) alCols.get(k);

if (dbCol != null) { if (k == 0) {

sSQLColumns = dbCol.getColumnName(); } else {

sSQLColumns = sSQLColumns + “ & “ + dbCol.getColumnName();

}

}

// Add keyword to SQL string

sSQL = sSQL + sSQLColumns + “ LIKE ‘%” + saKeyword + “%’”;

// Search Table and Save result set

Statement statement = m_cConnection.createStatement();

// Execute SQL statement

ResultSet resultSet = statement.executeQuery(sSQL);

// Add to resultset array list m_alResults.add(resultSet);

}

307

Chapter 6

} catch(Exception e) { System.out.println(e); e.printStackTrace(System.out);

}

return m_alResults;

}

This code is an excellent example of how you can utilize the DatabaseMetaData object to create code that does not fit under normal database operations. Using the DatabaseMetaData object, you were able to design code that has the ability to grab all the meta data information, create a list of all tables and all columns, and search the entire database for a specific keyword.

Utilizing RowSets

A RowSet represents a set of rows obtained from a tabular form of data such as a result set. RowSet interfaces are a JavaBeans component; therefore they support event notifications and property manipulations. RowSets can be used in Integrated Development Environments (IDE) that support visual JavaBeans development. This allows you to create a RowSet at design time and then execute its methods at run time.

RowSets are usually implemented as either connected or disconnected implementations. Connected RowSet implementations establish a connection with a data source and keep the connection until the RowSet is discarded. Disconnected RowSet implementations are very interesting because they don’t require a JDBC driver or the full use of the JDBC API until they need to establish a connection to retrieve or update data. Once the operations are finished, the RowSet disconnects. The disconnected RowSet implementation stores all the data and meta data about a data source in memory; so most manipulations of the data can occur offline until there is a need to commit the data. RowSets provide the perfect mechanism for sending formatted data over a low bandwidth network to clients that do not possess an extreme amount of capabilities for data processing.

Understanding RowSet Events

RowSets support JavaBeans events that notify other JavaBeans components that implement the RowSetListener interface and are registered with the appropriate RowSet object. In order to register with a RowSet object, the method RowSet.addRowSetListener() is provided for applications to use. There are three types of events that can occur which will cause an event to fire:

cursorMoved — Notifies listeners that the cursor has moved within the RowSet object.

rowChanged — Notifies listeners that the RowSet object has changed one of its rows.

rowSetChanged — Notifies listeners that the entire content of the RowSet object has changed.

RowSet Standard Implementations

Up until this point in time there have not been any finalized standard implementations on RowSets. Now there are five available for use in the J2SE 1.5 platform that are maintained by the Java Community Process (JCP) under the alias JSR 114.

308

Using the New JdbcRowSetImpl

The JdbcRowSetImpl is a new implementation of the JdbcRowSet interface that is provided with J2SE 1.5. This implementation essentially encapsulates a ResultSet and in turn makes the ResultSet and its driver usable as a JavaBeans component. The JdbcRowSetImpl supports all the ResultSet methods and it even has the added benefit of making nonscrollable ResultSets scrollable. So you could take a nonscrollable ResultSet, plug it into a JdbcRowSetImpl and make it scrollable as well as updatable:

JdbcRowSetImpl jrsRowSet = new JdbcRowSetImpl();

jrsRowSet.setURL(jdbc:sybase:Tds:127.0.0.1:3000?ServiceName=Sybase”);

jrsRowSet.setUsername(“jconnelly”);

jrsRowSet.setPassword(“secret”);

jrsRowSet.setCommand(“SELECT * FROM EMPLOYEES WHERE TITLE = ? AND AGE = ?”); jrsRowSet.setString(1, “SOFTWARE ENGINEER”);

jrsRowSet.setInt(2, 27);

//This establishes the connection, creates the prepared statement, and creates the

//ResultSet if successful

jrsRowSet.execute();

The code in the sample above creates a JdbcRowSetImpl called jrsRowSet and then sets its properties, which include a JDBC URL to the data source, a username and password for the data source, and an SQL command to be executed. Once all the properties are set, the JdbcRowSetImpl.execute method is called, which internally establishes a connection to the data source, creates any necessary prepared statements, and executes the statements, which in turn generate a ResultSet. The jrsRowSet can now be traversed just like any other scrollable, updatable ResultSet object.

The beauty of it all is that now the jrsRowSet that contains a ResultSet object can be a component in a Swing application, if so desired.

309

Chapter 6

Connection Pooling

The trouble with the normal way of connecting to a data source is that, if your application requires numerous connections to occur with a data source, every time you close the Connection object, the physical connection is closed. Therefore, every time you open a connection, the connection has to be reestablished with the data source, initialized, and eventually closed again before repeating the same process over and over again. This is a performance and scalability nightmare.

Connection pooling is the answer to this problem. It provides a way to maintain a certain amount of physical database connections that can be reused by applications as necessary. Connection pooling is typically used in a three-tier environment, but it can be used in a two-tier environment as well if the JDBC driver provides an implementation of the ConnectionPoolDataSource interface.

From an applications standpoint, connection pooling is virtually transparent. There are only two things you need to know in order to utilize connection pooling correctly, and they are listed here:

Never use the DriverManager class to get a Connection object; always use the DataSource object to create a Connection object.

Always use finally statements to close a Connection object.

Administrators of application servers are responsible for managing the connection pools, so talk to your application server administrator to find out specifics for your particular server.

Managing Transactions

Transaction management is extremely important when dealing with data sources. Transaction management ensures data integrity and data consistency; without it, it would be very easy for applications to corrupt data sources or cause problems with the synchronization of the data. Therefore, all JDBC drivers are required to provide transaction support.

What Is a Transaction?

To explain transactions best, take using an ATM machine as an example. The steps to retrieve money are as follows:

If anything was to go wrong along the way and you didn’t receive your money, you would definitely not want that to reflect on your balance. So a transaction encompasses all the steps above and has only two possible outcomes: commit or rollback. When a transaction commits, all the steps had to be successful. When a transaction fails, there should not be any damage done to the underlying data source. In this case, the data that stores your account balance!

310

Persisting Your Application Using Databases

Standard Transactions

JDBC transactions are extremely simple to manage. Transaction support is implemented by the DBMS, which eliminates your having to write anything — code-wise — that would be cumbersome. All the methods you need are contained in the Connection object. There are two main methods you need to be concerned about: Connection.commit and Connection.rollback. There isn’t a begin transaction method because the beginning of a transaction is implied when the first SQL statement is executed.

In JDBC 3.0, there is a new concept called a savepoint. Savepoints allow you to save moments in time inside a transaction. For example, you could have an application that sends an SQL statement, then invokes a savepoint, tries to send another SQL statement, but a problem arises and you have to rollback. Now instead of rolling back completely, you can choose to rollback to a given savepoint. The following code example demonstrates JDBC transactions and the new savepoint method, Connection.setSavepoint:

Statement stmt = cConn.createStatement();

int nRows = stmt.executeUpdate(“INSERT INTO PLAYERS (NAME) “ + VALUES (‘Roger Thomas’)”);

// Create our save point

Savepoint spOne = cConn.setSavepoint(“SAVE_POINT_ONE”);

nRows = stmt.executeUpdate(“INSERT INTO PLAYERS (NAME) “ + VALUES (‘Jennifer White’)”);

//Rollback to the original save point cConn.rollback(spOne);

//Commit the transaction. cConn.commit();

From this example, the second SQL statement never gets committed because it was rolled back to SAVE_POINT_ONE before the transaction was committed.

Distributed Transactions

Participation in distributed transaction management is the same as participating in connection pooling. You must create connections from the DataSource interface. Transactions are no longer maintained by applications; rather, they are now maintained by transaction managers outside your control. Therefore, your program must not call any of the following methods:

commit

rollback

setSavePoint

setAutoCommit(true) — false is acceptable

If your application calls any of these methods while participating in a distributed transaction architecture, an SQLException will be thrown. The following are the two things you doneed to do to participate fully in a distributed transaction management architecture:

311

Chapter 6

Never use the DriverManager class to get a connection; always use the DataSource interface to create a new Connection object.

Always use finally statements to close Connection objects.

Object to Relational Mapping with Hibernate

Object to Relational Mapping (ORM) technologies are becoming very popular in today’s fast-paced, develop-it-yesterday environment. ORM is an approach to developing applications that persist objects to relational databases. Another term that is frequently used when discussing ORM technologies is transparent persistence. Simply stated, it is the ability to store objects in a database using an object-oriented programming language while hiding the details from the application. Hibernate does exactly that.

Hibernate (http://www.hibernate.org) is one of the most popular and versatile ORM tools on the market. It acts as a persistent service for your applications to store and retrieve Java objects to and from relational databases. Hibernate is designed to be as transparent to the developer as possible and one of the main architectural features it possesses to accomplish this is the use of runtime reflection instead of build-time code generation. This type of architecture allows you to write and compile your code without Hibernate intruding on the build process. Hibernate doesn’t enter the picture until the application is actually executed.

Hibernate, like most ORM tools, has its own query language called Hibernate Query Language (HQL). HQL is an object-oriented query language that looks very similar to SQL. It supports the use of subqueries; group by, having, and order by; retrieval of arbitrary data objects using its select new construct; table joins; native SQL Queries; SQL functions and operators; aggregate functions; and query by criteria.

Hibernate handles the object to relational bridge through plain-text XML files that map classes and variables of those classes to tables and columns in a relational database. It also has mapping support for one-to-one, many-to-one, one-to-many, and many-to-many relationships. If your particular application will require complex mapping of an already existing database, I recommend a third-party tool called MiddleGen (http://middlegen.codehaus.org/) to perform all of your mapping needs. MiddleGen provides a Hibernate plug-in that supports the creation of Hibernate’s mapping configuration files and eliminates the need for you to generate the mappings by hand. For more information on how MiddleGen interacts with Hibernate, please visit http://www.hibernate.org/98.html.

Exploring Hibernate’s Architecture

Hibernate’s architecture is very flexible, and trying to narrow it down to one specific, overall architecture is rather difficult. The reason is that Hibernate can basically plug in to any J2EE architecture without hampering it. So the majority of its use will be based upon your architectural needs. This is not a drawback but a major winning point for Hibernate. You can base your needs on your requirements and not worry about how they will affect the tool. Figure 6-3 shows a very basic architecture that shows where Hibernate could reside.

312

Persisting Your Application Using Databases

Figure 6-3

313

Chapter 6

Supported Database Platforms

Hibernate supports a large array of database platforms to which objects may be persisted. Each database will require its own JDBC driver in order to communicate with it. The currently supported database platforms are as follows:

MySQL

Oracle

Sybase

Microsoft SQL Server

Informix

DB2

PostgreSQL

SAP DB

HypersonicSQL

Interbase

Pointbase

Mckoi SQL

Progress

FrontBase

You can always add more database platforms when their drivers become available.

Plugging Hibernate In

To use Hibernate in your application, you need to understand what is required in order to set up Hibernate successfully. The JARs that Hibernate uses are listed in the following table.

314

Depending on your particular needs, some of these JARs can be optionally included.

Developing with Hibernate

This section will explore how to develop applications using Hibernate. The section will end with a complete working example of a forum that allows users to collaborate via a Web browser on various topics. This example will also show how to use Hibernate with Tomcat.

Understanding Mappings

The XML mapping files are a great place to start when learning Hibernate. This is the area where you will build your object mappings to the relational database of choice. No code has to be written at this point because Hibernate can actually generate the stub classes for you using the CodeGenerator that ships with the Hibernate Extensions package. If you have downloaded and installed the Hibernate Extension package, you can issue the following command on your mapping files to generate the source stubs:

java -cp classpath net.sf.hibernate.tool.hbm2java.CodeGenerator options

mapping_files

Mapping documents are usually created in the same directory as your generated class files where your source files are. If you had a class named Employee, then the mapping file for that class should be called Employee.hbm.xml. Below is a sample mapping file showing the basics of how to map a generic class, in this case Employee, to a relational data source:

<hibernate-mapping package=”org.hibernate”> <class name=”Employee” table=”tblEmployees”>

<id name=”id” column=”employee_id” type=”long” unsaved-value=”null”> <generator class=”native”/>

</id>

<property name=”name” column=”employee_name” type=”string” length=”25” not-null=”true”/>

<set name=”Payroll” cascade=”all” inverse=”true” lazy=”true”> <key column=”employee_id”/>

<one-to-many class=”Employee”/> </set>

</class> </hibernate-mapping>

315