Currently I'm working on the web chapters of the book.  It turns out that Spring Roo has a lot of interesting approaches for dealing with HTML content.  Things like using XML-parseable JSP pages (called JSPX pages), generation of REST-friendly tags for forms (the form:update tag generates the proper form fields and URL to process PUTs for example).

So I am going to be pretty consumed in writing the two web chapters and also taking all of your VERY helpful feedback into Chapters 1-4.  Gordon is working on other chapters as well, focusing more on integration services, so keep up with him over at GordonDickens.com.  We were kicking around doing a webinar or seminar online soon, so if you have any interest let us know via the @RooInAction twitter user.

Thanks again, and we'll update you soon.

Oleg Zhurakousky talking about S/I, Rabbit MQ, GemFire

All of these tools are owned by VMWare/SpringSource.  RabbitMQ and Gemfire are recent acquisitions.

Oleg started by giving us a basic overview of the challenges of JMS as a standard.  Since it just defines an interface, interoperability is a big challenge.  Also, since the producers and consumers both are wired to a destination via code / configuration, moving to another destination generally involves recompiling code on both sides.  Also JMS developers generally have to deal with the fact that non-Java systems can't directly interface with JMS, various middleware, and connection management, to name a few issues.

Enter AMQP

The AMQP (advanced message queuing protocol) was created by a group of developers known as the AMQP working group.  It provides a wire-level message protocol that is built to support interoperability across all implementations.  The key distinction between JMS and a wire-level protocol like AMQP is that AMQP does not specify an API, only the format of the data on the wire.  The working group is comprised of companies from Microsoft to RedHat to financial companies like JP Morgan Chase, Credit Suisse, and Bank of America, where high-volume, real-time feeds of data need to be processed from a variety of systems.

The RabbitMQ Acquisition

SpringSource/VMWare acquired RabbitMQ this year with the goal of owning a highly scalable AMQP messaging service.  Licensed using the Mozilla Public License (with of course, support contracts available) the platform runs on just about any platform, and the code is primarily written in ERLang.  Oleg explained how easy it is to configure a cluster - once you start the cluster, elements are immediately replicated.  You can set up things like in-memory or persistent replication stores, passive/active models, and a number of other configurations.

Oleg said the biggest thing that struck him about RabbitMQ is how fast it is.  And he should know, working for a number of years in various message oriented middleware, and now becoming a member of the Spring Integration team with Mark Fisher.  He showed us how quickly RabbitMQ starts, consumes and delivers messages, and how easy it is to administer using a simple command-line interface.

Exchanges and Queues

Unlike JMS, where developers attach connections and sessions, then produce messages and communicate with a wired Destination, RabbitMQ (and I assume AMQP) deals in terms of Exchanges and Queues.  Exchanges receive messages from a sender, and Queues deliver messages to a receiver.  Furthermore, these elements are just referred to by a name, not a physical class reference, so they can be reconfigured on the fly, at runtime.

In the demonstration, Oleg sent messages from a Spring client using Spring Integration, delivering them to an Exchange in Rabbit MQ.  From there, he persisted the data in a persistent cache called Gemfire (more on that in a minute) and then another component delivered the message to the consumer via a queue.

Oleg says SpringSource is working on Spring components for RabbitMQ like a RabbitMQ Template and Proxy Factory Bean, to bring it into the Spring fold.  From there, we can orchestrate the activity via Spring Integration, which can define workflow to move things along.  

Oleg spent some time discussing Spring Integration's pipe-and-filters approach to integration, and also urged us all to pick up a copy of Enterprise Integration Patterns, which can be found online at www.eaipatterns.com (you can order the book via the website as well).  He explained that Spring Integration is based very heavily on the EI patterns, so that the book will be a worthwhile investment if you are looking into using Spring Integration.

About Gemfire

Gemfire is a distributed cache engine that SpringSource also recently purchased.  In the demonstration, as I said above, Oleg is persisting the data from the first (incoming) message flow into this cache so that it can be sent as quickly as possible.  He says the team has been working with Gemfire's developers to take advantage of features like sequencing messages, which we assume will be forthcoming in a future release.  

One of the interesting things about tools like Gemfire is the fact that large-scale sites like Amazon and eBay are actually already using huge, widely distributed caches to store data in memory across a large number of redundant hosts.  This, in a way, makes the data safer than if it was just being backed up with a disaster recovery plan - if there are thousands of hosts replicating the information, and delivering it to consumers who need it in the regions they are requesting it from, it becomes difficult to stop hosting that data.  A fascinating topic I'm really not doing justice to.

Wrap-up

Oleg's talk was really amazing.  He showed how VMWare / SpringSource is acquiring companies that can deal with massive data delivery and storage problems.  In my opinion VMWare is going after Oracle's business by side-stepping the physical box issue.  Why use a series of physical servers with CPU licenses when you can just use time on a large scale cloud?  Amazon does it.  Google does it.  With VMWare, Spring and some of these advanced technologies, it will be interesting to see some big customer rollouts in cloud-based systems, and to see how they stack up over offerings put together with conventional iron.

Note:  a recent blog post by Peter Ledbrook describes Rabbit MQ a bit more in detail.

Ken Rimple works as the Education Director and delivers Spring training courses for Chariot Solutions, a SpringSource partner, and is host of the Chariot TechCast, which can be found at techcast.chariotsolutions.com. 

I cooked up the idea after interviewing Ben Alex in November. Since Gordon and I are both Spring consultants and trainers and cover a lot of Spring-based technology, we felt that we were poised to jump on the book, as Roo is proving wildly popular and we already had the background to start quickly. And anyway, I think Manning owes Gordon something as he owns and technically reviews just about every MEAP and a large number of books (just kidding).

We all thank Manning for giving us this opportunity.

Spring Roo in Action is going to cover all aspects of this tool, including basic functionality, JPA and MVC features, Roo and AspectJ ITDs, add-ons, and a lot more. I am currently wrapping up chapter one, and a MEAP will be coming within a few months.

This is a big commitment, and so I am going to start some occasional blogging on topics of interest around Roo, and monitoring the book forums and Spring forums, etc. I am looking forward to contributing, and Gordon and I are thrilled that Craig showed interest in participating as well. He has already been extremely helpful to us in getting started.

More news soon.

The Setup

Here's a table definition and a stored procedure to go with it. The table defines sales for a book in an online store (ala the old Sybase pubs database). The stored procedure (function) just goes and counts the total revenue from all sales on a given book id.

The table schema

CREATE TABLE sale
(
book_id BIGINT NOT NULL,
sale_id BIGINT NOT NULL,
quantity INT NOT NULL,
sale_price DECIMAL(6,2) NOT NULL
);

(other tables and keys omitted for brevity)

Stored Procedure

CREATE OR REPLACE FUNCTION salesByBookId(
 book_id int)
 RETURNS decimal
 AS $$
DECLARE
amount DECIMAL;
BEGIN
 select sum(s.quantity * s.sale_price) INTO amount
 from sale s, book b
 where s.book_id = b.book_id
  and b.book_id = book_id;

 RETURN amount;
END;
$$ LANGUAGE plpgsql;

Ok, so now we've got a procedure to call. You can invoke it in PostgreSQL like this:

select salesByBook(80);

So, what options do I have on the Grails side? Let's look at the simplest option, using Spring's JdbcTemplate:

A Grails Service to call stored procedures

Grails provides the service object for writing re-usable business logic (ala an EJB or Spring Bean). In fact, it actually IS a Spring Bean, and happens to be transactionally managed. Just use grails create-service to build one. Here is an example one using the Spring JdbcTemplate (see the fully optimized version in this post):

class StoredProcedureRunnerService {
 def dataSource
 boolean transactional = true

 // automatically set up by name (Spring injected) on startup
 def sumBookSalesByBookIdWithJdbcTemplate(def bookId) {
     def template = new JdbcTemplate(dataSource)
        template.queryForInt("select salesByBookId(${bookId})")
     }
  }

Some items of note:

• Grails is a Spring application development platform. So you can easily import any standard Spring APIs such as JdbcTemplate
• note the def dataSource in the code above. Spring will look for a bean it has created with that name and inject it automatically. Our Grails datasource has the Spring Bean name of 'dataSource'
• The last line of thesumBookSalesByBookIdWithJdbcTemplate method just calls template.queryForInt - that happens to be the last evaluated statement in the method, which Groovy uses as the return value of the method. In other words, the value returned is the value of the queryForInt method.

So, there you have it. To use this service, just do a defStoredProcedureRunnerService at the top of a Controller, and call it - that class is a Spring Bean, and is autowired at startup time directly into the Controller. Here is my test controller (a fragment):

class TestController {
  def storedProcedureRunnerService
  def index = {
   render(view: "index", 
     model: [bookId: params.bookId != null ? 
          params.bookId : 0])
 }

  def template = {
     def safeBookId = parseInt(params.bookId)

     def result = storedProcedureRunnerService.
       sumBookSalesByBookIdWithJdbcTemplate(safeBookId);

     def model = [result: result,
                  bookId: safeBookId]
        render(view: "index", model: model)
  }
}