Review - Play Framework Cookbook

The first chapter covers the basics of getting started with the Play framework. This is pretty much all covered in the Play documentation’s tutorial, which makes this the weakest chapter in the book, but that does not make the recipes any less useful. What this chapter does better than the Play documentation is to identify a subset of tasks that you need to know how to do to be productive with Play, before moving onto more advanced topics.

Chapter 2 focuses on keeping controllers clean, with custom code and Play modules for additional features. There are some great examples of how to do this, such as the PDF example which shows you how to implement a custom renderer to avoid adding custom render logic to your controllers.

This is perhaps the most important chapter in the book, because the controller layer is where the benefits of Play’s simple but flexible and powerful approach are most apparent: HTTP routing, HTTP request parameter binding, input validation and generating other response types. These are all covered by recipes in this chapter.

The odd one out is the annotation-based routing recipe, since this uses a third-party module (developed by my colleague, Nicolas Leroux) instead of Play framework core functionality. This is also the only recipe that is an alternative solution to a task covered by a previous recipe, in this case the ‘Defining routes’ recipe in the previous chapter.

Chapter 3 - the shortest chapter in the book - is something of an anomaly. This chapter contains recipes that demonstrate several third-party Play modules. This is certainly useful, and gives a good insight into how modules can provide powerful extensions to Play’s core functionality.

However, it does seem a little odd to provide recipes for just five modules from the 95 Play framework modules available at the time of writing, because a cookbook for how to use the many modules is worth a whole book by itself, especially since many of the modules do not have extensive documentation.

In any case, it is useful to see a few examples of the available modules, to prompt further investigation of the Play module repository.

Chapter 4 follows on from previous chapters by extending the approach used for writing controllers and using modules to recipes that cover integration with third-party APIs. This is an important part of building a modern web application, and this chapter does a good job of picking recipes that demonstrate the different features that Play provides for this: using tags to modularise view template fragments, making web service requests to external services, mapping JSON and XML data, asynchronous requests and caching.

The recipes in this chapter make this all seem easy, which it is, even though these would normally be fairly advanced web application development topics.

Chapter 5 demystifies the business of writing Play modules, which isolate application functionality and make it available to other applications. This is another very useful set of recipes, because when you are getting started with Play it can take a while to get into the habit of modularising your Play applications. An explanation of how to do it is not nearly as helpful as examples that show you how.

This chapter introduces more advanced techniques: as plug-ins, events, Python commands, using a service interface to prevent a module depending on your application, and using bytecode enhancement to allow a module to modify application code at run-time.

The third chapter about modules combines the ideas from the previous two chapters by showing how Play modules can integrate third-party libraries with Play’s APIs so you can use them as if they were built-in to Play as core functionality. These recipes include model class enhancement to use a non-JPA persistence framework or add full-text search functionality, integrating Play plug-in messages with JMS and replacing the distributed cache implementation.

This chapter’s recipes show you how accessible Play makes this kind of advanced integration, with examples that you can adapt. It is only a shame that there is no example of replacing Play’s Groovy templates with an alternative template engine, to expand the demonstration of how much of what Play provides is pluggable.

The last chapter is the most promising, because continuous integration and production deployment are tasks that edge towards the black arts of devops and system administration. These are perhaps the most practical and useful recipes, because they cover necessary tasks that software developers often lack specialist skills for. This covers a collection of tools including Jenkins, Apache, Nginx, Lighttpd, as well as techniques such as virtual host and SSL configuration.

However, the description of Play application deployment is tantalisingly incomplete. Play currently lacks a standard file distribution and server deployment model, such as the cross-platform WAR deployment supported by Java EE application servers. As with the previous chapter, although the scope of a book like this always has to be limited, it would still have been nice to see platform-specific packaging and deployment instructions for platforms like Debian and Red Hat linux.

The appendix is a collection of links to several other modules and sources of information about the Play framework. It’s awesome. I would say that, though, because it includes a link to the Lunatech Research web site, where I have published several Play articles, and a list of Twitter accounts, including my own as well as the other Play committers’.