I am regularly asked about the origin of the name “Spring.”

The name goes back to late 2002. In November 2002, I published Expert One-on-One J2EE Design and Development. The book was accompanied by 30,000 lines of framework code, which had accounted for a good deal of the year full-time I put into writing the book. (Writing a 750 page book is enough work on its own; writing a substantial framework to go along with it is sheer masochism. It was hard.) Many of the fundamental concepts of the Spring Framework were there: an already capable IoC container, with BeanFactory and ApplicationContext…

If you're reading this blog, chances are that you already know Spring is a pretty popular framework. Most J2EE developers who've ever used it simply love it, as illustrated by 12+ books, 1,000,000+ downloads, 14,000+ forum members etc. Still, even I was surprised when my Australian Spring user group announcement a little over a week ago generated this much interest... As of today, we've had over five hundred registrations to attend these three meetings. Indeed, we've needed to move the Sydney meeting to larger premises, with the Brisbane and Melbourne meetings almost booked out. If you're…

I was in San Francisco for Oracle World. I even spoke briefly in Thomas Kurian's keynote on Java middleware. But Neelan and I had to leave on Tuesday and missed the Big Deal: Larry Ellison announcing that Oracle are offering support for Linux.

This is an interesting event from the perspective of the open source business. What are the wider implications?

Oracle are offering support for an open source product that they did not create and don't control.

This is possible for a number of reasons:

• Linux is not a product. It is a class of technology, and companies or organizations assemble, document, distribute and support products.
• Linux support is already commoditized to some extent. Red Hat is only one of several distributors offering support.
• The leadership of Linux is diffused. Linus Torvalds does not work for a big distributor; Red Hat does more than most but no single company provides clear leadership.
• The leadership of Linux matters less than you think. Linux is not primarily an engine of innovation, but an engine of commodization.

However, it's interesting to think about what the limits are for companies such as Oracle in providing…

Rod and I are here in San Francisco at Oracle OpenWorld 2006. This is indeed a scene. I can't decide if "hubris" or "impressive" is the right way to describe it but the numbers don't lie. They are expecting 45000 people for the conference and the City of San Francisco thinks the show will generate $50-60M in money for the city. Apparently, no Oracle employee is allowed to stay in a hotel north of the airport. One of the more shocking things was that the city blocked off a chunk of Howard St. in front of Moscone for the conference.

In this morning's Oracle Develop keynote given by Thomas Kurian, Senior Vice President at Oracle, Spring was front and center. Thomas had Rod get on stage during the keynote and describe what Spring is and what's new with Spring 2.0. Rod also talked about the collaboration…

Spring Web Flow is a product of the Spring community focused on the orchestration of user interface flow within a web application.

This release contains many improvements and several exciting new features.  We consider it the most stable release to-date and, at last, the release that makes the Spring Web Flow 1.0 final roadmap feature complete.  Spring Web Flow 1.0 final will be released next week with minimal changes.  Between now and then we encourage you to test 1.0 RC4 to help catch any remaining issues before the big 1.0 launch.

Note there are user-affecting changes in this release.  1.0 RC3 or earlier users should review the upgrade guide which outlines these changes in detail.

The new and noteworthy in 1.0 RC4 is an exciting list, including: 

New and Noteworthy

As the final release candidate before Spring Web Flow 1.0 final, Spring Web Flow 1.0 RC4 introduces powerful new features such as render actions (1), evaluate actions (2), set actions (3), flash scope (4), flow execution attributes (5), and always redirect on pause (6). It provides enhanced documentation, better flow definition validation, smart defaults, and a complete custom Spring 2.0 configuration schema (7) for configuring the flow execution engine.

• (1) Render actions execute application behavior before a response is rendered.  A render action is invoked when a view-state is asked to make a renderable view selection, on entry or on a refresh triggered by a redirect or brower refresh button.  The following example shows a render-action that executes a search of the phonebook before the results view is rendered.

    <view-state id="displayResults" view="searchResults">
        <render-actions>
            <bean-action bean="phonebook" method="search">
                <method-arguments>
                    <argument expression="flowScope.searchCriteria"/>          
                </method-arguments>
                <method-result name="results"/>
            </bean-action>
        </render-actions>
        <transition on="newSearch" to="enterCriteria"/>
        <transition on="select" to="browseDetails"/>
    </view-state>

• (2) Evaluate actions evaluate expressions against flow execution state.  The expression (OGNL-based by default) can be against any object reachable from the flow execution's root RequestContext, including objects in any scope such as flow scope.  The following example shows an evaluate-action that invokes the "makeGuess" method on the "game" flow-scoped bean:

    <action-state id="makeGuess">
        <evaluate-action expression="flowScope.game.makeGuess(requestParameters.guess)">
            <evaluation-result name="guessResult"/>
        </evaluate-action>
        <transition on="CORRECT" to="showAnswer"/>
        <transition on="*" to="enterGuess"/>
        <transition on-exception="java.lang.NumberFormatException" to="enterGuess"/>
    </action-state>

• (3) Set actions set attribute values in scope types such as flow scope.  The attribute may be a top-level attribute or a property at a nested property path.  The following example shows a set-action that sets the "fileUploaded" attribute to "true" in flash scope.

    <action-state id="uploadFile">
        <action bean="uploadAction" method="uploadFile"/>
        <transition on="success" to="selectFile">
            <set attribute="fileUploaded" scope="flash" value="true"/>
        </transition>
    </action-state>

• (4) Flash scope is a new scope type for persisting attributes across a redirect and any refreshes of the view.  When an event is signaled to transition out of the view flash scope is cleared.  The following complete flow definition example shows use of flash scope to expose a "fileUploaded" attribute to the selectFile view-state for displaying a success message after a successful upload.

    <flow xmlns="http://www.springframework.org/schema/webflow"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://www.springframework.org/schema/webflow
                                           http://www.springframework.org/schema/webflow/spring-webflow-1.0.xsd">
   
        <start-state idref="selectFile"/>
       
        <view-state id="selectFile" view="fileForm">
            <transition on="submit" to="uploadFile"/>
        </view-state>
   
        <action-state id="uploadFile">
            <action bean="uploadAction" method="uploadFile"/>
            <transition on="success" to="selectFile">
                <set attribute="fileUploaded" scope="flash" value="true"/>
            </transition>
        </action-state>
       
    </flow>

• (5) Flow execution attributes allow you to set custom attributes that can influence flow execution behavior.  The following example shows an instruction to set the "alwaysRedirectOnPause" attribute to false in a Portlet environment (where redirecting doesn't tend to apply).

    <flow:executor id="flowExecutor" registry-ref="flowRegistry">
        <flow:execution-attributes>
            <flow:alwaysRedirectOnPause value="false"/>
        </flow:execution-attributes>
    </flow:executor>

• (6) "Always redirect on pauses" gives you default POST+REDIRECT+GET behavior with no special coding. Now by default, when a view state is entered a redirect is issued automatically.  This triggers a refresh to a flow execution URL that remains stable while the conversation is active.
  

• (7) The new Spring 2.0 Configuration Dialect greatly simplifies system configuration and provides strong validation and tools support.  Configuring webflow's infrastructure is now as simple as defining two elements, as shown in a complete manner below:
  

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:flow="http://www.springframework.org/schema/webflow-config"
           xsi:schemaLocation="
               http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
               http://www.springframework.org/schema/webflow-config
               http://www.springframework.org/schema/webflow-config/spring-webflow-config-1.0.xsd">
   
        <!-- Launches new flow executions and resumes existing executions. -->   
        <flow:executor id="flowExecutor" registry-ref="flowRegistry"/>
       
        <!-- Creates the registry of flow definitions for this application -->
        <flow:registry id="flowRegistry">
            <flow:location path="/WEB-INF/flows/**-flow.xml"/>
        </flow:registry>
       
    </beans>

See the reference manual for more information on these features.  Spring Web Flow 1.0 RC4 further refines the reference documentation, providing 70 pages on SWF usage.  The manual is available on-line in HTML and PDF forms.

Getting Started

One of the best ways to get started with Spring Web Flow is to review and walkthrough the sample applications.  We recommend reviewing all samples, supplementing with reference manual material as needed from the start. Ten sample applications ship with the  release, each demonstratinga distinct set of product features.  These samples are:

1. Phonebook - the original sample demonstrating most features (including subflows)
2. Sellitem - demonstrates a wizard with conditional transitions, flow execution redirects, custom text field formatting, and continuations
3. Flowlauncher - demonstrates all the possible ways to launch and resume flows
4. Itemlist - demonstrates REST-style URLs and inline flows
5. Shippingrate - demonstrates Spring Web Flow together with Ajax technology
6. NumberGuess - demonstrates stateful beans, evaluate actions, and "single key" flow execution redirects.
7. Birthdate - demonstrates Struts integration
8. Fileupload - demonstrates multipart file upload, set actions, and flash scope
9. Phonebook-Portlet - the phonebook sample in a Portlet environment (notice how the flow definitions do not change)
10. Sellitem-JSF - the sellitem sample in a JSF environment
    

To build the sample applications for quick evaluation simply:

1. Extract the spring-webflow-1.0-rc4.zip release archive
2. Access the projects/spring-webflow/build-spring-webflow directory
3. Execute the "ant dist" target.
4. See the "target/artifacts" directory for deployable .war files for each sample as well as expanded war directories.

All sample projects are Spring IDE projects directly importable into Eclipse.

Thanks to everyone out there who supported this release.  Spring Web Flow 1.0 is now... finally... just around the corner.

Enjoy!

The Spring Web Flow Team

Spring 2.0 went final on Tuesday! This is the product of 9 months of hard work from the Spring team, and huge amounts of user feedback (thanks!) and it's a big step forward.

I promise my next blog will be about something other than download numbers. I've been playing around with some interesting approaches to testing pointcuts in @AspectJ annotations, so I'm hoping next time to post some interesting code.

But we just noticed some pretty amazing figures from SourceForge, so I can't resist posting about them. There were over 10,000 downloads of Spring 2.0 in the first 24 hours! Interest in Spring 2.0 has been building for months--with some users already in production with a release candidate, including a prominent media site in Europe--and I think Keith's brilliant launch page…

One last Spring 2.0 announcement on a day full of them. The Maven POMs for Spring 2.0 are up in Spring's private repository. If you want to point to it directly check https://svn.sourceforge.net/svnroot/springframework/repos/repo/. If you want to wait, they should be replicated into the Ibiblio Maven repository over the next couple of days.

For those of you who like to browse around with a bit more metadata, the ViewVC interface from SourceForge is a good choice. Remember that you should use the earlier link as a URL for maven, but you can use the later link for browsing.

It is our pleasure to announce that the long-awaited final release of the Spring Framework version 2.0 is now available.

Download | Documentation | Changelog 

As the leading full-stack Java/Java EE application framework, Spring delivers significant benefits for many projects, reducing development effort and costs while improving test coverage and quality.

This stable, production-grade release comes after 9 months of active development.  In this short time the Spring 2.x series has matured immensely, benefiting from over 150,000 early access downloads across 9 milestone releases, resulting in over 750 JIRA issues resolved, 50 of which introduce major new features.

What's New?

We believe three attributes capture what our users can expect from the Spring 2.0 series: Simple, Powerful, and Proven.

Version 2.0 brings major new simplifications to the framework's overall usage model.  As our existing users know, the heart of Spring is the Bean Container which drives the configuration of your Java and Java EE application.  In version 2.0 many common configuration tasks have been simplified through the introduction of custom Bean Configuration Dialects.  What does this mean to you?

This means you can now:

• Make your business services transactional in one-line of configuration code.
  
• Lookup objects from JNDI in one-line of configuration code.
  
• Expose externalized properties to your services in one line of configuration code.
  
• Apply consistent exception handling policies to your data access objects with a single annotation.
  
• Invoke Stateless Remote EJBs by defining a single configuration tag.  No more custom service locators or business delegates.
  

• Write parameterized JDBC queries in one line of code.
  
• Apply convention over configuration when deploying your Spring MVC controllers.
  
• Use Spring JSP tags to reduce your typing when developing input forms.
  

A major goal of Spring 2.0 is to make the common tasks easier.  Version 2.0 also opens up exciting new doors for solving the harder problems in an elegant manner.  In 2.0 you may:

• Weave custom behavior into multiple points of program execution using AspectJ's concise pointcut expression language.
  
• Receive asynchronous JMS messages with transactional and thread-safety guarantees.  See it live
• Develop your own Bean Configuration Dialect for your application.
  
• Inject objects from custom scopes such as "request" and "session" scope in a thread-safe manner.
  
• Invoke Groovy, Beanshell, and JRuby scripts from your Java application.
  
• Schedule tasks to run asynchronously with sophisticated threading and pooling options.
  

Version 2.0 builds on the foundation set by Spring 1.x.  This new release delivers major new functionality while preserving backwards compatability as far as possible.

With over one million downloads since its release in March 2004, Spring 1.x made developing sophisticated applications from plain Java Objects (POJOs) the de-facto standard.  The 2.x series builds on this widely-recognized best-practice to deliver new simplification and power while preserving full compatiblity with the established Spring 1.x series.  Users can expect their upgrade to be straightforward; in most cases, simply a matter of replacing the 1.2.8 JAR files with those included in Spring 2.0.

Enjoy, and thank you

Spring 2.0 represents the cumulative effort of many over the last year.  From the lead developers Juergen, Rob, Rick, and Costin at Interface21, to our supporting partners BEA and Oracle, to the many in the community contributing innovations, patches, documentation, bug reports, and tests--there is a lot of blood, sweat, and tears here.  We truly hope you find this new version as much a joy to use as it was for us to build.  Enjoy, and rest assured: the work doesn't stop here.

Sincerely,

The Spring Team

Additional Resources

• Watch Juergen and Rob's interview with InfoQ on the goals of Spring 2.0.

• Attend The Spring Experience 2006, the premier conference for the Spring community, December 7th - 10th in Hollywood, Florida.  Register by October 16th to secure the early bird discount for your team.

• Get started with Spring 2.0 by downloading the release and reviewing the JPetStore and Petclinic sample applications, supplementing with the reference manual and API JavaDocs as needed.

• Get community support at forum.springframework.org.

• Read content leading up to the release including the Spring 2.0 update and Adrian's Simplifying Enterprise Applications.
  

• Track future Spring 2.x development with the Roadmap

• Get insights from the leads of Spring development at the Interface21 team blog.

• Interface21 is offering upcoming and newly updated Spring 2.0 training courses in 2006 and 2007.

• Spring 2.0 will be available in the Maven2 repository in the coming days.
  

• The release of Spring Web Flow 1.0 final will follow next week.

• Bookmark this page for the rollout of additional screencasts and code examples showing the new 2.0 features in action.
  

It is a common misconception that I hear when talking with clients that all information about generic types is erased from your Java class files. This is entirely untrue. All static generic information is maintained, and only generic information about individual instances is erased. So if I have a class Foo that implements List<String>, then I can determine that Foo implements the List interface parameterised by String at runtime. However, if I instantiate an instance of ArrayList<String> at runtime, I cannot take that instance and determine its concrete type parameter (I can determine that ArrayList requires type parameters). In this entry I’m going to show you a practical usage for some of the available generics metadata that simplifies the creation of strategy interfaces and implementations that differ by the type of object they process.

A pattern that I see occurring in many applications is the use of some kind of strategy interface with concrete implementations each of which handles a particular input type. For example, consider a simple scenario from the investment banking world. Any publicly traded company can issue Corporate Actions that bring about an actual change to their stock. A key example of this is a dividend payment which pays out a certain amount of cash, stock or property per shared to all shareholders. Within an investment bank, receiving notification of these events and calculating the resultant entitlements is very important in order to keep trading books up to date with the correct stock and cash values.

As a concrete example of this, consider BigBank which holds 1,200,000 IBM stock. IBM decides to issue a dividend paying $0.02 per share. As a result, BigBank needs to receive notification of the dividend action and, at the appropriate point in time, update their trading books to reflect the additional $24,000 of cash available.

The calculation of entitlement will differ greatly depending on which type of Corporate Action is being performed. For example, a merger will most likely result in the loss of stock in one company and the gain of stock in another.

If we think about how this might look in a Java application we could assume to see something like this (heavily simplified) example:

public class CorporateActionEventProcessor {

    public void onCorporateActionEvent(CorporateActionEvent event) {
        // do we have any stock for this security?

        // if so calculate our entitlements
    }
}

Notifications about events probably come in via a number of mechanisms from external parties and then get sent to this CorporateActionEventProcessor class. The CorporateActionEvent interface might be realised via a number of concrete classes:

public class DividendCorporateActionEvent implements CorporateActionEvent {

    private PayoutType payoutType;
    private BigDecimal ratioPerShare;

    // ...
}

public class MergerCorporateActionEvent implements CorporateActionEvent {

    private String currentIsin; // security we currently hold
    private String newIsin; // security we get
    private BigDecimal…