Generating sql files in Maven using hibernate tools

Lars Vonk — Thu, 04 Dec 2008 21:42:01 +0000

Hibernate’s SessionFactory has some very powerful functions available like generating your tables from your hbm files using the hbm2ddl.auto property. This is very handy for laptop testing where you can let hibernate generate your complete scheme on the fly.
Although useful on your laptop, it is probably not want you want to do in a real environment. Luckily hibernate tools provides generating sql files via an Ant task. But if you are using Maven like me how can we integrate this in our build?

The answer is the maven-antrun-plugin. This plugin allows you to integrate ant tasks in Maven builds. To get the sql files we first create the Ant build.xml that will call the Ant task provided in the hibernate tools

In the above xml I declared the hibernatetool task via taskdef. Secondly, I created a target called generate-sql that I am going to call from the Maven build. The hibernatetool and hbm2ddl tasks are documented on the hibernate tools page, so checkout that if you need more info on how to configure.
As you can see I am using ${} properties. These are passed in from the Maven configuration. The file hibernate-for-sql-generation.properties contains the Dialect that Hibernate will use to generate the sql file.

Next is the relevant part of the pom.xml. Since I don't want to generate the sql each time I do a Maven build, I added it into a profile:

[/xml]

	generate-sql
	


				org.apache.maven.plugins
				maven-antrun-plugin
				1.3
				
					
						generate-sql
compile
						
							




								
									
								
							
								
						
							run
						
					
				
			
		
	

[xml]

The really interesting part starts from the execution tag. In here I tell the maven-antrun-plugin what to do. As you can see I pass in, amongst other things, the Maven test classpath. The classpath is needed by Ant to locate the org.hibernate.tool.ant.HibernateToolTask. Since I pass in the test classpath I added the hibernatetools jar as a dependency with scope test in the pom.xml.

When you now run mvn compile -Pgenerate-sql it will generate a sql file in the directory target/database. With some minor adjustments you are ready to use the generated file for creating your tables on all environments.

Lars

Maven and Jetty: A Perfect fit

Lars Vonk — Mon, 24 Nov 2008 21:50:14 +0000

The jetty-maven-plugin is a real life saver when it comes to developing web applications. In the past I had such horrible experiences with the eclipse WTP plugin that I banned it from my toolset forever.
For a year now I use the jetty-maven-plugin and it makes developing so much easier. In this blog I will give an overview how you can setup your development environment using Maven and Jetty.

When developing webapps on my local machine I set myself the following requirements:

1. I want to be able to edit classes and views (Wicket html files or jsp’s) and see the results in the browser fast without having to build a war file and manually redeploy.
2. I want to be able to switch between an in memory database, typically a Hsqldb and the real target database (Oracle). Since I am using Hibernate as ORM I also need to be able to switch settings like the hibernate.dialect property to match my database.
3. The WAR file produced should also run on the target application server, JBoss in my case.

Let’s see how Jetty fulfills these requirements.

The example project consist of a webapplication using Spring, Hibernate and Wicket. The target platform is JBoss with an Oracle database.

To get started we first need to add the jetty-maven-plugin in the pom.xml of the war project.

[/xml]

  jetty-maven-plugin
	org.mortbay.jetty
	7.0.0pre3
	
		/example-app
		3
		
			
8090
				0.0.0.0
			
		
	

[xml]

That’s it. When running mvn jetty:run the webapplication is available under http://localhost:8090/example-app. For a complete reference of all possible configuration settings I suggest you read http://jetty.mortbay.org/jetty/maven-plugin/run-mojo.html

Fast redeploying.
In my experience, I have no evidence, Jetty is the fastest starting servlet container out there, especially when you compare it with full blown application servers such as JBoss. JBoss is perfect for production and acceptance environments but when developing I have different needs. This is where Jetty gets a big plus.
Regarding redeploying: By default the jetty-maven-plugin automatically reloads/redeploys the webapplication whenever it detects a change. You can use the scanIntervalSeconds and scanTargets configuration properties to tweak change detection. Downside of this automatic reloading is that it will always reload, even if you are just developing for a couple of minutes and save changes in between. Not only does this consume unnecessary resources, it will eventually lead to full PermGen space which results in an OOME.
A way to counter this is to set the reload option of the jetty-maven-plugin to manual. Now reloading will only occur on a linefeed (hitting enter) in the console where you started jetty.

Switching databases
When developing a webapplication I want to be flexible. I want to be able to connect to a fast in memory database, to the target database and to a database that is for instance on a test machine. How can we achieve this with jetty? In my case I have two local databases: a Hsql database and an Oracle database installed on a VMWare image.
Since my Spring context uses a JNDI configured datasource I need to add those in Jetty as well. For this you need to create set the jettyEnvXml property in the jetty-maven-plugin. This property points to the jetty configuration file, called jetty-env.xml, containing the datasource in our case. But we also need to be able to switch hibernate dialect. Since we are using Spring we have the PropertyPlaceHolderConfigurer in our applicationContext in SYSTEM_PROPERTIES_MODE_OVERRIDE mode. This means that system properties override values defined in the applicationContext or the property file (if any). Together with Maven’s profiles we can now configure the jetty-maven-plugin so we can switch databases as needed.

The relevant parts of our pom now look like this:

[/xml]
...

  jetty-maven-plugin
	org.mortbay.jetty
	7.0.0pre3
	
		/example-app
		manual
                ${jetty.env.file}
		
			
8090
				0.0.0.0
			
		
		
			
				hibernate.dialect
				${hibernate.dialect}
			
		
	

...


		jetty-oracle

			${basedir}/src/test/resources/jetty-env-oracle.xml
			org.hibernate.dialect.Oracle10gDialect
		
	

		jetty-hsql

			${basedir}/src/test/resources/jetty-env-hsqldb.xml
			org.hibernate.dialect.HSQLDialect
		
	

[xml]

The contents of the jetty-env-hsqldb.xml is as follows:

[/xml]



	
		jdbc/example
		
			
				org.hsqldb.jdbcDriver
				jdbc:hsqldb:mem:test
				sa
				
			
		
	

[xml]

Via this configuration we are able to switch between Oracle and Hsqldb by specifying the profile at the commandline. For example mvn jetty:run -Pjetty-hsql in case we want the Hsqldb.

Servlet container compatibility
We are almost there. As said before, the example application is using a JNDI configured datasource and refers to it in the applicationContext using a jee:jndi lookup:

[/xml]

[xml]

When deploying the produced WAR file in JBoss it gives an error saying that jdbc is not bound. To get the application up and running in JBoss as well you to follow the steps as described in http://forums.sun.com/thread.jspa?threadID=626778. This is caused by the fact that not all servlet containers have the same way of registering jndi values.

Conclusion
Jetty and Maven go well together. The jetty-maven-plugin provides an easy way to use Jetty in development and enough flexibility to switch for instance databases when developing. I gihly recommend using the jetty-maven-plugin when developing. But make sure you check that the WAR file also runs on your target application server on a daily basis.

Vonk's Blog » Maven

Generating sql files in Maven using hibernate tools

Maven and Jetty: A Perfect fit