[[spring-whats-new]] = What's New in Spring Framework 4.x [[new-in-4.0]] == New Features and Enhancements in Spring Framework 4.0 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 https://github.com/spring-projects/spring-framework/wiki/Migrating-from-earlier-versions-of-the-spring-framework[migration guide for upgrading to Spring 4.0] is available on the https://github.com/spring-projects/spring-framework/wiki[Spring Framework GitHub Wiki]. === Improved Getting Started Experience The new https://spring.io[spring.io] website provides a whole series of https://spring.io/guides["Getting Started"] guides to help you learn Spring. You can read more about the guides in the <> 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 <> POM file that is now published with each Spring Framework release. === 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 http://docs.spring.io/spring-framework/docs/3.2.4.RELEASE_to_4.0.0.RELEASE/[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). === 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` (http://jcp.org/en/jsr/detail?id=310[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 6 and 7 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] ==== 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. [[groovy-bean-definition-dsl]] === 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: [source,groovy,indent=0] [subs="verbatim,quotes"] ---- 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` {javadoc-baseurl}/org/springframework/beans/factory/groovy/GroovyBeanDefinitionReader.html[javadocs]. === Core Container Improvements There have been several general improvements to the core container: * Spring now treats <> when injecting Beans. For example, if you are using a Spring Data `Repository` you can now easily inject a specific implementation: `@Autowired Repository customerRepository`. * If you use Spring's meta-annotation support, you can now develop custom annotations that <>. * Beans can now be __ordered__ when they are <>. 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 <> for developers using Java-based configuration. * A generalized model for <> has been added via the `@Conditional` annotation. This is similar to `@Profile` support but allows for user-defined strategies to be developed programmatically. * <> no longer require a default constructor. Support is provided via the http://code.google.com/p/objenesis/[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`. === 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 <> 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: * You can use the <> with Spring MVC applications, removing the need to add `@ResponseBody` to each of your `@RequestMapping` methods. * The `AsyncRestTemplate` class has been added, <> when developing REST clients. * Spring now offers <> when developing Spring MVC applications. === 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 http://jcp.org/en/jsr/detail?id=356[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 http://projects.spring.io/spring-integration/[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 <> section. === Testing Improvements 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 <> 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 <> 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. [[new-in-4.1]] == New Features and Enhancements in Spring Framework 4.1 === JMS Improvements Spring 4.1 introduces a much simpler infrastructure <> by annotating bean methods with {javadoc-baseurl}/org/springframework/jms/annotation/JmsListener.html[`@JmsListener`]. The XML namespace has been enhanced to support this new style (`jms:annotation-driven`), and it is also possible to fully configure the infrastructure using Java config ({javadoc-baseurl}/org/springframework/jms/annotation/EnableJms.html[`@EnableJms`], `JmsListenerContainerFactory`). It is also possible to register listener endpoints programmatically using {javadoc-baseurl}/org/springframework/jms/annotation/JmsListenerConfigurer.html[`JmsListenerConfigurer`]. Spring 4.1 also aligns its JMS support to allow you to benefit from the `spring-messaging` abstraction introduced in 4.0, that is: * Message listener endpoints can have a more flexible signature and benefit from standard messaging annotations such as `@Payload`, `@Header`, `@Headers`, and `@SendTo`. It is also possible to use a standard `Message` in lieu of `javax.jms.Message` as method argument. * A new {javadoc-baseurl}/org/springframework/jms/core/JmsMessageOperations.html[`JmsMessageOperations`] interface is available and permits `JmsTemplate` like operations using the `Message` abstraction. Finally, Spring 4.1 provides additional miscellaneous improvements: * Synchronous request-reply operations support in `JmsTemplate` * Listener priority can be specified per `` element * Recovery options for the message listener container are configurable using a {javadoc-baseurl}/org/springframework/util/backoff/BackOff.html[`BackOff`] implementation * JMS 2.0 shared consumers are supported === Caching Improvements Spring 4.1 supports <> using Spring's existing cache configuration and infrastructure abstraction; no changes are required to use the standard annotations. Spring 4.1 also improves its own caching abstraction significantly: * Caches can be resolved at runtime using a <>. As a result the `value` argument defining the cache name(s) to use is no longer mandatory. * More operation-level customizations: cache resolver, cache manager, key generator * A new <> allows common settings to be shared at the class level **without** enabling any cache operation. * Better exception handling of cached methods using `CacheErrorHandler` Spring 4.1 also has a breaking change in the `CacheInterface` as a new `putIfAbsent` method has been added. === Web Improvements * The existing support for resource handling based on the `ResourceHttpRequestHandler` has been expanded with new abstractions `ResourceResolver`, `ResourceTransformer`, and `ResourceUrlProvider`. A number of built-in implementations provide support for versioned resource URLs (for effective HTTP caching), locating gzipped resources, generating an HTML 5 AppCache manifests, and more. See <>. * JDK 1.8's `java.util.Optional` is now supported for `@RequestParam`, `@RequestHeader`, and `@MatrixVariable` controller method arguments. * `ListenableFuture` is supported as a return value alternative to `DeferredResult` where an underlying service (or perhaps a call to `AsyncRestTemplate`) already returns `ListenableFuture`. * `@ModelAttribute` methods are now invoked in an order that respects inter-dependencies. See https://jira.spring.io/browse/SPR-6299[SPR-6299]. * Jackson's `@JsonView` is supported directly on `@ResponseBody` and `ResponseEntity` controller methods for serializing different amounts of detail for the same POJO (e.g. summary vs. detail page). This is also supported with View-based rendering by adding the serialization view type as a model attribute under a special key. See <> for details. * JSONP is now supported with Jackson. See <>. * A new lifecycle option is available for intercepting `@ResponseBody` and `ResponseEntity` methods just after the controller method returns and before the response is written. To take advantage declare an `@ControllerAdvice` bean that implements `ResponseBodyAdvice`. The built-in support for `@JsonView` and JSONP take advantage of this. See <>. * There are three new `HttpMessageConverter` options: ** Gson -- lighter footprint than Jackson; has already been in use in Spring Android. ** Google Protocol Buffers -- efficient and effective as an inter-service communication data protocol within an enterprise but can also be exposed as JSON and XML for browsers. ** Jackson based XML serialization is now supported through the https://github.com/FasterXML/jackson-dataformat-xml[jackson-dataformat-xml] extension. When using `@EnableWebMvc` or ``, this is used by default instead of JAXB2 if `jackson-dataformat-xml` is in the classpath. * Views such as JSPs can now build links to controllers by referring to controller mappings by name. A default name is assigned to every `@RequestMapping`. For example `FooController` with method `handleFoo` is named "FC#handleFoo". The naming strategy is pluggable. It is also possible to name an `@RequestMapping` explicitly through its name attribute. A new `mvcUrl` function in the Spring JSP tag library makes this easy to use in JSP pages. See <>. * `ResponseEntity` provides a builder-style API to guide controller methods towards the preparation of server-side responses, e.g. `ResponseEntity.ok()`. * `RequestEntity` is a new type that provides a builder-style API to guide client-side REST code towards the preparation of HTTP requests. * MVC Java config and XML namespace: ** View resolvers can now be configured including support for content negotiation, see <>. ** View controllers now have built-in support for redirects and for setting the response status. An application can use this to configure redirect URLs, render 404 responses with a view, send "no content" responses, etc. Some use cases are https://jira.spring.io/browse/SPR-11543?focusedCommentId=100308&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-100308[listed here]. ** Path matching customizations are frequently used and now built-in. See <>. * http://groovy-lang.org/docs/groovy-2.3.6/html/documentation/markup-template-engine.html[Groovy markup template] support (based on Groovy 2.3). See the `GroovyMarkupConfigurer` and respecitve `ViewResolver` and `View' implementations. === WebSocket Messaging Improvements * SockJS (Java) client-side support. See `SockJsClient` and classes in same package. * New application context events `SessionSubscribeEvent` and `SessionUnsubscribeEvent` published when STOMP clients subscribe and unsubscribe. * New "websocket" scope. See <>. * `@SendToUser` can target only a single session and does not require an authenticated user. * `@MessageMapping` methods can use dot "." instead of slash "/" as path separator. See https://jira.spring.io/browse/SPR-11660[SPR-11660]. * STOMP/WebSocket monitoring info collected and logged. See <>. * Significantly optimized and improved logging that should remain very readable and compact even at DEBUG level. * Optimized message creation including support for temporary message mutability and avoiding automatic message id and timestamp creation. See Javadoc of `MessageHeaderAccessor`. * Close STOMP/WebSocket connections that have no activity within 60 seconds after the WebSocket session is established. See https://jira.spring.io/browse/SPR-11884[SPR-11884]. === Testing Improvements * Groovy scripts can now be used to configure the `ApplicationContext` loaded for integration tests in the TestContext framework. ** See <> for details. * Test-managed transactions can now be programmatically started and ended within transactional test methods via the new `TestTransaction` API. ** See <> for details. * SQL script execution can now be configured declaratively via the new `@Sql` and `@SqlConfig` annotations on a per-class or per-method basis. ** See <> for details. * Test property sources which automatically override system and application property sources can be configured via the new `@TestPropertySource` annotation. ** See <> for details. * Default ++TestExecutionListener++s can now be automatically discovered. ** See <> for details. * Custom ++TestExecutionListener++s can now be automatically merged with the default listeners. ** See <> for details. * The documentation for transactional testing support in the TestContext framework has been improved with more thorough explanations and additional examples. ** See <> for details. * Various improvements to `MockServletContext`, `MockHttpServletRequest`, and other Servlet API mocks. * `AssertThrows` has been refactored to support `Throwable` instead of `Exception`. * In Spring MVC Test, JSON responses can be asserted with https://github.com/skyscreamer/JSONassert[JSON Assert] as an extra option to using JSONPath much like it has been possible to do for XML with XMLUnit. * `MockMvcBuilder` _recipes_ can now be created with the help of `MockMvcConfigurer`. This was added to make it easy to apply Spring Security setup but can be used to encapsulate common setup for any 3rd party framework or within a project. * `MockRestServiceServer` now supports the `AsyncRestTemplate` for client-side testing. [[new-in-4.2]] == New Features and Enhancements in Spring Framework 4.2 === Core Container Improvements * Annotations such as `@Bean` get detected and processed on Java 8 default methods as well, allowing for composing a configuration class from interfaces with default `@Bean` methods. * Configuration classes may declare `@Import` with regular component classes now, allowing for a mix of imported configuration classes and component classes. * Configuration classes may declare an `@Order` value, getting processed in a corresponding order (e.g. for overriding beans by name) even when detected through classpath scanning. * `@Resource` injection points support an `@Lazy` declaration, analogous to `@Autowired`, receiving a lazy-initializing proxy for the requested target bean. * The application event infrastructure now offers an <> as well as the ability to publish any arbitrary event. ** Any public method in a managed bean can be annotated with `@EventListener` to consume events. ** `@TransactionalEventListener` provides transaction-bound event support. * Spring Framework 4.2 introduces first-class support for declaring and looking up aliases for annotation attributes. The new `@AliasFor` annotation can be used to declare a pair of aliased attributes within a single annotation or to declare an alias from one attribute in a custom composed annotation to an attribute in a meta-annotation. ** The following annotations have been retrofitted with `@AliasFor` support in order to provide meaningful aliases for their `value` attributes: `@Cacheable`, `@CacheEvict`, `@CachePut`, `@ComponentScan`, `@ComponentScan.Filter`, `@ImportResource`, `@Scope`, `@ManagedResource`, `@Header`, `@Payload`, `@SendToUser`, `@ActiveProfiles`, `@ContextConfiguration`, `@Sql`, `@TestExecutionListeners`, `@TestPropertySource`, `@Transactional`, `@ControllerAdvice`, `@CookieValue`, `@CrossOrigin`, `@MatrixVariable`, `@RequestHeader`, `@RequestMapping`, `@RequestParam`, `@RequestPart`, `@ResponseStatus`, `@SessionAttributes`, `@ActionMapping`, `@RenderMapping`. ** For example, `@ContextConfiguration` from the `spring-test` module is now declared as follows: [source,java,indent=0] [subs="verbatim,quotes"] ---- public @interface ContextConfiguration { @AliasFor(attribute = "locations") String[] value() default {}; @AliasFor(attribute = "value") String[] locations() default {}; // ... } ---- ** Similarly, _composed annotations_ that override attributes from meta-annotations can now use `@AliasFor` for fine-grained control over exactly which attributes are overridden within an annotation hierarchy. In fact, it is now possible to declare an alias for the `value` attribute of a meta-annotation. ** For example, one can now develop a composed annotation with a custom attribute override as follows. [source,java,indent=0] [subs="verbatim,quotes"] ---- @ContextConfiguration public @interface MyTestConfig { @AliasFor(annotation = ContextConfiguration.class, attribute = "value") String[] xmlFiles(); // ... } ---- * Numerous improvements to Spring's search algorithms used for finding meta-annotations. For example, locally declared _composed annotations_ are now favored over inherited annotations. * _Composed annotations_ that override attributes from meta-annotations can now be discovered on interfaces and on abstract, bridge, & interface methods as well as on classes, standard methods, constructors, and fields. * Maps representing annotation attributes (and `AnnotationAttributes` instances) can be _synthesized_ (i.e., converted) into an annotation. * The features of field-based data binding (`DirectFieldAccessor`) have been aligned with the current property-based data binding (`BeanWrapper`). In particular, field-based binding now supports navigation for Collections, Arrays, and Maps. * `DefaultConversionService` now provides out-of-the-box converters for `Stream`, `Charset`, `Currency`, and `TimeZone`. Such converters can be added individually to any arbitrary `ConversionService` as well. * `DefaultFormattingConversionService` comes with out-of-the-box support for the value types in JSR-354 Money & Currency (if the 'javax.money' API is present on the classpath): namely, `MonetaryAmount` and `CurrencyUnit`. This includes support for applying `@NumberFormat`. * `@NumberFormat` can now be used as a meta-annotation. * `JavaMailSenderImpl` has a new `testConnection()` method for checking connectivity to the server. * `ScheduledTaskRegistrar` exposes scheduled tasks. * Apache `commons-pool2` is now supported. === Data Access Improvements * `javax.transaction.Transactional` is now supported via AspectJ. * `SimpleJdbcCallOperations` now supports named binding. * Full support for Hibernate ORM 5.0: as a JPA provider (automatically adapted) as well as through its native API (covered by the new `org.springframework.orm.hibernate5` package). * Embedded databases can now be automatically assigned unique names, and `` supports a new `database-name` attribute. See "Testing Improvements" below for further details. === JMS Improvements * The `autoStartup` attribute can be controlled via `JmsListenerContainerFactory`. * The type of the reply `Destination` can now be configured per listener container. * The value of the `@SendTo` annotation can now use a SpEL expression. * The response destination can be <> * `@JmsListener` is now a repeatable annotation to declare several JMS containers on the same method (use the newly introduced `@JmsListeners` if you're not using Java8 yet). === Web Improvements * HTTP Streaming and Server-Sent Events support, see <>. * Built-in support for CORS including global (MVC Java config and XML namespace) and local (e.g. `@CrossOrigin`) configuration. See <> for details. * HTTP caching updates: ** new `CacheControl` builder; plug into `WebContentGenerator`, `ResourceHttpRequestHandler`, `ResponseEntity`. ** improved ETag/Last-Modified support in `WebRequest`. * JavaScript view templating built on Nashorn and JDK 1.8, see `ScriptTemplateViewResolver`. * Custom `@RequestMapping` annotations. * Public methods in `AbstractHandlerMethodMapping` to register and unregister request mappings at runtime. * New `RequestBodyAdvice` extension point and a built-in implementation to support Jackson's `@JsonView` on `@RequestBody` method arguments. * `HandlerMethod` as a method argument on `@ExceptionHandler` methods, especially handy in `@ControllerAdvice` components. * `java.util.concurrent.CompletableFuture` as an `@Controller` method return value type. * Byte-range request support in `HttpHeaders` and for serving static resources. * `@ResponseStatus` detected on nested exceptions. * `UriTemplateHandler` extension point in the `RestTemplate`. ** `DefaultUriTemplateHandler` exposes `baseUrl` property and path segment encoding options. ** the extension point can also be used to plug in any URI template library. * http://square.github.io/okhttp/[OkHTTP] integration with the `RestTemplate`. * Custom `baseUrl` alternative for methods in `MvcUriComponentsBuilder`. * Serialization/deserialization exception messages are now logged at WARN level. * When using GSON or Jackson 2.6+, the handler method return type is used to improve serialization of parameterized types like `List`. * Default JSON prefix has been changed from "{} && " to the safer ")]}', " one. * Protected `createDispatcherServlet` method in `AbstractDispatcherServletInitializer` to further customize the `DispatcherServlet` instance to use. === WebSocket Messaging Improvements * Expose presence information about connected users and subscriptions: ** new `SimpUserRegistry` exposed as a bean named "userRegistry". ** sharing of presence information across cluster of servers (see broker relay config options). * Resolve user destinations across cluster of servers (see broker relay config options). * `StompSubProtocolErrorHandler` extension point to customize and control STOMP ERROR frames to clients. * Global `@MessageExceptionHandler` methods via `@ControllerAdvice` components. * Heart-beats and a SpEL expression 'selector' header for subscriptions with `SimpleBrokerMessageHandler`. * STOMP client for use over TCP and WebSocket; see <>. * `@SendTo` and `@SendToUser` can contain destination variable placeholders. * Jackson's `@JsonView` supported for return values on `@MessageMapping` and `@SubscribeMapping` methods. * `ListenableFuture` and `CompletableFuture` as return value types from `@MessageMapping` and `@SubscribeMapping` methods. * `MarshallingMessageConverter` for XML payloads. === Testing Improvements * JUnit-based integration tests can now be executed with JUnit rules instead of the `SpringJUnit4ClassRunner`. This allows Spring-based integration tests to be run with alternative runners like JUnit's `Parameterized` or third-party runners such as the `MockitoJUnitRunner`. ** Spring JUnit rule configuration requires the following two rules. [source,java,indent=0] [subs="verbatim,quotes"] ---- @ClassRule public static final SpringClassRule SPRING_CLASS_RULE = new SpringClassRule(); @Rule public final SpringMethodRule springMethodRule = new SpringMethodRule(); ---- * `AopTestUtils` is a new testing utility that allows developers to obtain a reference to the underlying target object hidden behind one or more Spring proxies. ** See <> for details. * `ReflectionTestUtils` now supports setting and getting `static` fields, including constants. * The original ordering of bean definition profiles declared via `@ActiveProfiles` is now retained in order to support use cases such as Spring Boot's `ConfigFileApplicationListener` which loads configuration files based on the names of active profiles. * `@DirtiesContext` supports new `BEFORE_METHOD`, `BEFORE_CLASS`, and `BEFORE_EACH_TEST_METHOD` modes for closing the `ApplicationContext` _before_ a test -- for example, if some rogue (i.e., yet to be determined) test within a large test suite has corrupted the original configuration for the `ApplicationContext`. * `@Sql` now supports execution of _inlined SQL statements_ via a new `statements` attribute. * The `ContextCache` that is used for caching ++ApplicationContext++s between tests is now a public API with a default implementation that can be replaced for custom caching needs. * `DefaultTestContext`, `DefaultBootstrapContext`, and `DefaultCacheAwareContextLoaderDelegate` are now public classes in the `support` subpackage, allowing for custom extensions. * ++TestContextBootstrapper++s are now responsible for building the `TestContext`. * In the Spring MVC Test framework, `MvcResult` details can now be logged at `DEBUG` level or written to a custom `OutputStream` or `Writer`. See the new `log()`, `print(OutputStream)`, and `print(Writer)` methods in `MockMvcResultHandlers` for details. * The JDBC XML namespace supports a new `database-name` attribute in ``, allowing developers to set unique names for embedded databases –- for example, via a SpEL expression or a property placeholder that is influenced by the current active bean definition profiles. * Embedded databases can now be automatically assigned a unique name, allowing common test database configuration to be reused in different ++ApplicationContext++s within a test suite. This support can be enabled via: ** `EmbeddedDatabaseFactory.setGenerateUniqueDatabaseName()` ** `EmbeddedDatabaseBuilder.generateUniqueName()` ** ``