Release Announcement: 13/11/2009

5 cool things available in Spring 3.0

1. Java 5 fully used throughout the whole API. In 2.5 the core is still Java 1.4 compatible, 3.0 is written in and requires Java 5.0. This means much greater use of generics. Unrelated but they have also included many performance enhancements.
2. SpEL. Spring Expression Language gives access to nested bean definitions and system properties via #{…} syntax in property values. These dynamic #{…} expressions and static ${…} placeholders can also be used to inject property settings via the @Value annotation. This should much simplify property setting.
3. Comprehensive REST support. Spring 2.5 MVC is an excellent pattern. The simplicity of annotated controllers results in very clean implementations. 3.0 takes this system further by building in Restful support and a RestTemplate for clientside REST.
4. Spring 3.0 UI Field Formatting. Springs formatting system has always been useful in web and desktop applications. Its an effective way to remove a lot of boilerplate code from a system. This new system of annotations allows common formats to be applied to classes, model properties and methods. Check it out its very cool.
5. Many enhancements migrating to java.util.concurrent including ThreadPoolExecutorFactoryBean which exposes the native ExecutorService interface. The concurrent package is very good indeed, so bringing more support into spring is just fantastic.

Of the 5 mentioned here its only the tip of the iceberg as regards new features. This release is very rich. As usual with spring its when you have something to solve that you really appreciate it.

                          

Release Announcement: 19/11/2007

I don’t want to review all the improvements that were made, but thought it would be interesting to pick a favorite feature and explain why for me its the best feature. Perhaps some of the few remaining projects out there will move up and start taking advantage of this fantastic framework. After all, with the release notice for 3.0 RC1 back in September soon there will be reasons to upgrade again!

I have seen a few of these upgrades through now, and so far they have all been straightforward. The work is not in the upgrade, its in the work to use the features. This can be done over time to reduce the impact. The last one I did for instance was mainly re-factors to use generics which is never a bad idea, and conversion of tests to use the new annotation based Junit 4 framework.

So, my top 5 candidates for Favorite Upgrade Feature.

1. Takes advantage of new language features in Java 5 and 6. This includes adherence to JDBC 4.0, JTA 1.1, JavaMail 1.4 and JAX-WS 2.0. The addition of Generics in the high level API is a particular boon. The core is still compatible with Java 1.4, but the addition of Generics in the higher level API’s means you can take full advantage of generics in most of the important areas. If your already on Java 5 you can get rid of masses of warnings, or all those dangerous suppressions. The code gets cleaner and more of your casts will be checked upfront. For me this is a huge development productivity enhancement.
2. Greater use of annotations in configuration. This is particularly useful for wiring of web services and the MVC controller. The new @Qualifier annotation is essential when Auto-wiring beans and needing to choose from multiple beans of the same type. Not such a massive deal for me, as I like the way that xml provides a map of the application. Well if its well structured it does. There are some places that annotations are excellent though and the MVC layer is just that, as it allows you to see exactly what a controller is doing. What it responds to, and how it redirects. The new way to implement the get, post, redirect pattern is awesome more detail in the MVC API Documentation.
3. Better JDBC Support including better handling of errors and the new SimpleJDBCTemplate. Oh! and the addition of named parameter support is very handy indeed.
4. New annotation based support the Junit and Nunit integration testing. This includes new classes for spring integration testing, and removes the need to extend from the TestCase framework. The net result of this is greater test flexibility, easier configuration and the ability to easily inject fixture dependency and share test support utilities.
5. Increased performance. Not sure what the specific changes are but I quote from their website: We recommend upgrading to Spring 2.5 from all previous Spring 2.0.x versions in order to benefit from the new features as well as the significant performance enhancements that Spring 2.5 has to offer.

For me the winner is point 1, Java 5 language features, but it was a hard decision. I have seen an incomprehensible test framework re-factored into something manageable. It was made possible by point 4. The simplicity these two features bring to the code should be argument enough to begin your upgrade in the next iteration. Go for it!