If you have been using the Spring Framework for some time, you will be aware that Spring has undergone two major revisions: Spring 2.0, released in October 2006, and Spring 2.5, released in November 2007. It is now time for a third overhaul resulting in Spring 3.0. The Spring Framework is now based on Java 5 and Java 6 is fully supported. Furthermore, Spring is compatible with J2EE 1.4 and Java EE 5, while at the same time introducing some early support for Java EE 6.

The entire framework code has been revised to take advantage of Java 5 features like generics, varargs and other language improvements. We have done our best to still keep the code backwards compatible. We now have consistent use of generic Collections and Maps, consistent use of generified FactoryBeans, and also consistent resolution of bridge methods in the Spring AOP API. Generified ApplicationListeners automatically receive specific event types only. All callback interfaces such as TransactionCallback and HibernateCallback declare a generic result value now. Overall, the Spring core codebase is now freshly revised and optimized for Java 5. Spring's TaskExecutor abstraction has been updated for close integration with Java 5's java.util.concurrent facilities. We provide first-class support for Callables and Futures now, as well as ExecutorService adapters, ThreadFactory integration, etc. This has been aligned with JSR-236 (Concurrency Utilities for Java EE 6) as far as possible. Furthermore, we provide support for asynchronous method invocations through the use of the new @Async annotation (or EJB 3.1's @Asynchronous annotation).

The current documentation is a *** WORK IN PROGRESS *** and is currently being re-written to reflect all the changes in the framework and from now relying on Java 5 features. The Spring reference documentation has also substantially been updated to reflect all of the changes and new features for Spring 3.0. While every effort has been made to ensure that there are no errors in this documentation, some errors may nevertheless have crept in. If you do spot any typos or even more serious errors, and you can spare a few cycles during lunch, please do bring the error to the attention of the Spring team by raising an issue.

The framework modules have been revised and are now managed separately with one source-tree per module jar: org.springframework.aop org.springframework.beans org.springframework.context org.springframework.context.support org.springframework.expression org.springframework.instrument org.springframework.jdbc org.springframework.jms org.springframework.orm org.springframework.oxm org.springframework.test org.springframework.transaction org.springframework.web org.springframework.web.portlet org.springframework.web.servlet The spring.jar artifact that contained almost the entire framework is no longer provided. We are now using a new Spring build system as known from Spring Web Flow 2.0. This gives us: Ivy-based "Spring Build" system consistent deployment procedure consistent dependency management consistent generation of OSGi manifests

This is a list of new features for Spring 3.0. We will cover these features in more detail later in this section. Spring Expression Language IoC enhancements/Java based bean metadata Comprehensive REST support @MVC additions Declarative model validation Early support for Java EE 6

BeanFactoryinterface returns typed bean instancesas far as possible T getBean(Stringname, Class<T> requiredType) Map<String, T> getBeansOfType(Class<T> type) Spring's TaskExecutorinterface extends java.util.concurrent.Executor now extended AsyncTaskExecutor supports standard Callables with Futures New Java 5 based converter API and SPI stateless ConversionService and Converters superseding standard JDK PropertyEditors Typed ApplicationListener<E>

Spring introduces an expression language which is similar to Unified EL in its syntax but offers significantly more features. The expression language can be used when defining XML and Annotation based bean definitions and also serves as the foundation for expression language support across the Spring portfolio. Details of this new functionality can be found in the chapter Spring Expression Language (SpEL). The Spring Expression Language was created to provide the Spring community with a single well supported expression language that can used across all the products in the Spring portfolio. Its language features are driven by the requirements of the projects in the Spring portfolio, including tooling requirements for code completion support within the eclipse based SpringSource Tool Suite. The following is an example of how the Expression Language can be used to configure some properties of a database setup <bean class="mycompany.RewardsTestDatabase"> <property name="databaseName" value="#{systemProperties.databaseName}"/> <property name="keyGenerator" value="#{strategyBean.databaseKeyGenerator}"/> </bean> This functionality is also available if you prefer to configure your components using annotations: @Repository public class RewardsTestDatabase { @Value("#{systemProperties.databaseName}") public void setDatabaseName(String dbName) { … } @Value("#{strategyBean.databaseKeyGenerator}") public voidsetKeyGenerator(KeyGenerator kg) { … } }

Some core features from the JavaConfig project have been added to the Spring Framework now. This means that the following annotations are now directly supported: @Configuration @Bean @Primary @Lazy @Import @Value Here is an example of a Java class providing basic configuration using the new JavaConfig features: @Configuration public class AppConfig{ @Value("#{jdbcProperties.url}") String jdbcUrl; @Value("#{jdbcProperties.username}") String username; @Value("#{jdbcProperties.password}") String password; @Bean public FooServicefooService() { return new FooServiceImpl(fooRepository()); } @Bean public FooRepositoryfooRepository() { return new HibernateFooRepository(sessionFactory()); } @Bean public SessionFactorysessionFactory() { // wire up a session factory using // AnnotationSessionFactoryBean asFactoryBean.setDataSource(dataSource()); return (SessionFactory) asFactoryBean.getObject(); } @Bean public DataSourcedataSource() { return new DriverManagerDataSource(jdbcUrl, username, password); } } To get this to work you need to add the following component scanning entry in your minimal application context XML file. <context:component-scan base-package="com.myco.config"/>

FactoryBeans can be defined within a Spring component definition and registered using standard component-scanning techniques. See Factory Bean Definitions using annotations for more information

Work in progress ...

Server-side support for building RESTful applications has been provided as an extension of the existing annotation driven MVC web framework. Client-side support is provided by the RestTemplate class in the spirit of other template classes such as JdbcTemplate and JmsTemplate. Both server and client side REST functionality make use of HttpConverters to facilitate the conversion between objects and their representation in HTTP request and replies. The MarhsallingHttpMessageConverter uses the Object to XML mapping functionality in the org.springframework.oxm package. This functionality had previously been part of Spring Web Services. More information on the use of the org.springframework.oxm can be found in the Marshalling XML using O/X Mappers chapter. Refer to the section on REST support for more information.

Additional annotations such as @CookieValue and @RequestHeaders have been added. See Mapping cookie values with the @CookieValue annotation and Mapping request header attributes with the @RequestHeader annotation for more information. Work in progress ...

Hibernate Validator, JSR 303 Work in progress...

JSF 2.0, JPA 2.0, etc Work in progress...