Archive for August, 2008

A Minimal Grails JMS Integration

Thursday, August 28th, 2008

We’re implementing some asynchronous processing at work and naturally JMS seems like the right choice. We looked at the JMS plugin, and it is helpful but you need to configure a JMS provider yourself. It’d certainly be more helpful if it configured a provider for you, e.g. ActiveMQ, while making it easy to configure another if you want.

We were having some classloader issues with ActiveMQ, so I configured a new empty app just to get that working, without the clutter of all of our code, the other various plugins, etc. I thought I had everything working – at least the app started – but although I didn’t get errors sending test messages, I wasn’t seeing any output in the console from the listener I’d configured.

It turns out it was a Groovy issue – I was trying to send a text message but ended up sending a GString, which was sent as an ObjectMessage, so when I called “message.getText()” in onMessage() it failed, and the Spring wrapper class just logs the exception so I didn’t see anything.

So anyway, I thought I’d post the app I created to help others get started. It’s intentionally very basic – it uses an in-memory instance of ActiveMQ (so there’s no extra step of starting an external server) and configures a single queue, plus a single listener and a simple Controller method to send test messages. It doesn’t use the JMS plugin, but Spring’s excellent JmsTemplate makes sending message trivial. Adding other queues, listeners, and senders would be simple by using the existing configuration as a guide.

Download the sample app here. Run “grails run-app” and navigate to http://localhost:8080/jms/jms and you should see a message in the console after the receiver logs the receipt of the message that the JmsController sends.

A Grails UI Performance Plugin

Tuesday, August 26th, 2008

I wrote up some notes in my previous post about some recent work I’ve done implementing the Yahoo Performance Team’s 14 rules for UI Performance. We’d talked at work about making it a plugin, but I wasn’t sure if it was sufficiently different from the excellent Jawr plugin to justify it. So I took a look and I think that my approach has some benefits that do justify a second plugin.

One significant feature that I’m providing is versioning and far-future Expires headers and caching for images in addition to JavaScript and CSS. Of course images aren’t very compressible, so gzipping them doesn’t make much sense, but the image payload of most sites is going to be a lot larger than that of the .js and .css files, so it makes sense to try to get clients to cache those also.

Another is a taglib that helps keep javascript at the end of the page. Sitemesh gets in the way here – there can be a lot of code in your layout GSPs after the layoutBody call, so DependantJavascriptTagLib allows you to define one or more hidden JavaScript declarations in your GSPs and render them all from the layout at the end of the body (Sitemesh has “content” tags that support this but there’s a bug where script tags lose their opening bracket so I’m using a technique borrowed from here).

Finally there’s simplicity – this was designed as a Grails plugin, so it has a more focused feature set and has fewer moving parts, preferring convention over configuration.

Having said that, there are advantages and disadvantages of both approaches:

Reasons to use Jawr versus using this plugin:

  • a lot more features, e.g. I18n, DWR, and JSF support, choice of minification approach, etc.
  • more configurable, e.g. exclusion lists – I gzip/minify/version everything
  • it’s not Grails-specific, so the time you spend learning its features will be useful when you want to use it in non-Grails apps

Reasons to use this plugin versus using Jawr:

  • the bulk of the work is done during the build, so no temp files, everything is in the war and problems are caught during the build instead of after deployment
  • it versions and sets Expire on images, and rewrites inner urls in css files to point to versioned images
  • supports Sprites via a taglib
  • helps move JavaScript to the end of the body via a taglib
  • doesn’t use a servlet – only a few taglibs and a Filter, letting the container continue to serve static resources
  • less processing at the server – it only needs to check if client supports gzip when rendering <javascript>, <css>, and <img> tags in GSPs
  • more Grails-friendly – in development mode it does nothing, and is only enabled in production mode, so there’s no need to check for modifications since Grails doesn’t support that in production mode

So as you’ll see from the code, there’s not much to it:

  • the plugin script wires up a simple Filter that adds caching headers in production mode
  • an Events.groovy script hooks into the war building process and gzips/versions/minifies static resources before the war file is packaged
  • and five taglibs handle the work of inserting the correct version and paths for resources, choosing to render the path to the gzipped files if the client supports it


You can download an early version of the plugin here, and a sample app demonstrating its use here. I’m waiting on some feedback before I put it up at since it’s still got some rough edges. Note that they’re configured as Eclipse projects but I’ve removed the Grails classpath jar entries and replaced them with a User Library called ‘grails’ to simplify the classpath. Either create a similar User Library (just include everything in GRAILS_HOME/dist and GRAILS_HOME/lib) or just re-add those jars explicitly like you’d have in a regular app.

Testing it out:

First run “grails run-app” from the performance-test project. It’s a basic app with one domain class, but the point is to show that in development mode it functions just like an app without the plugin – it serves the files from the file system unchanged and with no extra headers.

But if you run “grails war” and deploy the war in a servlet container (I’ve only tested Tomcat 6.0.16) then you should be able to view the source and see that the .js and .css files, plus all images have versions embedded in the urls and the .js and .css are gzipped and minified, and that the appropriate caching headers are set. The source files are unchanged – you still get to develop with readable files, but when deployed in prod mode, the app is a lot more efficient.

Note that there are very few image files since most are rendered using sprite1.gif via CSS. Also check out http://localhost:8080/performance-test/sprite/index (and views/sprite/index.gsp) for an example of an inline image from a sprite, plus an example of deferred JavaScript.

To install the plugin in one of your apps run

grails install-plugin

Let me know about issues you find or questions you have.

High Performance Grails

Saturday, August 23rd, 2008

I’ve been looking at performance issues for the site we’re building at work. The database is obviously going to be the biggest bottleneck, so we’ve configured 2nd-level caching for read-only tables and some read-mostly tables. We’ve also configured query caching for obvious candidates.

Currently the big hitter is the search page, and some profiling showed that we just needed a few extra indexes and some extra 2nd-level caching, but otherwise it performs pretty well. I still need to test it on production hardware with a large database – the stuff I’ve done so far is on my own high-end developer box with the database, server, and clients all running on the same box.

So I’m now working on applying the 14 rules from Steve Souders and the Yahoo performance team. YSlow has been very useful to measure improvement after each change, and of course Firebug is indispensable.

This is a Grails app, and Grails makes several parts of the process a lot easier, but of course all of these approaches apply to non-Grails apps too.

We’d already put the CSS at the top of the pages and the JavaScript at the bottom, so the next thing I looked at was GZipping content. I configured Tomcat to gzip HTML and text types by adding “compression=’on’ compressableMimeType=’text/html,text/xml,text/plain'” to the HTTP <Connector> element in conf/server.xml. This will change to Apache’s mod_deflate if we end up fronting the Tomcat instances with Apache.

I’m not having Tomcat compress CSS and JavaScript since these are static and I don’t want to keep re-compressing these files for each client, trading I/O cost for CPU cost. So instead I’m compressing once during the build.

This step is currently a little clumsy. Eventually we’ll hook into the war building process using GANT events, but currently I’m unpacking the war after it’s built, compressing each file (leaving the original for the rare client that doesn’t support gzip) and re-packing the war. While I’m doing this, I also use the YUI Compressor to minify all CSS and JavaScript files. This has the benefit of allowing us to develop with readable files but send optimized files to the client.

We also want to configure caching by using far-future Expires header. The best approach for this is to add an Expires header for the year 2038, 10 years from now, etc. and embed a version number in the url but serve the current file. For example instead of:

<script src='/js/foo/bar.js'></script>

we want:

<script src='/js/foo/bar_v2364.js'></script>

The client will get the latest contents of bar.js and the Expires header will tell the browser to cache forever. The version helps us when we deploy a new build and want to ensure that clients re-request the file to get the new latest version. After deploying the new version we’d want to render the new version:

<script src='/js/foo/bar_v2789.js'></script>

We’ll still send them the contents of bar.js but it’ll be newer and since the name is different, the old version will be ignored (and removed from the client’s cache once it’s full) and they’ll use the latest code.

So how to get the version in the urls? Grails has a <g:javascript> taglib but in the past I’d written custom tags to reduce a lot of the boilerplate for <script> tags, CSS <link> tags, and <img> tags and I’ve ported these to this app. Since all JavaScript, CSS , and image files are in the /js/, /css/, and /images/ directories respectively, and we know the extension for JavaScript and CSS files, the custom tags allow us to specify the minimum information, e.g.

<ns:javascript src='bar'/>


<script type='text/javascript' src='/context/js/bar.js></script>

<ns:css name='styles'/>


<link rel='stylesheet' type='text/css' href='/context/css/styles.css' />


<ns:image src='spacer.png'/>


<img src='/context/images/spacer.png' border='0' />

where ‘context’ is the context the app is deployed under (blank for the root context), and ‘ns’ is whatever namespace the tag is registered under. Each tag allows extra attributes and these are just passed through to the HTML (e.g. to specify the id, style, etc.)

Since we’re rendering the urls to most static resources using these three tags, we can do a lot of extra work. During the build, I look up the latest SVN version of the root directory and use that to version the resources. I gzip each JavaScript and CSS file and embed the version in the gzipped and non-gzipped file names, and also rename images.

I write out the version into a properties file for use by the custom tags at runtime so they can append the version into the rendered <script>, <link>, and <img> tag urls so they match up with the names in the war.

Embedded image urls in CSS files are a problem using this versioning scheme, but since I’m processing each file during the build, I take that opportunity to rewrite the urls inside all CSS files with the version embedded, so they also agree with the names in the war, e.g.

background-image: url(/images/cluetip/wait.gif);


background-image: url(/images/cluetip/wait_v2364.gif);

The final optimization I’m working on is reducing the number of files. We have many small JavaScript files being sent to each client and have partitioned our CSS files but typically send the same few files in most pages. So another step in the build process involves bundling JavaScript and CSS files into larger single files. These are minified and gzipped like the rest, and the net effect is fewer requests with a smaller total size.

And I’m also putting together sprites where practical (stretched single-pixel background images and animated images aren’t candidates) to reduce the number of image requests. makes bundling together individual images easy and generates a table showing the position offsets for each image.

Using these techniques I’m seeing YSlow scores of 93-99 on all of our pages when deployed in production mode in Tomcat. We’re planning on using a CDN eventually, but for now I’ve cheated and added ‘localhost’ and ‘’ to the YSlow ‘extensions.firebug.yslow.cdnHostnames’ property since the YSlow score is significantly affected when not using a CDN that it knows about.

Of course developing locally we don’t use war files, so all of this must be disabled unless we’re in production mode. Grails makes this easy (using application.isWarDeployed() and GrailsUtil.environment), so the custom tags skip the step of appending the version in urls, and we’re able to serve uncompressed, unminified files from the file system with no Expires headers.

Using GORM outside of Grails

Saturday, August 23rd, 2008

I’ve seen questions about using GORM outside of Grails in standalone apps but didn’t think much about it – I don’t mind using Hibernate directly. It came up again today on the Grails User mailing list, so I thought I’d take a look.

It turns out that Jeremie Weldin got this working quite a while ago but it no longer works with the latest version of Grails. I’ve been mucking around in the Grails internals trying to get a plugin together that’ll allow multiple datasources in a single app, so I figured it wouldn’t take long to get things going. As usual I was overly optimistic, but several hours later it’s ready to share.

I tried to use the public API and not copy/paste code or call private methods, since I’d like for this to continue working with future versions of Grails. So the main trick here is to call DomainClassGrailsPlugin.doWithDynamicMethods and HibernateGrailsPlugin.doWithDynamicMethods to leverage that functionality. The rest of the app basically just configures the Application, SessionFactory, Configuration, and TransactionManager.

Some notes:

  • It’s set up to support annotated classes via a GrailsAnnotationConfiguration, although I haven’t tested that here. You’d follow the same steps as regular Grails – put the jar in the lib directory and a hibernate.cfg.xml file in grails-app/conf/hibernate.
  • There’s no OpenSessionInView, so you’ll need to manage session flush() yourself. The easiest way to do this is to run your update/insert actions in a transaction – use GormHelper.withTransaction() for this (similar to calling withTransaction on a domain class in Grails)
  • Define data source info just like in Grails, in grails-app/conf/DataSource.groovy. It doesn’t make much sense to use dev or test mode, so just keep everything in the prod section.
  • There’s no Dialect autodetection, so you’ll need to specify that in DataSource.groovy, but you should be doing this in Grails anyway
  • There’s no Spring application context, so to access the Application, SessionFactory, and TransactionManager I’ve stored them in static fields in GormHelper

There’s a sample class that configures things and runs a test script – it’s called Tester in src/groovy. Just run “ant run” from the command line and it’ll compile and run this for you. This executes a script (scripts/Main.groovy) that creates some instances of the domain classes defined in grails-app/domain.

One significant issue that limits the usefulness of this is that as currently configured, you cannot execute anything other than dynamically loaded scripts. This is because Grails artifacts are loaded by a special Groovy/Grails classloader to support reloading and MetaClass magic methods. When I tried adding compiled domain classes to the classpath I was able to reference and import them but the MetaClass methods failed. I’ll have to take a look at how to get this working.

Thanks again to Jeremie Weldin. I did a pretty significant rewrite so I took the liberty of repackaging things under com.burtbeckwith but this wouldn’t have been possible without his original work.

You can download the code here. I’ve omitted the jar files from the zip – check out the README in the lib directory for the list of jars you’ll need to copy from your Grails installation.

Creative Commons License
This work is licensed under a Creative Commons Attribution 3.0 License.