Spring Framework Changelog

New in version 4.0.0

January 8th, 2014
  • 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.
  • 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.
  • 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 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 10, as released in late 2008) 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.
  • Note that the Java 8 bytecode level (-target 1.8, as required by -source 1.8) is only fully supported as of Spring Framework 4.0. In particular, Spring 3.2 based applications need to be compiled with a maximum of Java 7 as the target, even if they happen to be deployed onto a Java 8 runtime. Please upgrade to Spring 4 for Java 8 based applications.
  • 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 application into a Servlet 2.5 environment; however, Servlet 3.0+ is recommended when at all possible.
  • Groovy Bean Definition DSL:
  • With Spring Framework 4.0 it is now 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.
  • Core Container Improvements:
  • 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 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 @Ordered annotation and Ordered interface are supported.
  • The @Lazy annotation can now be used on injection points, as well as @Bean definitions.
  • The @Description annotation has been added 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 but allows for user-defined strategies to be developed.
  • 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.
  • 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 earlier, the following general improvements have been made to Spring’s Web modules:
  • You can use the new @RestController annotation with Spring MVC applications, removing the need to add @ResponseBody to each of your @RequestMapping methods.
  • The AsyncRestTemplate class has been added, allowing non-blocking asynchronous support when developing REST clients.
  • Spring now offers comprehensive timezone support 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 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. IE < 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 from the Spring Integration project such as Message, MessageChannel, MessageHandler and others to serve as a foundation for messaging applications.
  • Testing Improvements:
  • 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 tests.
  • 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 utility class has been introduced in the spring-core module which enables you to scan for free TCP & 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 compatible with Servlet 3.0. Furthermore, several of the Servlet API mocks (e.g., MockHttpServletRequest, MockServletContext, etc.) have been updated with minor enhancements and improved configurability.

New in version 3.2.4 (August 7th, 2013)

  • fixed potential security risk when using Spring OXM with JAXB (SPR-10806)
  • support for Quartz 2.2 (SPR-10775)
  • updated spring-instrument manifest to include JDK 7 redefine/retransform attributes (SPR-10731)
  • TypeDescriptor class is marked as Serializable now (SPR-10631)
  • ConfigurationClassPostProcessor is Ordered.HIGHEST_PRECEDENCE now (SPR-10645)
  • @ImportResource supports ${...} placeholders as well (SPR-10686)
  • BeanFactory's getBeansWithAnnotation ignores abstract bean definitions (SPR-10672)
  • fixed regression with non-String value attributes on custom stereotypes (SPR-10580)
  • fixed regression in nested placeholder resolution in case of ignoreUnresolvablePlaceholders (SPR-10549)
  • fixed SpEL's MethodExecutor to correctly cache overloaded methods (SPR-10684)
  • fixed ClassFilterAwareUnionMethodMatcher equals implementation (SPR-10604)
  • introduced latest CGLIB UndeclaredThrowableStrategy changes for better memory usage (SPR-10709)
  • fixed regression with AspectJ-based @Async handling in case of no executor set (SPR-10715)
  • proper parsing of JPA's "exclude-unlisted-classes" element with a nested "true"/"false" value (SPR-10767)
  • resource-based PlatformTransactionManager implementations defensively handle Errors on begin (SPR-10755)
  • re-introduced RmiInvocationWrapperRTD.xml for WebLogic which has been missing in 3.2 (SPR-10649)
  • Jaxb2Marshaller scans for @XmlRegistry annotation as well (SPR-10714)
  • XStreamMarshaller's "getXStream() method is non-final again (SPR-10421)
  • DelegatingFilterProxy avoids synchronization for pre-resolved delegate (SPR-10413)
  • fixed regression in @RequestParam empty value handling (SPR-10578)
  • fixed ResourceHttpRequestHandler's locations-list-empty warn log (SPR-10780)
  • fixed ContentNegotiatingViewResolver regression in case of no content type requested (SPR-10683)
  • fixed MappingJackson(2)JsonView's handling of a prefixJson="false" value (SPR-10752)
  • added configurable JSON prefix handling to MappingJackson(2)HttpMessageConverter (SPR-10627)
  • several UriComponentsBuilder refinements (SPR-10779, SPR-10701)
  • several HttpHeaders refinements (SPR-10713, SPR-10648)

New in version 3.2.1 (January 25th, 2013)

  • SpEL support for static finals on interfaces (SPR-10125)
  • AnnotationAwareOrderComparator is able to sort Class objects as well (SPR-10152)
  • added dedicated sort method to AnnotationAwareOrderComparator (SPR-9625)
  • BridgeMethodResolver properly handles bridge methods in interfaces (SPR-9330)
  • LocalVariableTableParameterNameDiscoverer works for bridge methods as well (SPR-9429)
  • added constructor with Charset argument to EncodedResource (SPR-10096)
  • ResourcePropertyResource accepts EncodedResource for properties files with a specific encoding (SPR-10096)
  • SystemEnvironmentPropertySource properly works with an active JVM SecurityManager (SPR-9970)
  • CachedIntrospectionResults.clearClassLoader(null) removes cached classes for the system class loader (SPR-9189)
  • DisposableBeanAdapter detects "shutdown" as a destroy method as well (for EHCache CacheManager setup; SPR-9713)
  • introduced NoUniqueBeanDefinitionException as a dedicated subclass of NoSuchBeanDefinitionException (SPR-10194)
  • DefaultListableBeanFactory's getBean(Class) checks primary marker in case of multiple matches (SPR-7854)
  • fixed QualifierAnnotationAutowireCandidateResolver's detection of custom qualifier annotations (SPR-10107)
  • fixed AbstractAutoProxyCreator to accept null bean names again (SPR-10108)
  • AbstractAdvisingBeanPostProcessor caches per bean target class, working for null bean names as well (SPR-10144)
  • MessageSourceResourceBundle overrides JDK 1.6 containsKey method, avoiding NPE in getKeys (SPR-10136)
  • SpringValidationAdapter properly detects invalid value for JSR-303 field-level bean constraints (SPR-9332)
  • SpringBeanAutowiringInterceptor eagerly releases BeanFactory if post-construction fails (SPR-10013)
  • added "exposeAccessContext" flag JndiRmiClientInterceptor/ProxyFactoryBean (for WebLogic; SPR-9428)
  • MBeanExporter does not log warnings for manually unregistered MBeans (SPR-9451)
  • MBeanInfoAssembler impls expose actual method parameter names if possible (SPR-9985)
  • AbstractCacheManager accepts no caches defined, allowing for EHCache default cache setup (SPR-7955)
  • EhCacheManagerFactoryBean applies cacheManagerName ahead of creation (for EHCache 2.5 compatibility; SPR-9171)
  • ThreadPoolExecutorFactoryBean exposes "createExecutor" method for custom ThreadPoolExecutor subclasses (SPR-9435)
  • added "awaitTerminationSeconds" property to ThreadPoolTaskExecutor/ThreadPoolTaskScheduler (SPR-5387)
  • aligned XML scheduled-task elements with @Scheduled in terms of kicking in after context refresh (SPR-9231)
  • reintroduced "mode" and "proxy-target-class" attributes in spring-task-3.1/3.2.xsd (SPR-10177)
  • spring-task-3.2.xsd allows for SpEL expressions in initial-delay attribute (SPR-10102)
  • spring-jms-3.2.xsd allows for SpEL expressions in prefetch and receive-timeout attributes (SPR-9553)
  • JmsTemplate uses configured receiveTimeout if shorter than remaining transaction timeout (SPR-10109)
  • added MappingJackson2MessageConverter for JMS (SPR-10099)
  • JDBC parameter binding uses JDBC 3.0 ParameterMetaData (if available) for type determination (SPR-10084)
  • JpaTransactionManager etc finds default EntityManagerFactory in parent context as well (SPR-10160)
  • MimeMessageHelper encodes attachment filename if not ASCII compliant (SPR-9258)
  • FreeMarkerConfigurationFactory properly supports TemplateLoaders when recreating Configurations (SPR-9389)
  • SpringContextResourceAdapter implements equals/hashCode according to the JCA 1.5 contract (SPR-9162)
  • ContextLoader properly detects pre-refreshed WebApplicationContext (SPR-9996)
  • added support for placeholders in @RequestMapping annotation value (SPR-9935)
  • added support for specifying a message code as @ResponseStatus reason (SPR-6044)
  • HttpEntityMethodProcessor supports HttpEntity/ResponseEntity subclasses as well (SPR-10207)
  • Tiles 3 TilesConfigurer properly works in combination with "completeAutoload" (SPR-10195)
  • Spring MVC Test framework supports HTTP OPTIONS method as well (SPR-10093)
  • MockHttpServletRequest's getParameter(Values) returns null for null parameter name (SPR-10192)
  • MockHttpServletResponse's getHeaderNames declares Collection instead of Set for Servlet 3.0 compatibility (SPR-9885)

New in version 3.0.2 (April 19th, 2010)

  • fixed cross-module version ranges in OSGi manifests
  • fixed contents of org.springframework.web.struts jar
  • upgraded to Hibernate Validator 4.0.2 and Jackson 1.4.2
  • compatibility with Hibernate 3.5 final (native and also as a JPA 2.0 provider)
  • compatibility with OpenJPA 2.0 (support for JPA 2.0 persistence.xml versioning)
  • compatibility with Hessian 4.0 (in terms of exception propagation)
  • compatibility with JasperReports 3.x (in terms of resource management)
  • restored full compatibility with Servlet 2.4 containers on all VMs
  • PropertyEditor lookup fallback works on Google App Engine as well
  • fixed TypeDescriptor/MethodParameter toString for all cases in debug log messages
  • widened AbstractFactoryBean's "getObjectType" signature to return any Class as well
  • BeanPostProcessors are allowed to return a null bean value in the middle of the chain
  • autowire="byType" ignores parameter name when choosing a primary bean, as defined
  • ObjectFactoryCreatingFactoryBean creates a serializable ObjectFactory reference
  • added ProviderCreatingFactoryBean, exposing a serializable JSR-330 Provider reference
  • "conversionService" bean will be ignored if it is not of type ConversionService
  • revised AbstractInterceptorDrivenBeanDefinitionDecorator for alignment with auto-proxying
  • SimpleJdbcCall's "returningResultSet" accepts any plain RowMapper now
  • added public "validateDatabaseSchema" method to Hibernate LocalSessionFactoryBean
  • HibernateJpaDialect borrows JDBC Connection on demand (supporting aggressive release)
  • JCA listener containers delegate to wrapped Transaction handle (for Geronimo compatibility)
  • @Transactional qualifiers work in unit tests as well (TransactionalTestExecutionListener)
  • @Value processing works in test instances (using the test context framework) as well now
  • @DirtiesContext is now inherited for class-level usage
  • NativeWebRequest detects native MultipartRequest when decorated by HiddenHttpMethodFilter
  • WebRequestInterceptor exposes HttpServletResponse through NativeWebRequest (after downcast)
  • WebContentInterceptor does not restrict HTTP methods by default anymore
  • WebApplicationObjectSupport's initServletContext will be called only once in any scenario
  • DispatcherPortlet passes handler instance into HandlerExceptionResolver for action exception
  • DispatcherPortlet applies preHandleRender callbacks in case of action exception as well
  • UrlPathHelper cuts off trailing servlet-path slashes for root mappings (on WebSphere)
  • introduced support for HttpEntity and ResponseEntity wrappers, adding context to body values
  • fixed DataBinder's conversion error handling for direct field access with ConversionService
  • @InitBinder methods support all applicable Spring 3.0 parameter annotations as well
  • fixed @RequestParam(required=false) regression for @InitBinder methods
  • @ExceptionHandler methods consistently receive original exception
  • fixed indexed property binding regression in form tag library
  • fixed @Configurable issue with null bean name

New in version 3.0.0 RC2 (November 17th, 2009)

  • updated to final versions of JSR-330 "javax.inject" and JSR-303 "javax.validation" APIs
  • full compliance with the JSR-330 TCK (i.e. full compliance with the final specification)
  • support for Hibernate Validator 4.0 GA (as the JSR-303 reference implementation)
  • added support for load-time weaving in JBoss 5.x
  • added support for recent EHCache 1.6 configuration properties to EHCacheFactoryBean
  • added AnnotatedBeanDefinitionReader helper for programmatic registration of annotated classes
  • added AnnotationConfig(Web)ApplicationContext for convenient registration/scanning of classes
  • added GenericXmlApplicationContext with flexible configuration options for its XML support
  • AbstractApplicationContext can also start up in case of system properties access failure
  • internal MergedBeanDefinitionPostProcessors apply after all other post-processors
  • inner beans detected as ApplicationListeners as well (only supported for inner singletons)
  • child bean definition's scope attribute can be inherited from parent bean definition now
  • introduced SmartLifecycle interface with auto-startup and shutdown order support
  • introduced LifecycleProcessor delegate, customizable through "lifecycleProcessor" bean
  • MessageListenerContainers and Quartz SchedulerFactoryBean start up on refresh instead of init
  • added initialize-database tag to jdbc namespace for populating external data sources with data
  • PathMatchingResourcePatternResolver leniently ignores non-existing root directories
  • DefaultConversionService understands "on"/"off", "yes"/"no", "1"/"0" as boolean values
  • CustomEditorConfigurer supports PropertyEditor instances again (with deprecation warning)
  • revised MethodParameter's annotation accessor methods
  • ClassUtils is now parameterized with Class and Class where appropriate
  • DataBinder now accepts var-args to set allowed, disallowed, and required fields
  • DataBinder auto-grows nested paths on traversal (avoiding NullValueInNestedPathException)
  • fixed enum binding regression with WebRequestDataBinder (as used by @MVC data binding now)
  • fixed FieldError to expose rejected input value as String value instead of as array
  • JSR-303 Validator will only register validation failures if no binding failure happened
  • ContentNegotiatingViewResolver works with ignoreAcceptHeader and defaultContentType as well
  • added Spring MVC namespace, with convenient mvc:annotation-driven configuration element
  • default number and datetime formatters configured when using the Spring MVC namespace
  • full support for datetime formatting using the Joda Time library (automatically enabled)
  • added convenient @NumberFormat and @DateTimeFormat annotations for declarative formatting
  • implicit T.valueOf(S) and constructor T(S) lookup if no explicit S->T converter matches
  • AbstractExcelView is compatible with Apache POI 3.0 as well as 3.5 now
  • TilesConfigurer only sets up EL support if JSP 2.1 is present (for JSP 2.0 compatibility)
  • re-introduced Struts 1.x support ("org.springframework.web.struts") in deprecated form
  • deprecated scheduling support for JDK 1.3 Timer ("org.springframework.scheduling.timer")
  • deprecated remoting support for JAX-RPC (in favor of JAX-WS)

New in version 2.5.5 (September 9th, 2008)

  • fixed SCM URL in Maven POMs
  • "-with-dependencies" distribution includes "jarcontent" folder now (needed for building from the source)
  • upgraded to Quartz 1.6.1 (includes a fix for the Spring trigger persistence problem that was introduced in 1.6.0)
  • upgraded to Hibernate 3.3.0 (while retaining compatibility with Hibernate 3.1/3.2)
  • upgraded to iBATIS SQL Maps 2.3.2 (while retaining compatibility with iBATIS 2.3.0)
  • added "proxyClassLoader" property to ProxyFactoryBean, AbstractSingletonProxyFactoryBean and AbstractAutoProxyCreator
  • CustomizableTraceInterceptor hides proxy class names even in log replacement strings (if hideProxyClassNames=true)
  • CustomizableTraceInterceptor properly escapes all "" and "$" symbols in replacement values
  • revised GenericTypeAwarePropertyDescriptor for compatibility with IBM's JDK 1.6 (avoiding NPE)
  • TypeMismatchException shows type description for mismatching JDK proxy values (listing their implemented interfaces)
  • CustomNumberEditor explicitly removes all inline whitespace from input Strings (for compatibility with French locales)
  • added "getDescription()" method to BeanDefinition interface (exposing the value of the XML bean description element)
  • AbstractFactoryBean uses bean ClassLoader for the generation of early singleton proxies
  • PropertyPlaceholderConfigurer correctly manages resolution of set entries and map keys with modified hash code
  • fixed DefaultSingletonBeanRegistry's singleton exposure to remove singleton factory after creation of singleton object
  • DefaultSingletonBeanRegistry only exposes related causes on outermost creation exception (avoiding excessive logging)
  • DefaultSingletonBeanRegistry only registers same related cause (i.e. same message, same chained cause) once
  • DefaultListableBeanFactory only registers causes during constructor resolution when resolution eventually fails
  • DefaultListableBeanFactory checks primary attribute in bean definitions of parent factory as well
  • fixed DefaultListableBeanFactory to use a post-processing lock (for proper synchronization of annotation scanning)
  • dependency check "simple" accepts Number, Date, URI, URL and Locale as well (consistent with simple MVC value types)
  • UnsatisfiedDependencyException preserves full nested exception stacktrace in case of a BeansException
  • added overloaded BeanComponentDefinition constructor with aliases argument
  • GenericBeanFactoryAccessor's "getBeansWithAnnotation" performs deep search (including interfaces and target class)
  • added "findAnnotationOnBean" method to GenericBeanFactoryAccessor, performing a deep search on a specific bean
  • BeanConfigurerSupport (@Configurable processing) includes type of bean in warn log when called in unconfigured state
  • restored BeanConfigurerSupport's silent skipping in case of no BeanFactory configured yet
  • factored out MessageSourceSupport base class from AbstractMessageSource, providing common MessageFormat handling
  • DelegatingMessageSource resolves message arguments in default messages even if there is no parent MessageSource
  • MessageSourceResourceBundle exposes Spring-specified locale through overridden "ResourceBundle.getLocale()" method
  • revised CommonAnnotationBeanPostProcessor's "getResource" method to allow for proper overriding in subclasses
  • ClassPathBeanDefinitionScanner always accepts explicit bean definition of same name as override for scanned bean
  • added type="custom" expression="" option to component-scan's "include-filter"/"exclude-filter"
  • component-scan's "include-filter"/"exclude-filter" entries are validated individually (for Spring IDE)
  • added assertions to GenericTypeResolver (avoiding NPEs)
  • factored out generic ConfigurableObjectInputStream class from CodebaseAwareObjectInputStream in RMI support
  • re-enabled PathMatchingResourcePatternResolver's JarURLConnection handling (accidentally disabled in 2.5.4)
  • "jee:local/remote-slsb" accepts plain object returned from EJBHome create method (for JBoss 4.2 EJB3 compatibility)
  • added "exposeAccessContext" flag to AbstractSlsbInvokerInterceptor, for WebLogic resource factories with authorization
  • added "expose-access-context" flag to "jee:local-slsb", "jee:remote-slsb" and "jee:jndi-lookup"
  • added SimpleDriverDataSource alternative to DriverManagerDataSource, avoiding class loading and synchronization issues
  • BeanPropertySqlParameterSource uses specific integer/decimal SQL types by default now (e.g. TINYINT, BIGINT, DOUBLE)
  • introduced SqlXmlHandler abstraction (for the XML support in the Advanced Pack for Oracle Database)
  • added further SQL error code mapping for MS SQL Server
  • SingleConnectionFactory and TransactionAwareConnectionFactoryProxy use JMS API ClassLoader for proxy generation
  • JmsTemplate properly allows for overriding "getDefaultDestination()" and "getDefaultDestinationName()"
  • AbstractJmsListeningContainer sets Connection to null on shutdown, allowing for smooth reinitialization
  • DefaultMessageListenerContainer performs lazy setup in case of any connection exception (also JNDI lookup failure)
  • DefaultMessageListenerContainer is able to recover all cases where the provider is not available on startup
  • fixed DefaultMessageListenerContainer to avoid race condition when stopping through lock on unified monitor
  • added "container-class" attribute to "jms:listener-container" element, for specifying a custom implementation class
  • MessageListenerAdapter and JmsInvokerServiceExporter use message id as correlation id if no request correlation id set
  • MBeanExporter performs default MBeanServer lookup even when registering notification listeners only
  • added "exposeAccessContext" flag to JndiObjectFactoryBean, for WebLogic resource factories with authorization
  • removed overlapping "application/x-pointplus" MIME type for "css" extension from MimeMessageHelper's default mappings
  • improved HibernateTransactionManager's InvalidIsolationLevelException exception message (-> SpringTransactionFactory)
  • added "hibernateManagedSession" flag to HibernateTransactionManager, for working with a custom CurrentSessionContext
  • documented use of Hibernate StatelessSession with Spring's DataSourceTransactionManager/HibernateTransactionManager
  • added support for Derby and H2 through Hibernate/OpenJpa/TopLink/EclipseLinkJpaVendorAdapter's "database" property
  • Hibernate/TopLink/JDO/JPA proxy classes are generated in the ORM provider's ClassLoader (for full visibility in OSGi)
  • Spring-enriched JPA proxies are created in the application's ClassLoader (making any vendor interfaces work in OSGi)
  • fixed AbstractEntityManagerFactoryBean's EMF proxy to handle equals/hashCode locally (for correct equals behavior)
  • iBATIS SqlMapClientFactoryBean supports multiple sql-map-config files and also patterns ("configLocations" property)
  • iBATIS SqlMapClientFactoryBean supports Spring resource/pattern lookup of sql-map files ("mappingLocations" property)
  • RemoteAccessException explicitly declares serialVersionUID (for serialization compatibility on WebLogic)
  • (Simple)HttpInvokerServiceExporter uses the ClassLoader of the containing BeanFactory for deserialization
  • fixed JaxWsClientInterceptor to throw a RemoteConnectFailureException (if applicable) instead of returning it
  • added support for "username"/"password"/"maintainSession"/"useSoapAction"/etc properties to JaxWsClientInterceptor
  • added SimpleHttpServerJaxWsServiceExporter, allowing for exposure through a fully configurable Sun JDK 1.6 HttpServer
  • added "filters" and "authenticator" property to SimpleHttpServerFactoryBean for Sun's JDK 1.6 HttpServer
  • revised HessianExporter's "debug" feature to work on Hessian 3.0.20+ as well (with input debugging only)
  • SchedulerFactoryBean's "jobSchedulingDataLocation" feature is compatible with Quartz 1.6.1 now (requiring 1.6.1+)
  • ScriptFactoryPostProcessor ignores any "predictBeanType" failure (in particular reference to currently created bean)
  • GroovyScriptFactory also converts CompilationFailedException to ScriptCompilationException during type determination
  • added "prepareApplicationContext(GenericApplicationContext)" template method to AbstractSingleSpringContextTests
  • added "prepareContext(GenericApplicationContext)" template method to AbstractGenericContextLoader
  • removed unnecessary "throws Exception" declarations from ReflectionTestUtils
  • added "getField" and "invokeGetterMethod" methods to ReflectionTestUtils
  • transactional resource synchronization works even for operations triggered during commit (e.g. by JPA PostUpdate)
  • strengthened warning regarding @Transactional use on interfaces versus classes
  • "tx:annotation-driven" registers revised TransactionAttributeSourceAdvisor, initializing TransactionInterceptor lazily
  • publicly exposed "isVisible" method on ClassUtils
  • added "getField" and simple "findField" method to ReflectionUtils
  • NumberUtils avoids overflow when converting from BigDecimal to BigInteger
  • NumberUtils automatically supports JDK 1.5+ localized BigDecimal parsing
  • added various overloaded methods with a CharSequence argument (as alternative to a String argument) to StringUtils
  • removed Commons Log usage from SystemPropertyUtils, ClassUtils, FileCopyUtils (avoiding early Log4J initialization)
  • revised CachingMapDecorator to expose all state representations in a thread-safe manner, even for pure introspection
  • revised CachingMapDecorator to use weak references for caching only (not losing a value from get)
  • fixed DefaultBindingErrorProcessor to register correct "missing field" errors within specified nested path
  • revised RequestAttributes access from child threads in order to not touch the request object after request completion
  • DispatcherServlet exposes the Servlet spec's error attributes to error views (for JSP error page compatibility)
  • HandlerMethodInvoker does not eagerly copy entire model Map in order to avoid lazy initialization of attribute values
  • Servlet AnnotationMethodHandlerAdapter throws ambiguity exception in case of equivalent mappings with same method name
  • Portlet AbstractMapBasedHandlerMapping sorts predicates before checking them (according to their natural order)
  • Portlet DefaultAnnotationHandlerMapping checks default mappings last, independent from order of controller definition
  • RedirectView uses request's encoding (default ISO-8859-1) if no encoding scheme specified (previous default was UTF-8)
  • RedirectView considers arrays and collections with eligible values, turning them into multi-value request parameters
  • RedirectView accepts StringBuffers, StringBuilders, Numbers, Dates, URIs, URLs and Locales as eligible values as well
  • factored out common temporary byte array handling from AbstractPdfView etc into AbstractView base class
  • added AbstractPdfStamperView as alternative to AbstractPdfView, operating on an existing document with an AcroForm
  • fixed AbstractJasperReportsView to fully isolate a model-specified JDBC DataSource (not setting it as view DataSource)
  • AbstractJasperReportsView gives specified JDBC DataSource precedence over implicit report data value in model
  • AbstractJasperReportsView proceeds without report data value in case of multiple collections or object arrays
  • added "autocomplete" attribute to JSP FormTag (for a form-wide setting, as alternative to InputTag's "autocomplete")
  • JSF DelegatingVariableResolver and SpringBeanFacesELResolver log resolution success at trace level only