I’ve spent some time getting Wicket (just 1.4.2), Guice 2, and Warp-persist 2.0 running together. Everything seems to be running happily but I haven’t tried anything complicated. I can inject my Hibernate session and start a transaction though. Just remember that Warp-persist 2.0 is in active development and wicket-guice doesn’t mention Guice 2.0 at all. Use it this all together at your own peril.

It’s really not that much of a stretch from the current 1.0 releases of Guice and Warp-persist. And really, most of what I did I got from blog 1 and blog 2. The current Warp-persist 2.0 docs are a work-in-progress.

First, let’s setup the Maven 2 dependencies under the assumption you got Wicket and Hibernate already configured appropriately.

We’ll need wicket-guice which is dependent on Guice 1.0. We’ll remove that dependency.

        <dependency>
            <groupId>org.apache.wicket</groupId>
            <artifactId>wicket-guice</artifactId>
            <version>${wicket.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>com.google.code.guice</groupId>
                    <artifactId>guice</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

Then, we’ll add a dependency for Guice 2.0.

         <dependency>
            <groupId>com.google.inject</groupId>
            <artifactId>guice</artifactId>
            <version>2.0</version>
        </dependency>

Lastly, we’ll add our dependency for Warp-persist 2.0. Unfortunately, there aren’t any public Maven repositories that have a recent build of Warp-persist 2.0 stored. We’ll need to download the most recent public build (you can get the source and build your own snapshot, but I leave that as an exercise to the ambitious) and manually install it our local Maven repository.

Head to the public dist and download warp-persist-2.0-20090214.zip. The snapshot is out-of-date (as of 2009/10/12)! Extract the warp-persist-2.0-20090214\warp-persist-2.0-20090214.jar located in the zip file to some local directory. Then run the following Maven command to install this jar into your local repository.


mvn install:install-file -Dfile=warp-persist-2.0-20090214.jar -DgroupId=com.wideplay.warp -DartifactId=warp-persist -Dversion=2.0-20090214 -Dpackaging=jar -DgeneratePom=true


With any luck, you’ll be able to add the last Maven dependency.

        <dependency>
            <groupId>com.wideplay.warp</groupId>
            <artifactId>warp-persist</artifactId>
            <version>2.0-20090214</version>
        </dependency>

Maven is exciting.

The SessionPerRequestFilter from Warp-persist 1.0 has been deprecated. In our web.xml, we’ll have to use the new PersistenceFilter instead. It’s pretty straightforward. Just make sure you define the PersistenceFilter mapping first. This’ll get us towards our open session in view goal.

	<filter>
		<filter-name>wicket.web</filter-name>
 		<filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
		<init-param>
			<param-name>applicationClassName</param-name>
			<param-value>com.atomicgamer.web.WebApplication</param-value>
 		</init-param>
 	</filter>

    <filter>
        <filter-name>warpPersistFilter</filter-name>
        <filter-class>com.wideplay.warp.persist.PersistenceFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>warpPersistFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <filter-mapping>
        <filter-name>wicket.web</filter-name>
	    <url-pattern>/*</url-pattern>
    </filter-mapping>

We’re almost there. In our subclasses WebApplication, we need to configure Warp-persist’s PersistenceService, tell Guice about it, and tell Wicket-guice about everything. One difference from Warp-persist 1.0 is that we don’t need to manually start the PersistenceService. The PersistenceFilter takes care of that for us.

        //We'll be wanting to use Hibernate
        Module warpModule = PersistenceService.usingHibernate().across(UnitOfWork.REQUEST).buildModule();
        //And use the Warp-persist module followed by our own module for Guice.
        Injector injector = Guice.createInjector(warpModule, buildWebModule());
        //And we'll probably be wanting to use some injecting inside of our Wicket classes
        addComponentInstantiationListener(new GuiceComponentInjector(this, injector));

For completeness, here’s the buildWebModule() method inside my WebApplication. There’s no magic here. I’m using a Hibernate annotation configuration and telling it about my DAO classes.

    protected Module buildWebModule()
    {
        return new Module()
        {
            public void configure(Binder binder)
            {
                AnnotationConfiguration configuration = new AnnotationConfiguration().configure();
                binder.bind(Configuration.class).toInstance(configuration);
                configuration.addAnnotatedClass(Game.class);

                binder.bind(GameDAO.class).to(GameHibernateDAO.class);
            }
        };
    }

With this all set, I can take those DAO and use them finally! Let’s get a session.

public abstract class HibernateDAO<T, ID extends Serializable> implements DAO<T, ID>
{
    @Inject
    protected Provider<Session> session;

And more importantly, let’s start a transaction.

    @Transactional
    Game getGame(long id)
    {
        return gameDAO.findById(id);
    }

And that’s all. If you’re already running 1.0 versions of everything, it’s not too bad to upgrade to 2.0. Practically everything is backward compatible and just deprecated at this point. So if you want to be on the bleeding edge of Hibernate 3.5, Guice 2.0, Warp-persist 2.0, Wicket 1.4.2, well, there you go.