technology

Adding a Hibern8IDE browser to your Hibernate Project

The Hibern8 IDE is a quick’n’dirty interactive Hibernate Query Language (HQL) tool. And while it’s not really an IDE, it’s a pretty slick way of viewing the contents of your persistent Hibernate data store. There are basically two ways of opening up your data store with Hibern8IDE: you can interactively add hibernate properties and configuration files or you can programmatically start Hibern8IDE with a hibenate configuration object. Since I hate to constantly repeat myself, I opted for the programmatic option.

If you’ve been following my series on Hibernate, then you know that I’ve been keeping all my configuration files in the cfg directory tree. So I decided to simply traverse the cfg directory tree, adding all .hbm.xml files to a configuration object before passing the configuration object on to Hibern8IDE. And since traversing a directory is a pretty common operation, I decided to implement a general solution consisting of a simple TreeWalker class and a TreeAction interface.

14 May 04: Max Andersen from the Hibernate team comments that the load order of .hbm.xml files is important when a subclass or joined-subclass is defined in a separate file from the parent. If the parent is defined in parent.hbm.xml and the child is defined in child.hbm.xml, then parent.hbm.xml must be loaded before child.hbm.xml.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package util; 
 
public interface TreeAction {
    public void handle( java.io.File f );
}
 package util;
 
import java.io.File;
 
public class TreeWalker {
 
    public void walk ( TreeAction actor, File root )
    {
        if ( root.exists() ) {
            if ( root.isDirectory() ) {
                File[] files = root.listFiles();
 
                for ( int i=0 ; i<files.length ; ++i ) {
                    if ( files[i].isDirectory() ) {
                        this.walk( actor, files[i] );
                    }
                    else if ( files[i].isFile() ) {
                        actor.handle( files[i] );
                    }
                }
            }
            else if ( root.isFile() ) {
                actor.handle( root );
            }
        }
    }
}

The top level Ide class treats each command line argument as a configuration root directory It contains a static inner class Action implementing TreeAction that adds each .hbm.xml file to the hibernate configuration. And we hand the configuration object to Hibern8IDE once all the configuration directories have been traversed.

Note that static inner class Action has to catch the hibernate MappingException to match the TreeAction interface. After catching the MappingException, we use it to create a RuntimeException. This trick of wrapping checked exceptions in a RuntimeException comes courtesy of Tim Bray. This is an appropriate response because our only other choice is to ignore it entirely.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.io.File;
 
import net.sf.hibernate.cfg.Configuration;
import net.sf.hibernate.MappingException;
import net.sf.hibernate.HibernateException;
 
import net.sf.hibern8ide.Hibern8IDE;
 
import util.*;
 
public class Ide {
 
    static class Action implements TreeAction {
        private Configuration config;
 
        public Action ( Configuration aConfig )
        {
            config = aConfig;
        }
 
        public void handle ( File f )
        {
            String name = f.toString();
            if ( name.endsWith( ".hbm.xml" ) ) {
                try {
                    config.addFile( f );
                } catch ( MappingException e ) {
                    throw new RuntimeException( e );
                }
            }
        }
    }
 
    public static void main ( String[] args )
        throws MappingException,
               HibernateException
    {
        Configuration cfg = new Configuration();
        Action      actor = new Action( cfg );
        TreeWalker walker = new TreeWalker();
 
        for ( int i=0 ; i<args.length ; ++i ) {
            File f = new File( args[i] );
            walker.walk( actor,f );
        }
 
        Hibern8IDE.startWith( cfg );
    }
}

Finally, we add a new ide action to our build file (other minor buildfile changes not shown here). The single command line argument references our configuration directory.

1
2
3
4
5
6
7
8
9
10
11
...
<target name="ide" depends="compile,setup-run">
  <java classname="Ide"
        fork="true">
    <classpath refid="classpath.ide" />
    <arg value="${cfg-dir}" />

    <sysproperty key="log4j.configuration" value="${LOG4J_OUT}" />
  </java>
</target>
...

Now we can launch the Hibern8IDE query tool by simply typing “ant ide”. Here’s the source for adding a Hibern8IDE query tool to your Hibernate project.

Disclaimer: I don’t claim to be an expert on hibernate. Please send comments and corrections.