It was December 7, 2005. I was standing at the side of a large hotel meeting room in Miami Beach, Florida. The room was filled with developers from all over the world who had descended upon the beautiful sandy beaches of southern Florida for a single purpose: to talk about Spring.

What can I say? It was a room full of nerds. Rather than soak in the sun and surf, we all gathered inside to bask in the warm glow of our laptop screens to learn more about our beloved framework from those who know it best.

On that particular night, we were hanging on the words of Spring’s creator, Rod Johnson, as he presented the opening keynote for the conference. He spoke of Spring’s origins and the successes it had enjoyed. Then he invited a few members of the Spring team to the podium to introduce new features that were to be in the next version.

He wasn’t far into his presentation when Rod made an announcement that caught everyone’s attention. We were all expecting these great new features to be available in Spring 1.3, the supposed next version of Spring. Much to our surprise, Rod informed us that there would be no Spring 1.3; the next version would be Spring 2.0.

The decision to bump up the major version number of the next release isn’t made lightly. Such an action connotes a significant advance in Spring. If the next version of Spring would be 2.0, then we could expect major enhancements. Indeed, ten months later, Spring 2.0 would be released with an abundance of new capabilities, including:

• Simplified XML configuration and the option to create custom configuration elements
• Greatly simplified AOP and transactions
• Support for Java 5 annotations for declaring aspects, transactions, and required bean properties
• The ability to create beans from scripts written in JRuby, Groovy, or BeanShell
• New JDBC templates to support named parameters and Java 5 features
• Improved JMS support, including receiving messages asynchronously (for creating message-driven POJOs)
• A new form-binding JSP tag library
• Several convention-over-configuration improvements to reduce the amount of XML required to configure Spring
• Support for the Java Persistence API (JPA)
• Enhanced bean scoping, including request and session scoping of beans for web applications
• The ability to perform dependency injection on objects that Spring doesn’t create (such as domain objects)

At one point in his keynote, Rod said that if the wealth of new features being introduced didn’t justify a jump to 2.0, then how would they ever be able to justify a 2.0 release?

That’s not all. In addition to the work being done on the core Spring Framework, several interesting Spring-related projects were underway to provide additional capabilities on top of Spring. Among them:

• Spring Web Flow, which is based on Spring MVC and enables development of flow-based web applications
• XFire, for exporting your Spring beans as SOAP web services
• Spring-WS for creating contract-first web services
• Spring Modules, which provides (among other things) declarative caching and validation
• Direct Web Remoting (DWR) for Ajax-enabling Spring beans
• Lingo, which makes it possible to asynchronously invoke methods on remote beans

Then it occurred to me: if all of these new advances in Spring didn’t justify a second edition of Spring in Action, then what would? As it turned out, Manning was thinking the same thing.

And now, well over a year later, here’s the long-awaited update to Spring in Action that covers many of the new features of Spring 2.0. It has taken me a lot longer to finish than I had planned, but I hope that it was worth the wait. My goal for this edition is the same as with the first: to share the joy of developing in Spring. I hope this book will serve to enhance your enjoyment of Spring.