public void closeConnection(Connection conn) throws SQLException {

  if ( log.isDebugEnabled() ) checkedOut--;

//synchronized pool to avoid concurrence error.  
synchronized (pool) {
   int currentSize = pool.size();
   if ( currentSize < poolSize ) {
    if ( log.isTraceEnabled() ) log.trace("returning connection to pool, pool size: " + (currentSize + 1) );

//add to pool  
    pool.add(conn);
    return;
   }
  }

  log.debug("closing JDBC connection");

  conn.close();

 }

Only add the mapping files you need!

If you are running some few JUnit tests for a 400++ classes project you probably don't hit every class in those tests and thus do not need to add all those hbm.xml's to the Configuration. Go look at Hibernate's test suite on how you could let your TestCase decide what classes should be defined in the mapping.

Use serialized XML documents when configuring Configuration

When building the configuration 40-60% of the time is used by the XML parsers and Dom4j to read up the XML document. Significant performance increases can be done by serializing the Document object's to disc once, and afterwards just add them to the configuration by deserializing them first.

In the current cvs we have an experimental Configuration.addCachableFile() method that can be used as inspiration for previous Hibernate versions.

public Configuration addCachableFile(String xmlFile) throws MappingException {        
        try {
            File file = new File(xmlFile);
            File lazyfile = new File(xmlFile + ".bin");
            org.dom4j.Document doc = null; 
            List errors = new ArrayList();
            if(file.exists() && lazyfile.exists() && file.lastModified()<lazyfile.lastModified()) {
                log.info("Mapping lazy file: " + lazyfile.getPath());
                ObjectInputStream oip = null;
                oip = new ObjectInputStream(new FileInputStream(lazyfile));
                doc = (org.dom4j.Document) oip.readObject();
                oip.close(); 
            } else {
                doc = xmlHelper.createSAXReader(xmlFile, errors, entityResolver).read( file );
                log.info("Writing lazy file to " + lazyfile);
                ObjectOutputStream oup = new ObjectOutputStream(new FileOutputStream(lazyfile));
                oup.writeObject(doc);
                oup.flush();
                oup.close();
            }
            
            if ( errors.size()!=0 ) throw new MappingException( "invalid mapping", (Throwable) errors.get(0) );
            add(doc);
            return this;
        }
        catch (Exception e) {
            log.error("Could not configure datastore from file: " + xmlFile, e);
            throw new MappingException(e);
        }
    }

Disable Hibernates usage of cglib reflection optimizer

Put the following line in hibernate.properties:

hibernate.cglib.use_reflection_optimizer=false

It will make Hibernate start faster since it does not try to build cglib-enhanced objects to access getter/setters.

Note: It will have in impact on overall runtime performance since Hibernate will be forced to use standard JDK reflection for access. So it is most useful during development. (You will also get better error messages in some situations when the optimizer is disabled ;)

Another approach would be to serialize the whole Configuration 
object. What do you think about this? I have submitted a patch to  
the Jira to make the Configuration Serializable (see bugs 492 and 
147).

I can't fine addLazyFile() in CVS.  Is it still supposed to be there?

Try the Hibernate3 module (or just the alpha release)

The information on this page does not seem to be correct any
more. With Hibernate 3.0rc1, there is no Configuration.addLazyFile()
any more, but addCacheableFile(). How should it be used?

If you have terrible problems with startup time and
do NOT need certain features like:

* proxy objects
* lazy loading

or if you are using the stateless session,
then you can disable lazyness on class level like:

<class name="myClass" table="myTable" lazy="false">

The default is true and forces byte code generation of
some proxy class which takes a lot of time.
Perhaps some hibernate guru can tell us, which other
features will be disabled by this.

The Hibernate Configuration module implement is very bad.
I write a module to realize the dynamic loading mapping files.
But other function I can't resolve...

Hibernate Dynamic Module
This project is only a module of Hibernate http://www.hibernate.org Read
mapping file until insert/update/delete/select the persistent class in
Hibernate.
http://sourceforge.net/projects/hbn-dyn-mod/

        try {
            FileInputStream fis = new FileInputStream("serial");
            ObjectInputStream ois = new ObjectInputStream(fis);
            configuration = (Configuration) ois.readObject();
            ois.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
        catch (IOException e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
        if(configuration!=null)
        {
        SessionFactory sessionFactory = configuration.configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        callBack.doing(session);
        transaction.commit();
        }
    }
when will Configuration serialize and why it's some field seted transient?the example will be error because some field transient is null after serialize.

Hibernate: Understand FlushMode.NEVER

Posted by tfenne under Java


I've complained before about how the Hibernate documentation doesn't provide much help for those of us dealing with large data sets. The established point of view seems to be that "large amounts of data == batch processing" and "hibernate/java is not the best place for batch processing." Seeing as the system I'm working on currently (a DNAresequencingLIMS) has a complex data model and very large amounts of OLTP data, I'm at odds with the first piece of accepted knowledge. We deal with large (thousands of objects) complex object webs in memory to implement use cases driven from a user interface in human-time (i.e. non-batch).

One of the more useful pieces of advice I've seen meted out on the hibernate forums was a trite statement from Gavin to some poor user to "understand FlushMode.NEVER". Well, I've recently had occasion to understand it, and I thought I'd share. To use FlushMode.NEVER you might write something like:

session.setFlushMode(FlushMode.NEVER);

This tells the hibernate session that it is not to flush any state changes to the database at all, ever - unless told to do so by the application programmer calling session.flush() directly. That's fairly logical, and is useful in it's own right, but why does it have a big impact on performance in some scenarios?

To explain, let's take a look at a fairly typical use case of mine (if you don't understand the science, don't worry). It involves automatically picking the "best" available PCR primers for the genes/exons being resequenced in an experiment, and goes something like this:

1. Find all the exons/targets in the experiment (ranges up to 5000)
2. Find all the PCR primers that have already been ordered by the experiment, and worked
3. Find all the PCR primers that are in queue to be ordered by the experiment
4. Net out the primers against the targets to find what isn't covered
5. For each un-covered area query for all possible PCR primers in the system
6. Examine each matching primer and pick the best one for each target
7. Save the picked PCR primers to the experiment

Because our domain model is fairly rich, by step 4 we've probably got on the order of 20-30,000 objects in the session! And then each query (it's actually two queries, but that's not so important) in steps 5/6 brings in anywhere from 0 to 20 additional objects. What's interesting though is that while we're pulling in a lot of objects, none of the objects we're loading are getting modified. Only new objects are getting created and saved at the end.

Back to FlushMode.NEVER then. You might assume that since we're not persisting or changing anything until the last step, changing the flush mode would have little consequence. You'd be wrong of course. In actuality setting flush mode to NEVER at the start of this flow and then flushing manually at the end caused the run time to drop by over half!

The reason for this is the way hibernate implements dirty checking. Every time you load an object into memory (and don't evict it) the session keeps track of it in case it changes. (Of course, you could evict it - but then any lazy loaded relationships won't be able to load.) So, any time you perform a query, the session iterates over all objects in the session checking dirtiness and flushes any dirty objects to the database. It does this to ensure that all state changes that might affect the query are present in the database before issuing the query to it. That's fine when you have only a few objects in session, but when you have thousands and are performing thousands of queries, it becomes a real drain on performance.

What I'm yet to understand is exactly why hibernate does it this way. Perhaps it's the developers' belief that improving performance for large data sets isn't worth the additional complexity? What am I talking about? Well, a lot (the vast majority) of the objects that get loaded into memory are proxied by hibernate anyway. These don't need to be dirty checked when queries are made because they could actively be flagged as dirty when changes are made through the proxy, and added directly to a dirty list. It would seem to me that if hibnerate always returned proxied instances - even on non-lazy loads - this problem could practically disappear. There's still the case when someone persists a new object and then tries to modify it without replacing their reference with a newly proxified reference- but even if those instances were tracked the old way, it would hardly affect performance in most use cases like this.

Anyway, the moral of the story is this: in use cases with lots of reading/querying and lots of objects in session you should use FlushMode.NEVER as long as you're not modifying data that will affact your queries. Example psuedo-code is below:

FlushMode previous = session.getFlushMode();
session.flush(); // who know's what been done till now
session.setFlushMode(FlushMode.NEVER);
// Do some querying
// Do some more querying
// Really load up that session
// Execute a few more queries
// Write back to some tables
session.flush();
session.setFlushMode(previous);

  Projection, aggregation, subselects, detatched criterias - its all there in the Hibernate 3 Criteria API. Let me show you some examples, starting with the new projection API. Suppose we have a User class and only want to query for its username:

session.createCriteria(User.class)
    . setProjection(Projection.property(\"username\"))
    .list();

session.createCriteria(User.class).setProjection(
    Projections.propertyList()
        .add(Projection.property(\"firstname\"))
        .add(Projection.property(\"lastname\"))
    )
    .add(Restriction.gt(\"age\", 25))
    .list();

session.createCriteria(User.class)
    .setProjection(Projections.rowCount())
    .add(Restriction.eq(\"lastname\", \"Black\"))
    .list();

session.createCriteria(User.class)
    .createAlias(\"roles\", \"r\")
    .setProjection( Projections.projectionList()
        .add(Projection.groupProperty(\"r.name\"))
        .add(Projection.rowCount())
    )
    .list();

DetatchedCriteria dc = DetatchedCriteria.forClass(User.class)
    .add(Property.forName(\"firstname\").eq(\"John\")
    .setProjection(Property.forName(\"age\").min());
	
Session session = sessionFactory.openSession();
	
dc.getExecutableCriteria(session).list();

DetatchedCriteria dc = DetatchedCriteria.forClass(User.class)
    .add(Property.forName(\"firstname\").eq(\"John\")
    .setProjection(Property.forName(\"age\").min());
	
session.createCriteria(User.class)
    .add(Subqueries.propertyEq(\"age\", dc))
    .list();

You can count the number of query results without actually returning them:

( (Integer) session.iterate("select count(*) from ....").next() ).intValue()

To order a result by the size of a collection, use the following query:

select usr.id, usr.name
from User as usr 
    left join usr.messages as msg
group by usr.id, usr.name
order by count(msg)

If your database supports subselects, you can place a condition upon selection size in the where clause of your query:

from User usr where size(usr.messages) >= 1

If your database doesn't support subselects, use the following query:

select usr.id, usr.name
from User usr.name
    join usr.messages msg
group by usr.id, usr.name
having count(msg) >= 1

As this solution can't return a User with zero messages because of the inner join, the following form is also useful:

select usr.id, usr.name
from User as usr
    left join usr.messages as msg
group by usr.id, usr.name
having count(msg) = 0

Properties of a JavaBean can be bound to named query parameters:

Query q = s.createQuery("from foo Foo as foo where foo.name=:name and foo.size=:size");
q.setProperties(fooBean); // fooBean has getName() and getSize()
List foos = q.list();

Collections are pageable by using the Query interface with a filter:

Query q = s.createFilter( collection, "" ); // the trivial filter
q.setMaxResults(PAGE_SIZE);
q.setFirstResult(PAGE_SIZE * pageNumber);
List page = q.list();

Collection elements may be ordered or grouped using a query filter:

Collection orderedCollection = s.filter( collection, "order by this.amount" );
Collection counts = s.filter( collection, "select this.type, count(this) group by this.type" );

You can find the size of a collection without initializing it:

( (Integer) session.iterate("select count(*) from ....").next() ).intValue();

User.hbm.xml

				
						java:
						

						

						

						

						

						

						

						

						

								
										

										

										
User user1 = new User();
								

								user1.setName("bush"); 
								

								Room room1 = new Room(); 
								

								room1.setAddress("NTU-M8-419");
								

								        
								

								user1.setRoom(room1);
								

								room1.setUser(user1);
								

								        
								

								Session session = sessionFactory.openSession();
								

								Transaction tx = session.beginTransaction();
								

								 
								

								session.save(user1);
								

								

								        
								

								tx.commit();
								

								session.close();
								

						
						

						

						

						

						

						

						the above is run right,but if the following :

						

						

						User user1 = new User();
  user1.setName("bush"); 
						

						  Room room1 = new Room(); 
						

						  room1.setAddress("NTU-M8-419");
						

						        
						

						  user1.setRoom(room1);
						

						  room1.setUser(user1);

						

						

						

						User user2 = new User();
  user2.setName("bush"); 

						

						

						 //the new column point to the same room1 and no errors 
						

						

						user2.setRoom(room1);
						

						        
						

						  Session session = sessionFactory.openSession();
						

						  Transaction tx = session.beginTransaction();
						

						 
						

						  session.save(user1); 
 //save

						

						

						

						  session.save(user2);
      
						

						  tx.commit();
						

						  session.close();

						

						

						

				
				is "one-to-one" in hibernate just for creating  a foreign key for another table?
did it make any restriction between the two tables.
		

  org.hibernate.cfg.Configurations 根据 xml 文件配置整个工作过程中所需要的参数。一般

我们会用 Configuration cfg = new Configuration().configure(); 创建一个配置类。那么，这句话到底做了什么呢？

  首先， new Configuration() 会做些什么呢？我们来看他的源码：

  protected Configuration(SettingsFactory settingsFactory) {

        System.out.println("Configuration(SettingsFactory settingsFactory)");

        this.settingsFactory = settingsFactory;

        reset();

    }

// 默认构造函数，先 new SettingsFactory() ， 然后调用

//protected Configuration(SettingsFactory settingsFactory)

public Configuration() {

        this(new SettingsFactory());

}

reset() 初始化了很多变量，感兴趣的可以去看源代码，没有什么特别的地方。

  接着，调用 configure() 方法！

public Configuration configure() throws HibernateException {

        configure("/hibernate.cfg.xml");

        return this;

}

可以看出，默认使用 hibernate.cfg.xml 文件，如果想用自定义的文件，可以调用

configure(“….xml”) 方法。

public Configuration configure(String resource) throws HibernateException {

        log.debug("configuring from resource: " + resource);

        InputStream stream = getConfigurationInputStream(resource);

        return doConfigure(stream, resource);

}

根据 getConfigurationInputStream(resource) 得到文件流， getConfigurationInputStream(resource) 调用 ConfigHelper.getResourceAsStream(resource) 。

public static InputStream getResourceAsStream(String resource) {

              String stripped = resource.startsWith("/") ?

                            resource.substring(1) : resource;

              InputStream stream = null;

              ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

              if (classLoader!=null) {

                     stream = classLoader.getResourceAsStream( stripped );

              }

// 这里的代码可能应该是 stream = Environment.class.getResourceAsStream( resource );

              if ( stream == null ) {

                     Environment.class.getResourceAsStream( resource );

              }

              if ( stream == null ) {

                     stream = Environment.class.getClassLoader().getResourceAsStream( stripped );

              }

              if ( stream == null ) {

                     throw new HibernateException( resource + " not found" );

              }

              return stream;

       }

然后 doConfigure(stream, resource) 。

protected Configuration doConfigure(InputStream stream, String resourceName) throws HibernateException {

org.dom4j.Document doc;

        try {

            List errors = new ArrayList();

            SAXReader saxReader = xmlHelper.createSAXReader(resourceName, errors, entityResolver);

            doc = saxReader.read(new InputSource(stream));

            if (errors.size() != 0) {

                throw new MappingException(

                        "invalid configuration",

                        (Throwable) errors.get(0)

                );

            }

        }

entityResolver 在初始值为 entityResolver = XMLHelper.DEFAULT_DTD_RESOLVER ; 在 reset() 的时候设置的。 XMLHelper.DEFAULT_DTD_RESOLVE 在 XMLHelper 默认是 XMLHelper.DEFAULT_DTD_RESOLVER= new DTDEntityResolver() ； DTDEntityResolver 是用来加载 dtd 文件的。别跟我说你不知道 dtd 是什么东西？它有 3 种加载方式：

1．  文件路径以 http://hibernate.sourceforge.net/ 开头的文件，如

http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd ，

它会把 http://hibernate.sourceforge.net 去掉，加上 org/hibernate/ ，文件路径为

org/hibernate/hibernate-configuration-3.0.dtd ，然后加载这个文件。

2.       文件路径以 file:// 开头的文件，如

  file://hibernate-configuration-3.0.dtd ，

它会把 file:// 去掉，路径为 hibernate-configuration-3.0.dtd ，然后加载这个文件。

3. 如果没有以上 2 种情况，则直接加载。就是路径名没有修改过。

整个过程在 public InputSource resolveEntity(String publicId, String systemId) 中实现。

systemId 就是 dtd 的路径。大家可以去看看 SAXReader 类自带的

protected static class SAXEntityResolver ，比较比较。

在得到 doc 的值

            doc = saxReader.read(new InputSource(stream));

后，调用 protected Configuration doConfigure(org.dom4j.Document doc) ，这个函数主要是根据 doc 的到配置参数，然后存到 properties 中。

  先是设置 session-factory 的名字：

Element sfNode = doc.getRootElement().element("session-factory");

        String name = sfNode.attributeValue("name");

        if (name != null) {

             // 保存到 properties 中！

            properties.setProperty(Environment.SESSION_FACTORY_NAME, name);

        }

然后是 addProperties(sfNode) ，把 <property name=" "> </property> 保存到 properties 中。

// 这句话估计又是多余的

properties.setProperty(name, value);

            if (!name.startsWith("hibernate")) {

                properties.setProperty("hibernate." + name, value);

            }

接着调用了 parseSessionFactory(sfNode, name) ，把 mapping ， class-cache ， collection-cache ， listener ， event 等配置保存。到底它保存到哪，我也不全知道，只看了

protected void parseMappingElement(Element subelement, String name), 根据配置加载了 mapping 的文件，最后使用 HbmBinder : public static void bindRoot(Document doc, Mappings mappings, java.util.Map inheritedMetas) 保存。 bindRoot 是对 mapping 中的 xml 文件进行解析。

HbmBinder 和 Configuration 都有 2000 行以上的代码，在 Hibernate 中有很重要的地位。 Configuration 使用 .cfg.xml ，而 HbmBinder 则使用了 .hbm.xml 。

              extractRootAttributes( hmNode, mappings ) 根据 <hibernate-mapping> 的配置，把分析的结果存入 mapping 。

java.sql.SQLException: Connection is broken
        at org.hsqldb.jdbc.jdbcUtil.sqlException(Unknown Source)
        at org.hsqldb.jdbc.jdbcStatement.fetchResult(Unknown Source)
        at org.hsqldb.jdbc.jdbcStatement.executeQuery(Unknown Source)
        at org.hsqldb.jdbc.jdbcDatabaseMetaData.execute(Unknown Source)
        at org.hsqldb.jdbc.jdbcDatabaseMetaData.getDatabaseProductName(Unknown S
ource)
        at org.hibernate.cfg.SettingsFactory.buildSettings(SettingsFactory.java:
75)
        at org.hibernate.cfg.Configuration.buildSettings(Configuration.java:1881
)
        at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.jav
a:1174)
        at org.springframework.orm.hibernate3.LocalSessionFactoryBean.newSession
Factory(LocalSessionFactoryBean.java:825)


因为我在lib中放了hsqldb-1.7.3.0.jar所以导致了错误！

Struts Recipes: Hibernate and Struts

Add the power of Hibernate to your Struts application

Summary
In this excerpt from Struts Recipes, (Manning Publications, December 2004) authors George Franciscus and Danilo Gurovich illustrate how to use Hibernate in a Struts application. They also show how to create a Struts plug-in to improve performance. (2,200 words; January 24, 2005)

ersistence is a fundamental piece of an application. Obviously, without persistence all work would be lost. However, persistence means different things to different people. The length of time something must be persisted is a fundamental qualifier in choosing a persistence storage medium. For example, the HTTP session may be suitable when the life of a piece of data is limited to the user's session. In contrast, persistence over several sessions, or several users, requires a database. The volume of data is another important qualifier. For example, best practices suggest large amounts of data should not be stored in an HTTP session. In those circumstances, you need to consider a database. In this recipe we target persistence in a database.

The type of database you choose has an important influence on your architecture and design. As object-oriented developers, we tend to represent data as an interconnected web of objects as a means to describe the business problem at hand—this is often called a domain model. However, the most common storage medium is based on a relational paradigm. Unless our object model mirrors a relational structure, the in-memory representation of our data is at odds with the means to persist it. This problem is called the mismatch paradigm. One of the most popular tools to address the mismatch problem is a category of tools called object-relational mappers. An object-relational mapper is software used to transform an object view of the data into a relational one, and provide persistence services, such as create, read, update, and delete (CRUD). Many good papers have been written on object-relational mappers, but in essence, they all speak to the Data Mapper pattern. One of the most popular object-relational mappers is the open source Hibernate project.

In this recipe, we show you how to employ Hibernate in a Struts application. In addition, we will show you how to create a Struts plug-in to give your Hibernate-powered Struts applications a performance boost.

Recipe
In this recipe, we use an example to illustrate everything you need to do to use Hibernate in a Struts application. We create an application to retrieve and display elements from the chemical periodic table. The application offers the user a search page to look for an element by element symbol. The application responds by searching the database for an element matching the symbol name and returns information about the element.

We'll start by showing you how to get the Hypersonic database server up and running. With the database server started, we create the table and data required to exercise the application. Once the database is ready to go, we'll create all the Hibernate artifacts required to execute this application by using the Hypersonic database server. The next step is to respond to search requests by calling upon Hibernate to handle database access from inside our Action. Because creating Hibernate factory objects is expensive, we'll create a Struts plug-in to create the factory and store it in context.

Let's start by bringing up the Hypersonic database server. You need to download Hypersonic from http://hsqldb.sourceforge.net/. Place hsqldb.jar in your classpath and launch Hypersonic by entering the following command in your DOS prompt:

java org.hsqldb.Server

Although the server's response varies from one version of Hypersonic to another, the following response is a typical indication that Hypersonic is ready to serve database requests.

Server 1.6 is running
Press [Ctrl]+{c} to abort

With the database server up and running, we are ready to create the elements table and populate it with data, as shown in Listing 1.

Listing 1. Create and populate elements tables

create table elements (id integer(3) IDENTITY,
                 name char(30),
                 number char(30),
                 mass char(30),
                 symbol char(2));

CREATE UNIQUE INDEX ui_elements_pk ON elements (symbol)

insert into elements ( name, number, mass, symbol) values ('Manganese','25','55','Mn');
insert into elements ( name, number, mass, symbol) values ('Zinc','30','65','Zn');
insert into elements ( name, number, mass, symbol) values ('Thulium','69','169','Tm');
insert into elements ( name, number, mass, symbol) values ('Californium','98','251','Cf');
insert into elements ( name, number, mass, symbol) values ('Gold','79','197','Au');
insert into elements ( name, number, mass, symbol) values ('Ytterbium','70','173','Yb');
insert into elements ( name, number, mass, symbol) values ('Molybdenum','42','96','Mo');
insert into elements ( name, number, mass, symbol) values ('Palladium','46','106','Pd');

Listing 1 presents the SQL commands necessary to create the elements table, create a unique index on symbol, and insert data We have only presented a few of the periodic elements. We'll leave it to you to dust off your high school chemistry textbook to create data for the remaining elements.

Listing 2 presents the Element JavaBean used to store data retrieved from the database.

Listing 2. Element JavaBean

package com.strutsrecipes.hibernate.beans;

public class Element {
   private String name;
   private String symbol;
   private String number;
   private String mass;
   private int id;

   public Element() {
      super();
   }

   public Element(String name, String symbol, String number, String mass) {
      this.name = name;
      this.symbol = symbol;
      this.number = number;
      this.mass = mass;

   }

   public int getId() {
      return id;
   }

   public void setId(int id) {
      this.id = id;
   }

   public String getMass() {
      return mass;
   }

   public String getName() {
      return name;
   }

   public String getNumber() {
      return number;
   }

   public String getSymbol() {
      return symbol;
   }

   public void setMass(String mass) {
      this.mass = mass;

   }

   public void setName(String name) {
      this.name = name;
   }

   public void setNumber(String number) {
      this.number = number;
   }

   public void setSymbol(String symbol) {
      this.symbol = symbol;
   }
}

Hibernate is an object-relational mapping tool. Its job is to map objects to relational tables and vice versa. Therefore, we must tell Hibernate how to map the columns in the "elements" table to the properties of the Elements JavaBean. This is done using the Element.hbm.xml file. The information embodied in this file is required to empower Hibernate to copy data from the table to the Elements JavaBean. If we were using Hibernate to update data, the information in the Element.hbm.xml file would be used to extract data from the Elements JavaBean to generate SQL update statements. Listing 3 presents Element.hbm.xml.

Listing 3. Element.hbm.xml

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

<hibernate-mapping>
   <class name="com.strutsrecipes.hibernate.beans.Element" table="elements">

      <id name="id" column="id">
         <generator class="native"/>
      </id>

      <property name="name" column="name"/>
      <property name="number" column="number"/>
      <property name="mass" column="mass"/>
      <property name="symbol" column="symbol"/>
   </class>
</hibernate-mapping>

Let's step through Listing 3

We declare the full package name of the class to be associated with the "elements" table. We then declare the name of the table associated with that class. Next, we declare the mapping from the id JavaBean property to the id column. Because the property and column names have the same value, we could have omitted the column attribute, but we have explicitly declared the column for clarity purposes. The <id> tag is a special tag. It is used to declare the primary key for the table. The enclosing <generator> tag instructs Hibernate to generate the key in whichever way is most appropriate for the database implementation. You should consult Hibernate documentation for more information on the <id> tag. Finally, we declare mapping for the remaining JavaBean properties. Once again the column attribute is declared for clarification purposes.

Once the mapping file has been broken down in detail, it's all rather straightforward. It simply describes which table maps to which class and which JavaBean properties map to which column names. Later on we will tell you where to place this file.

Next, we configure Hibernate by declaring environmental information. In Listing 4, we present the hibernate.cfg.xml file.

Listing 4. hibernate.cfg.xml

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

<hibernate-configuration>
   <session-factory>
   <property name="dialect">net.sf.hibernate.dialect.HSQLDialect</property>
   <property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
   <property name="connection.username">sa</property>
   <property name="connection.password"></property>
   <property name="connection.url">jdbc:hsqldb:hsql://127.0.0.1</property>
   <property name="show_sql"> </property>
   <property name="">true</property>

   <mapping resource="/com/strutscookbook/hibernate/beans/Element.hbm.xml"/>
</session-factory>
</hibernate-configuration>

Let's step through Listing 4.

We start by specifying the database implementation dialect that allows Hibernate to take advantage of implementation-specific features. We declare the Hypersonic dialect. You should consult the Hibernate documentation to choose the appropriate dialect for your database. We then declare the database driver. You must ensure this driver is in your application's classpath. We then declare the database username, the database password, and the database connection URL. Next, we instruct Hibernate to display the SQL generated at runtime in the log.

The hibernate.cfg.xml file must be placed in your classpath.

The procedure to use Hibernate within your application requires the following steps:

1. Create a Hibernate configuration object

2. Use the Hibernate configuration object to create a Hibernate factory object

3. Use the Hibernate factory object to create a Hibernate session object

4. Use the Hibernate session object to start a transaction (optional)

5. Employ the Hibernate session object to create, read, update, and delete data on the database

6. Commit the transaction (optional)

7. Close the session

A Hibernate best practice is to create and cache the Hibernate factory to enhance performance. Therefore, we will create a Struts plug-in to perform Steps 1 and 2 and cache the Hibernate factory in the servlet context, as shown in Listing 5.

Listing 5. HibernatePlugin.java

package com.strutsrecipes.hibernate.plugin;

import java.net.URL;
import javax.servlet.ServletException;

import net.sf.hibernate.HibernateException;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.cfg.Configuration;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts.action.ActionServlet;
import org.apache.struts.action.PlugIn;
import org.apache.struts.config.ModuleConfig;

public class HibernatePlugin implements PlugIn {
   private Configuration config;
   private SessionFactory factory;
   private String path = "/hibernate.cfg.xml";
   private static Class clazz = HibernatePlugin.class;

      public static final String KEY_NAME = clazz.getName();

      private static Log log = LogFactory.getLog(clazz);

   public void setPath(String path) {
      this.path = path;
   }

   public void init(ActionServlet servlet, ModuleConfig modConfig)
      throws ServletException {

      try {
         URL url = HibernatePlugin.class.getResource(path);
         config = new Configuration().configure(url);
         factory = config.buildSessionFactory();
         servlet.getServletContext().setAttribute(KEY_NAME, factory);

      } catch (MappingException e) {
         log.error("mapping error", e);
         throw new ServletException();

      } catch (HibernateException e) {
         log.error("hibernate error", e);
         throw new ServletException();
      }

   }

   public void destroy() {
      try {
         factory.close();
      } catch (HibernateException e) {
         log.error("unable to close factory", e);
      }
   }
}

Creating a Struts plug-in requires only two steps. First, create a class implementing org.apache.struts.action.PlugIn (Listing 5). Second, define a <plug-in> tag in the struts-config.xml file (Listing 6).

Let's step through Listing 5.

We create a constant to hold the name of the servlet context attribute key. We have chosen to use the HibernatePlugin class name. Notice the constant is static public final. We use the HibernatePlugin class to access the key name in the Action (Listing 7). We define the path property. By default, the Hibernate-Plugin looks for the Hibernate configuration file at /hibernate.cfg.xml. You can use this property to load the Hibernate configuration file from another filename and directory anywhere on the classpath. Next, we use the classloader to find the Hibernate configuration file and then we create the Hibernate configuration object. We use the Hibernate configuration object to create a Hibernate factory object and then we store the Hibernate factory object in the servlet context. The factory is now available to any code with a reference to the servlet.

As a good practice, we close the factory in the destroy method.

Listing 6 presents the application struts-config. The only thing out of the ordinary here is the <plug-in> tag. This is where we declare the Hibernate plug-in, which creates and caches the Hibernate factory object.

Listing 6. struts-config.xml

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
   "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
   "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

<struts-config>
   <form-beans>
      <form-bean name="searchForm"type="com.strutsrecipes.hibernate.forms.SearchForm"/>
   </form-beans>

   <global-forwards>
      <forward name="search" path="/search.jsp"/>
      <forward name="searchsubmit" path="/searchsubmit.do"/>
   </global-forwards>

   <action-mappings>
      <action path="/searchsubmit"
            type="com.strutsrecipes.hibernate.actions.SearchAction"
            name="searchForm"
            scope="request"
            input="/search.jsp">
            <forward name="success" path="/element.jsp"/>
      </action>
   </action-mappings>

   <plug-in className="com.strutsrecipes.hibernate.plugin.HibernatePlugin">
      <set-property property="path" value="/hibernate.cfg.xml"/>
   </plug-in>
</struts-config>

Listing 7 presents the SearchForm used to search for an element. It's very simple because the user can only search by element symbol.

Listing 7. SearchForm.java

package com.strutsrecipes.hibernate.forms;

import org.apache.struts.action.ActionForm;
public class SearchForm extends ActionForm {
   String symbol;

   public String getSymbol() {
      return symbol;
   }

   public void setSymbol(String symbol) {
      this.symbol = symbol;
   }
}

Let's have a look at the SearchAction in Listing 8. Although you may decide to employ Hibernate in other areas of your application architecture, we have chosen to use it in the Action. We'll defer the discussion of the other alternatives to the discussion section.

Listing 8. SearchAction.java

package com.strutsrecipes.hibernate.actions;

import java.util.List;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import net.sf.hibernate.Hibernate;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.SessionFactory;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

import com.strutsrecipes.hibernate.beans.Element;
import com.strutsrecipes.hibernate.forms.SearchForm;
import com.strutsrecipes.hibernate.plugin.HibernatePlugin;

public class SearchAction extends Action {
   private static Log log = LogFactory.getLog(SearchAction.class);

   final public static String HQL_FIND_ELEMENT =
      "from com.strutsrecipes.hibernate.beans.Element as e where e.symbol = ?";

   public ActionForward execute(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
      throws Exception {

      SearchForm searchForm = (SearchForm) form;
      Element element = null;
      List elements = null;
      SessionFactory factory = null;
      Session session = null;

      try {

         factory =
                (SessionFactory) servlet.getServletContext()
               .getAttribute(HibernatePlugin.KEY_NAME);

         session = factory.openSession();

         elements =
            session.find(
            HQL_FIND_ELEMENT,
            searchForm.getSymbol(),
            Hibernate.STRING);

         if (!elements.isEmpty()) {
            element = (Element) elements.get(0);
         }

      } catch (HibernateException e) {
         log.error("Hibernate error", e);
         } finally {
            log.error("Hibernate exception encountered");
         session.close();
      }

      if (element != null) {
            request.setAttribute("element", element);
            return mapping.findForward("success");
      }

      ActionErrors errors = new ActionErrors();

      errors.add(ActionErrors.GLOBAL_ERROR,
         new ActionError("error.notfound"));
      saveErrors(request, errors);
      return mapping.getInputForward();
   }
}

Let's take a quick overview of what happens in the SearchAction. The SearchAction uses the SearchForm.getSymbol() method to obtain the element symbol entered by the user on the search page. Hibernate is used to search the database and convert the data stored in the database to an Element object. The Element object is placed in request context for the JavaServer Pages (JSP) page. Let's step through Listing 8 line by line to see how it's done in detail.

First, we declare a constant to search the database. We next cast the form to SearchForm and then we obtain the Hibernate factory. Recall the Hibernate plug-in has already created the factory and cached it in the servlet context. Next, we obtain a session. The session obtains a connection to the database. Hibernate uses the configuration information we created in Listing 4 to connect to the database. We then search the database.

There are other ways to employ Hibernate to search the database, but the find method is appropriate whenever a search doesn't use the primary key. Notice, we have the HQL_FIND_ELEMENT constant declared. The SQL defined in HQL_FIND_ELEMENT looks somewhat like standard SQL, but not quite. The SQL used by Hibernate is proprietary to Hibernate and reflects an object-oriented version of SQL, rather than the relational SQL to which you are accustomed.

Let's delve into the Hibernate SQL (HQL) code snippet.

from com.strutsrecipes.hibernate.beans.Element as e where e.symbol = ?

This statement tells Hibernate to select all Element objects residing in the com.strutsrecipes.hibernate.beans package. The where clause filters the list to only those elements whose symbols match a runtime parameter. The as e indicates that e may be used as an alias elsewhere in the HQL, as we have done in the where clause. You can see that we are selecting objects, not rows, in the database. Hibernate uses the information in Listing 4 to map the class we are interested in to its associated table. In this example, the relationship between the table and the object are very close, but that does not necessarily need to be the case.

The second and third arguments to the find method are the value and data type of the HQL replacement parameter. The Hibernate reference material describes other ways to replace runtime parameters.

The find method always returns a List. In this case, we obtain a list of Element objects. We are confident that a maximum of one instance is returned because the "elements" table has a unique key constraint on the symbol column (see Listing 1).

Returning to Listing 8, we copy the element reference in the first position in the list to the element variable. To deal with any Hibernate exceptions, we have chosen to log the exception and present the user a "not found" message, but you may decide to present a different message or use declarative exception handling. Next, we close the session. Closing the session in the finally clause guarantees it is attempted even when exceptions are thrown. We store the Element object in the request context and finally we build the ActionError when the symbol can't be found. For the sake of completeness, we have presented the search.jsp (Listing 9) and the element.jsp (Listing 10).

Listing 9. Search.jsp

<%@ page language="java" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>

<html:html>
<body>
   <h1>Search for an Element</h1>

   <html:form action="/searchsubmit.do">
      symbol <form:text property="symbol"/>
   <html:submit value="Search"/>
   </html:form>

   <html:errors/>

</body>
</html:html>

Listing 10. Element.jsp

<%@ page language="java" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>

<html:html>
   <h1>Periodic Element</h1>
   Name: <bean:write name="element" property="name"/><br>
   Symbol: <bean:write name="element" property="symbol"/><br>
   Number: <bean:write name="element" property="number"/><br>
   Mass: <bean:write name="element" property="mass"/><br>

   <html:link forward="search">Search</html:link><p>
</html:html>

Before putting Hibernate to work, consult the Hibernate documentation to ensure you have all the required Hibernate jar files in your classpath.

Discussion
Persistence of data is a tedious and laborious job. To make matters worse, a considerable effort must be spent transforming an object-oriented representation of the data to a relational one, and vice versa. Fortunately, several good object-relational mappers exist to ease this burden. In this recipe, we explored Hibernate—one of the most popular open source object-relational mappers available to Java programmers.

Hibernate is a very rich product with many unexplored features left for you to discover. Our simple example is limited to read behavior, but the rest of the CRUD family is just as easy. Update functionality is as simple as accessing the desired element, calling the desired JavaBean setter, and calling the session commit method. Hibernate takes care of generating the SQL and updating the table. A delete is also rather simple—session.delete(element) is all it takes! Finally, create only requires instantiating the object, calling the setters, and calling session.save(element).

Hibernate best practices recommend caching the Hibernate factory object. We chose to create and cache the factory using a Struts plug-in. Alternatively, you could have chosen to cache using any other means in your arsenal.

Although this recipe can serve you well, there are some drawbacks. First, we have exposed Hibernate to the Struts Action. Migrating to another persistence layer framework requires us to change every Action employing Hibernate. Second, our persistence is tightly coupled to the presentation layer. This coupling denies us the opportunity to reuse the persistence logic in some other presentation mechanism, such as a batch program.

Although there is room for improvement, this recipe is suitable when you do not expect to reuse your persistence logic. You may find yourself in this situation developing prototypes or small throwaway applications.

About the author
George Franciscus is a J2EE consultant and Struts authority. He is a coauthor of Manning's Struts in Action.

Danilo Gurovich is a manager of Web engineering at an e-commerce company. He has designed e-commerce and ERP/EAI Struts applications, and has led teams who have built them.

由于Hibernate是为了能在各种不同环境下工作而设计的, 因此存在着大量的配置参数. 幸运的是多数配置参数都 有比较直观的默认值, 并有随Hibernate一同分发的配置样例hibernate.properties (位于etc/)来展示各种配置选项. 所需做的仅仅是将这个样例文件复制到类路径 (classpath)下做一些自定义的修改.

Configuration cfg = new Configuration()
    .addResource("Item.hbm.xml")
    .addResource("Bid.hbm.xml");

Configuration cfg = new Configuration()
    .addClass(org.hibernate.auction.Item.class)
    .addClass(org.hibernate.auction.Bid.class);

Configuration cfg = new Configuration()
    .addClass(org.hibernate.auction.Item.class)
    .addClass(org.hibernate.auction.Bid.class)
    .setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLInnoDBDialect")
    .setProperty("hibernate.connection.datasource", "java:comp/env/jdbc/test")
    .setProperty("hibernate.order_updates", "true");

SessionFactory sessions = cfg.buildSessionFactory();

Session session = sessions.openSession(); // open a new Session

hibernate.connection.driver_class = org.postgresql.Driver
hibernate.connection.url = jdbc:postgresql://localhost/mydatabase
hibernate.connection.username = myuser
hibernate.connection.password = secret
hibernate.c3p0.min_size=5
hibernate.c3p0.max_size=20
hibernate.c3p0.timeout=1800
hibernate.c3p0.max_statements=50
hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect

hibernate.connection.datasource = java:/comp/env/jdbc/test
hibernate.transaction.factory_class = \
    org.hibernate.transaction.JTATransactionFactory
hibernate.transaction.manager_lookup_class = \
    org.hibernate.transaction.JBossTransactionManagerLookup
hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect

hibernate.query.substitutions true=1, false=0

hibernate.query.substitutions toLowercase=LOWER

SessionFactory sf = new Configuration()
    .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)
    .addFile("Item.hbm.xml")
    .addFile("Bid.hbm.xml")
    .buildSessionFactory();

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

<hibernate-configuration>

    <!-- 以/jndi/name绑定到JNDI的SessionFactory实例 -->
    <session-factory
        name="java:hibernate/SessionFactory">

        <!-- 属性 -->
        <property name="connection.datasource">java:/comp/env/jdbc/MyDB</property>
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="show_sql">false</property>
        <property name="transaction.factory_class">
            org.hibernate.transaction.JTATransactionFactory
        </property>
        <property name="jta.UserTransaction">java:comp/UserTransaction</property>

        <!-- 映射定义文件 -->
        <mapping resource="org/hibernate/auction/Item.hbm.xml"/>
        <mapping resource="org/hibernate/auction/Bid.hbm.xml"/>

        <!-- 缓存设置 -->
        <class-cache class="org.hibernate.auction.Item" usage="read-write"/>
        <class-cache class="org.hibernate.auction.Bid" usage="read-only"/>
        <collection-cache class="org.hibernate.auction.Item.bids" usage="read-write"/>

    </session-factory>

</hibernate-configuration>

SessionFactory sf = new Configuration().configure().buildSessionFactory();

SessionFactory sf = new Configuration()
    .configure("catdb.cfg.xml")
    .buildSessionFactory();

<?xml version="1.0"?>
<server>

<mbean code="org.hibernate.jmx.HibernateService"
    name="jboss.jca:service=HibernateFactory,name=HibernateFactory">

    <!-- 必须的服务 -->
    <depends>jboss.jca:service=RARDeployer</depends>
    <depends>jboss.jca:service=LocalTxCM,name=HsqlDS</depends>

    <!-- 将Hibernate服务绑定到JNDI -->
    <attribute name="JndiName">java:/hibernate/SessionFactory</attribute>

    <!-- 数据源设置 -->
    <attribute name="Datasource">java:HsqlDS</attribute>
    <attribute name="Dialect">org.hibernate.dialect.HSQLDialect</attribute>

    <!-- 事务集成 -->
    <attribute name="TransactionStrategy">
        org.hibernate.transaction.JTATransactionFactory</attribute>
    <attribute name="TransactionManagerLookupStrategy">
        org.hibernate.transaction.JBossTransactionManagerLookup</attribute>
    <attribute name="FlushBeforeCompletionEnabled">true</attribute>
    <attribute name="AutoCloseSessionEnabled">true</attribute>

    <!-- 抓取选项 -->
    <attribute name="MaximumFetchDepth">5</attribute>

    <!-- 二级缓存 -->
    <attribute name="SecondLevelCacheEnabled">true</attribute>
    <attribute name="CacheProviderClass">org.hibernate.cache.EhCacheProvider</attribute>
    <attribute name="QueryCacheEnabled">true</attribute>

    <!-- 日志 -->
    <attribute name="ShowSqlEnabled">true</attribute>

    <!-- 映射定义文件 -->
    <attribute name="MapResources">auction/Item.hbm.xml,auction/Category.hbm.xml</attribute>

</mbean>

</server>