The Spring Framework was first released in 2004; since then there have been significant
major revisions: Spring 2.0 provided XML namespaces and AspectJ support; Spring 2.5
embraced annotation-driven configuration; Spring 3.0 introduced a strong Java 5+ foundation
across the framework codebase, and features such as the Java-based
@Configuration model.
Version 4.0 is the latest major release of the Spring Framework and the first to fully
support Java 8 features. You can still use Spring with older versions of Java, however,
the minimum requirement has now been raised to Java SE 6. We have also taken the
opportunity of a major release to remove many deprecated classes and methods.
A
migration guide for upgrading to Spring 4.0
is available on the
Spring Framework GitHub Wiki.
1 Improved Getting Started Experience
The new
spring.io website provides a whole series of
"Getting Started" guides to help you learn Spring. You
can read more about the guides in the
Chapter 1, Getting Started with Spring section
in this document. The new website also provides a comprehensive overview of the many
additional projects that are released under the Spring umbrella.
If you are a Maven user you may also be interested in the helpful
bill of materials POM file that is now published with each Spring
Framework release.
2 Removed Deprecated Packages and Methods
All deprecated packages, and many deprecated classes and methods have been removed with
version 4.0. If you are upgrading from a previous release of Spring, you should ensure
that you have fixed any deprecated calls that you were making to outdated APIs.
For a complete set of changes, check out the
API
Differences Report.
Note that optional third-party dependencies have been raised to a 2010/2011 minimum
(i.e. Spring 4 generally only supports versions released in late 2010 or later now):
notably, Hibernate 3.6+, EhCache 2.1+, Quartz 1.8+, Groovy 1.8+, and Joda-Time 2.0+.
As an exception to the rule, Spring 4 requires the recent Hibernate Validator 4.3+,
and support for Jackson has been focused on 2.0+ now (with Jackson 1.8/1.9 support
retained for the time being where Spring 3.2 had it; now just in deprecated form).
3 Java 8 (as well as 6 and 7)
Spring Framework 4.0 provides support for several Java 8 features. You can make use of
lambda expressions and
method references with Spring’s callback interfaces. There
is first-class support for
java.time (
JSR-310),
and several existing annotations have been retrofitted as
@Repeatable. You can also
use Java 8’s parameter name discovery (based on the
-parameters compiler flag) as an
alternative to compiling your code with debug information enabled.
Spring remains compatible with older versions of Java and the JDK: concretely, Java SE 6
(specifically, a minimum level equivalent to JDK 6 update 18, as released in January 2010)
and above are still fully supported. However, for newly started development projects
based on Spring 4, we recommend the use of Java 7 or 8.
Java EE version 6 or above is now considered the baseline for Spring Framework 4, with
the JPA 2.0 and Servlet 3.0 specifications being of particular relevance. In order to
remain compatible with Google App Engine and older application servers, it is possible
to deploy a Spring 4 application into a Servlet 2.5 environment. However, Servlet 3.0+
is strongly recommended and a prerequisite in Spring’s test and mock packages for test
setups in development environments.
![[Note]](https://docs.spring.io/spring/docs/current/spring-framework-reference/html/images/note.png) |
| If you are a WebSphere 7 user, be sure to install the JPA 2.0 feature pack. On
WebLogic 10.3.4 or higher, install the JPA 2.0 patch that comes with it. This turns
both of those server generations into Spring 4 compatible deployment environments. |
On a more forward-looking note, Spring Framework 4.0 supports the Java EE 7 level of
applicable specifications now: in particular, JMS 2.0, JTA 1.2, JPA 2.1, Bean Validation
1.1, and JSR-236 Concurrency Utilities. As usual, this support focuses on individual
use of those specifications, e.g. on Tomcat or in standalone environments. However,
it works equally well when a Spring application is deployed to a Java EE 7 server.
Note that Hibernate 4.3 is a JPA 2.1 provider and therefore only supported as of
Spring Framework 4.0. The same applies to Hibernate Validator 5.0 as a Bean Validation
1.1 provider. Neither of the two are officially supported with Spring Framework 3.2.
5 Groovy Bean Definition DSL
Beginning with Spring Framework 4.0, it is possible to define external bean configuration
using a Groovy DSL. This is similar in concept to using XML bean definitions but allows
for a more concise syntax. Using Groovy also allows you to easily embed bean definitions
directly in your bootstrap code. For example:
def reader = new GroovyBeanDefinitionReader(myApplicationContext)
reader.beans {
dataSource(BasicDataSource) {
driverClassName = "org.hsqldb.jdbcDriver"
url = "jdbc:hsqldb:mem:grailsDB"
username = "sa"
password = ""
settings = [mynew:"setting"]
}
sessionFactory(SessionFactory) {
dataSource = dataSource
}
myService(MyService) {
nestedBean = { AnotherBean bean ->
dataSource = dataSource
}
}
}
For more information consult the
GroovyBeanDefinitionReader
javadocs.
6 Core Container Improvements
There have been several general improvements to the core container:
-
Spring now treats generic types as a form of
qualifier when injecting Beans. For example, if you are using a Spring Data
Repository you can now easily inject a specific implementation:
@Autowired Repository<Customer> customerRepository.
-
If you use Spring’s meta-annotation support, you can now develop custom annotations that
expose specific attributes from the source annotation.
-
Beans can now be ordered when they are autowired into
lists and arrays. Both the
@Order annotation and Ordered interface are
supported.
-
The
@Lazy annotation can now be used on injection points, as well as on @Bean
definitions.
-
The
@Description annotation has been introduced for
developers using Java-based configuration.
-
A generalized model for conditionally filtering beans has
been added via the
@Conditional annotation. This is similar to @Profile support but
allows for user-defined strategies to be developed programmatically.
-
CGLIB-based proxy classes no longer require a default
constructor. Support is provided via the objenesis
library which is repackaged inline and distributed as part of the Spring Framework.
With this strategy, no constructor at all is being invoked for proxy instances anymore.
-
There is managed time zone support across the framework now, e.g. on
LocaleContext.
7 General Web Improvements
Deployment to Servlet 2.5 servers remains an option, but Spring Framework 4.0 is now
focused primarily on Servlet 3.0+ environments. If you are using the
Spring MVC Test Framework you
will need to ensure that a Servlet 3.0 compatible JAR is in your
test classpath.
In addition to the WebSocket support mentioned later, the following general improvements
have been made to Spring’s Web modules:
8 WebSocket, SockJS, and STOMP Messaging
A new
spring-websocket module provides comprehensive support for WebSocket-based,
two-way communication between client and server in web applications. It is compatible with
JSR-356, the Java WebSocket API, and in addition
provides SockJS-based fallback options (i.e. WebSocket emulation) for use in browsers
that don’t yet support the WebSocket protocol (e.g. Internet Explorer < 10).
A new
spring-messaging module adds support for STOMP as the WebSocket sub-protocol
to use in applications along with an annotation programming model for routing and
processing STOMP messages from WebSocket clients. As a result an
@Controller
can now contain both
@RequestMapping and
@MessageMapping methods for handling
HTTP requests and messages from WebSocket-connected clients. The new
spring-messaging
module also contains key abstractions formerly from the
Spring Integration project such as
Message,
MessageChannel,
MessageHandler, and others to serve as a foundation
for messaging-based applications.
For further details, including a more thorough introduction, see the
Chapter 26, WebSocket Support section.
In addition to pruning of deprecated code within the
spring-test module, Spring
Framework 4.0 introduces several new features for use in unit and integration testing.
-
Almost all annotations in the
spring-test module (e.g., @ContextConfiguration,
@WebAppConfiguration, @ContextHierarchy, @ActiveProfiles, etc.) can now be used
as meta-annotations to create custom
composed annotations and reduce configuration duplication across a test suite.
-
Active bean definition profiles can now be resolved programmatically, simply by
implementing a custom
ActiveProfilesResolver
and registering it via the resolver attribute of @ActiveProfiles.
-
A new
SocketUtils class has been introduced in the spring-core module
which enables you to scan for free TCP and UDP server ports on localhost. This
functionality is not specific to testing but can prove very useful when writing
integration tests that require the use of sockets, for example tests that start
an in-memory SMTP server, FTP server, Servlet container, etc.
-
As of Spring 4.0, the set of mocks in the
org.springframework.mock.web package is
now based on the Servlet 3.0 API. Furthermore, several of the Servlet API mocks
(e.g., MockHttpServletRequest, MockServletContext, etc.) have been updated with
minor enhancements and improved configurability.
- Removed Deprecated Packages and Methods
- Java 8 Support
- Java EE 6 and 7 become the baseline
- Groovy Bean Definition DSL
- Core Container Improvements
- General Web Improvements
- WebSocket, SockJS, and STOMP Messaging
- Testing Improvements with extreme use of annotations
Take also a look to
Spring MVC Test Tutorial by Petri Kainulainen that can give you a lot of informations about testing.
