SPRING FRAMEWORK CHANGELOG =========================== http://www.spring.io Changes in version 3.2.8 (2014-02-18) ------------------------------------- * fixed potential LinkageError with aop:scoped-proxy (SPR-11398) * fixed various memory leaks (SPR-11440, SPR-10785) * added processExternalEntities support to OXM (SPR-11376) * fixed URL mapping issue (SPR-11101) * prevented unwanted side-effects from PreparedStatements (SPR-11386) * restore correct equals/hashCode for AbstractBeanDefinition (SPR-11420) * fixed various HTML form issues (SPR-10837, SPR-11426) * wraped runtime-registered EhCacheCacheManager caches with TransactionAwareCacheDecorator (SPR-11407) * fixed StringIndexOutOfBoundsException in AbstractErrors for class-level JSR-303 validator (SPR-11374) * fixed off-by-one regression in AbstractMethodMockingControl (SPR-11385) * fixed potential ClassCastException in RequestContextListener when destroying the request object (SPR-11378) * fixed various stream closing issues (SPR-11411, SPR-11413) * fixed broken documentation links (SPR-11404) * improved error reporting for issues related to @Controller types requiring AOP proxing (SPR-11281) * consider nonPublicAccessAllowed flag and SecurityManager with resolveFactoryMethodIfPossible method (SPR-11422) * don't lazily populate a hash field for Objects with multi-threaded access (SPR-11428) * fixed locale specific unit test failures (SPR-11392) * explicitly skip BindingResult when searching for a model object in MarshallingView (SPR-11417) * fixes potential malformed JSON from LiveBeansView (SPR-11366) Changes in version 3.2.7 (2013-12-12) ------------------------------------- * fixed memory leaks with @Async (SPR-11275, SPR-11276) * restored full Java 5 compatibility (SPR-11313, SPR-11349, SPR-11321) * fixed various dependency compatibility issues (SPR-11359, SPR-11265, SPR-11362, SPR-11284) * improved performance and reduced memory consumption for some edge cases (SPR-11343, SPR-9014, SPR-11344, SPR-11304) * fixed WebSphere compatibility issue (SPR-11341, SPR-11297) * fixed ServletWebRequest.checkNotModified() methods to treat HEAD identically to GET (SPR-11317) * fixed various regression issues (SPR-11320, SPR-11246, SPR-11231) * fixed theme resolution fails with "IllegalArgumentException" issue (SPR-11128) * fixed @Enable registrars subclass issues (SPR-11251) * allowed consolidation of all configuration into the "root" context with AbstractAnnotationConfigDispatcherServletInitializer (SPR-11357) * provided alternative RestTemplate constructor to avoid default MessageConverter creation (SPR-11351) * handle NoClassDefFoundError for TestExecutionListeners consistently (SPR-11347) * fixed @Bean meta-annotation detection when using ASM (SPR-10488) * provide access to SimpleTriggerFactoryBean property startTime (SPR-10940) * added patch() to MockMvcRequestBuilders (SPR-11299) * provided a mechanism for adding ApplicationContextInitializers to DispatcherServlet's ApplicationContext (SPR-11314) * fixed various documentation issues (SPR-3983, SPR-11364, SPR-11331) * enabled ServletTestExecutionListener by default in abstract base test classes (SPR-11340) * fixed type comparison in ReflectionHelper.getTypeDifferenceWeight (SPR-11306) * improved logging and exception information (SPR-11346, SPR-11333) * fixed read/write method mismatch problems with BeanWrapper (SPR-11361) * fixed context:component-scan element in the mvc-cofig.xml (SPR-11221) * fixed XMLEventStreamWriter handleing for writeEmptyElement() followed by writeAttribute() (SPR-11254) * fixed CronTriggerFactoryBean to allow calendar name and description to be specified (SPR-9771) Changes in version 3.2.6 (2013-12-12) ------------------------------------- * added Maven bill-of-materials POM * fixed BeanUtils.copyProperties() issue caused by recently changes to GenericTypeAwarePropertyDescriptor (SPR-11209) * fixed issue with ServletTestExecutionListener breaking existing code (SPR-11144) * fixed SpEL ReflectivePropertyAccessor to not consider "is" methods with non boolean returns (SPR-11142) * support multiple comma-separated values in X-Forwarded-Host header (SPR-11140) * fixed tests related to java.beans.BeanInfo changes in JDK8-b117 (SPR-11139) * added synchronization to EhCacheFactoryBean.afterPropertiesSet (SPR-11132) * fixed dependency injection issue when using ManagedMap or ManagedList in BeanDefinitionParser (SPR-11131) * fixed support for combining multiple @Cacheable within @Caching annotation (SPR-11124) * allow autowire qualified scoped-proxy @Bean definitions (SPR-11116) * fixed type resolution fails for uninitialized factory-method declaration issue (SPR-11112) * fixed "CglibAopProxy: Unable to proxy method" warning when bean class contains static final method (SPR-11107) * improved performance for repeated JDBC 3.0 getParameterType calls in StatementCreatorUtils (SPR-11100) * fixed minor issue with prior fix for CVE 2010-1622 (SPR-11098) * added mapping for additional Sybase error code to DataIntegrityViolationException (SPR-11097) * fixed issue with "!profile" selector XML (SPR-11093) * fixed set statistics issues with EhCache (SPR-11092, SPR-11080) * fixed classpath scanning issue on private meta-attributes (SPR-11091) * fixed potential NPE when calling stored procedures (SPR-11076) * added synchronization to MBeanExporter & MBeanRegistrationSupport (SPR-11002) * removed integer conversion from JmsListenerContainerParser (SPR-10986) * fixed @ResourceMapping issue with Portlets (SPR-10791) Changes in version 3.2.5 (2013-11-06) ------------------------------------- * fixed type prediction for generic factory method with conversion of method arguments (SPR-10411) * fixed GenericTypeResolver issues relating to ParameterizedType (SPR-10819) * allow indexed constructors to be used with @Autowire resolution (SPR-11019) * refined JavaConfig overrides algorithm (SPR-10988, SPR-10992) * fixed multiple calls to @Autowire setters when defining several beans of the same class (SPR-11027) * provided more lenient fallback checks for setter injection (SPR-10995) * allowed AnnotationConfigWebApplicationContext.register to be called multiple times (SPR-10852) * fixed various SpEL issues (SPR-9495, SPR-10452, SPR-10928, SPR-10884, SPR-10953, SPR-10716, SPR-10486, SPR-11031) * added XStream catch-all converter (SPR-10821) * fixed issue with AOP Advisor being silently skipped during creation (SPR-10430) * fixed use of configured prefix for Jackson message converters (SPR-10817) * fixed SimpleJdbcCall function return issues (SPR-10606) * protected against memory leak in AntPathMatcher (SPR-10803) * fixed memory leak in AbstractBeanFactory (SPR-10896) * fixed Ehcache RMI replication issue (SPR-10904) * fixed ArrayStoreException with ASM reading of enum subclass (SPR-10914) * prevented duplicate scan of @Import annotations (SPR-10918) * fixed issues using non-shareable @Resource (SPR-10931) * ensured malformed content type is translated to 415 status code (SPR-10982) * fixed issues when converting a single element array to object (SPR-10996) * allow override of @ContextConfiguration initializer when using @ContextHierarchy (SPR-10997) * fixed issue with ordering of @PropertySource values (SPR-10820) * fixed parsing issues with JNDI variables (SPR-11039) * fixed MockHttpServletRequestBuilder handling parameter without value (SPR-11043) * fixed ClasspathXmlApplicationContext inherit/merge of parent context environment (SPR-11068) * fixed wrong translation of MS SQL error code (SPR-10902) * fixed JMSTemplate issues when used with Oracle AQ (SPR-10829) * fixed AbstractMethodMockingControl off-by-one error (SPR-10885) * fixed potential NPE with JaxB2Marshaller (SPR-10828) * fixed potential NPE with RestTemplate (SPR-10848) * fixed potential NPE in AbstractApplicationEventMulticaster (SPR-10945) * fixed potential NPE with RedirectView (SPR-10937) * fixed NPE with ExtendedBeanInfo on IBM J9 VM (SPR-10862) * improved subclassing support for RequestMappingHandlerMapping (SPR-10950) * made AnnotationConfigUtils.processCommonDefinitionAnnotations public (SPR-11032) * removed unnecessary char[] allocation with NamedParameterUtils (SPR-11042) * refined logging output (SPR-10974, SPR-11017) * minor documentation updates (SPR-10798, SPR-10850, SPR-10927) Changes in version 3.2.4 (2013-08-06) ------------------------------------- * 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) Changes in version 3.2.3 (2013-05-17) ------------------------------------- * compatibility with OpenJDK 8 for target 1.5/1.6/1.7 compiled Spring Framework 3.2.x applications (SPR-9639) * compatibility with OSGI-style use of generics in source code that got compiled to 1.4 byte code (SPR-10559) * consistent detection of Order annotation in superclasses and interfaces (SPR-10514) * fixed regression with type detection for child bean definitions (SPR-10374) * fixed configuration class overriding in terms of superclasses (SPR-10546) * minimized ASM usage during configuration class processing (SPR-10292) * added public "getName()" accessor to MethodReference (SPR-10422) * fixed ReflectiveMethodResolver to avoid potential UnsupportedOperationException on sort (SPR-10392) * JdbcTemplate defensively uses JDBC 3.0 getParameterType call for Oracle driver compatibility (SPR-10385) * introduced public ArgumentPreparedStatementSetter and ArgumentTypePreparedStatementSetter classes (SPR-10375) * fixed BeanPropertyRowMapper to only prefix actual upper-case letters with underscores (SPR-10547) * HibernateJpaDialect supports Hibernate 4.2 as a JPA provider now (SPR-10395) * fixed Jaxb2Marshaller's partial unmarshalling feature to consistently apply to all sources (SPR-10282) * ContentNegotiationManager properly handles HttpMessageConverter checking for Accept header "*/*" (SPR-10513) * SimpleMappingExceptionResolver prefers longer mapping expression in case of same exception depth (SPR-9639) * ServletContextResourcePatternResolver supports Tomcat-style "foo#bar.war" deployment unit names (SPR-10471) * fixed potential deadlock with DeferredResult timeout handling on Tomcat (SPR-10485) * fixed regression with ResourceHttpMessageConverter accidentally not closing underlying files (SPR-10460) * fixed regression with JSP form tag prepending the context/servlet path (broke use for Portlets; SPR-10382) * added "jsonPrefix" property to MappingJackson(2)JsonView, allowing for a custom prefix (SPR-10567) * changed MappingJackson(2)JsonView's "writeContent" template method to include "jsonPrefix" String (SPR-10567) Changes in version 3.2.2 (2013-03-14) ------------------------------------- * official support for Hibernate 4.2 (SPR-10255) * fixed missing inter-dependencies in module POMs (SPR-10218) * marked spring-web module as 'distributable' in order for session replication to work on Tomcat (SPR-10219) * DefaultListableBeanFactory caches target type per bean definition and allows for specifying it in advance (SPR-10335) * DefaultListableBeanFactory clears by-type matching cache on runtime register/destroySingleton calls (SPR-10326) * ConfigurationClassPostProcessor consistently uses ClassLoader, not loading core JDK annotations via ASM (SPR-10249) * ConfigurationClassPostProcessor detects covariant return type mismatch, avoiding infinite recursion (SPR-10261) * ConfigurationClassPostProcessor allows for overriding of scoped-proxy bean definitions (SPR-10265) * "depends-on" attribute on lang namespace element actually respected at runtime now (SPR-8625) * added locale-independent "commonMessages" property to AbstractMessageSource (SPR-10291) * added "maximumAutoGrowSize" property to SpelParserConfiguration (SPR-10229) * allow for ordering of mixed AspectJ before/after advices (SPR-9438) * added "beforeExistingAdvisors" flag to AbstractAdvisingBeanPostProcessor (SPR-10309) * MethodValidation/PersistenceExceptionTranslationPostProcessor apply after existing advisors by default (SPR-10309) * fixed regression in SpringValidatorAdapter's retrieval of invalid values (SPR-10243) * support 'unless' expression for cache veto (SPR-8871) * @Async's qualifier works for target class annotations behind a JDK proxy as well (SPR-10274) * @Scheduled provides String variants of fixedDelay, fixedRate, initialDelay for placeholder support (SPR-8067) * refined CronSequenceGenerator's rounding up of seconds to address second-specific cron expressions (SPR-9459) * @Transactional in AspectJ mode works with CallbackPreferringPlatformTransactionManager (WebSphere) as well (SPR-9268) * LazyConnectionDataSourceProxy catches setReadOnly exception analogous to DataSourceUtils (SPR-10312) * SQLErrorCodeSQLExceptionTranslator tries to find SQLException with actual error code among causes (SPR-10260) * added "createTemporaryLob" flag to DefaultLobHandler, using JDBC 4.0's createBlob/Clob mechanism (SPR-10339) * deprecated OracleLobHandler in favor of DefaultLobHandler for the Oracle 10g driver and higher (SPR-10339) * deprecated (NamedParameter)JdbcTemplate's queryForInt/Long operations in favor of queryForObject (SPR-10257) * added useful query variants without parameters to NamedParameterJdbcTemplate, for convenience in DAOs (SPR-10256) * "packagesToScan" feature for Hibernate 3 and Hibernate 4 detects annotated packages as well (SPR-7748, SPR-10288) * HibernateTransactionManager for Hibernate 4 supports "entityInterceptor(BeanName)" property (SPR-10301) * DefaultJdoDialect supports the JDO 2.2+ isolation level feature out of the box (SPR-10323) * DefaultMessageListenerContainer invokes specified ExceptionListener for recovery exceptions as well (SPR-10230) * DefaultMessageListenerContainer logs recovery failures at error level and exposes "isRecovering()" method (SPR-10230) * added "mappedClass" property to Jaxb2Marshaller, introducing support for partial unmarshalling (SPR-10282) * added "entityResolver", "classDescriptorResolver", "doctypes" and further properties to CastorMarshaller (SPR-8470) * deprecated CastorMarshaller's "object" property in favor of "rootObject" (SPR-8470) * MediaType throws dedicated InvalidMediaTypeException instead of generic IllegalArgumentException (SPR-10226) * DispatcherServlet allows for customizing its RequestAttributes exposure in subclasses (SPR-10342) * AbstractCachingViewResolver does not use global lock for accessing existing View instances anymore (SPR-3145) * MappingJackson(2)JsonView allows subclasses to access the ObjectMapper and to override content writing (SPR-7619) * Tiles 3 TilesConfigurer preserves standard EL support for "completeAutoload" mode as well (SPR-10361) * Log4jWebConfigurer supports resolving placeholders against ServletContext init-parameters as well (SPR-10284) * consistent use of LinkedHashMaps and independent getAttributeNames Enumeration in Servlet/Portlet mocks (SPR-10224) * several MockMvcBuilder refinements (SPR-10277, SPR-10279, SPR-10280) * introduced support for context hierarchies in the TestContext framework (SPR-5613) * introduced support for WebApplicationContext hierarchies in the TestContext framework (SPR-9863) Changes in version 3.2.1 (2013-01-24) -------------------------------------- * 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 to 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) Changes in version 3.2 GA (2012-12-13) -------------------------------------- * upgraded Spring Framework build to AspectJ 1.7.1, JUnit 4.11, Groovy 1.8.8, JRuby 1.6.5, Joda-Time 2.1 * checked compatibility of Spring's Velocity support with Velocity 1.7 and Velocity Tools 2.0 * checked compatibility of Spring's JasperReports support with JasperReports 5.0 * added unit tests for Spring's Hibernate 4 support * deprecated Apache iBATIS support in favor of native Spring support in Mybatis (the iBATIS successor) * deprecated JSF 1.1 VariableResolver implementations in favor of Spring-provided JSF 1.2 ELResolvers * deprecated BeanReferenceFactoryBean and CommonsLogFactoryBean * DeprecatedBeanWarner detects deprecated FactoryBean classes and always logs user-specified bean type * fixed CGLIB proxy class leaks through further equals/hashCode implementations in Spring AOP pointcuts (SPR-8008) * ConfigurationClassPostProcessor consistently uses ClassLoader, not loading core JDK classes via ASM (SPR-10058) * SpEL indexer uses direct access to specific List elements instead of iterating over the Collection (SPR-10035) * DefaultMessageListenerContainer allows for concurrent subscription consumers on WebLogic/ActiveMQ (SPR-10037) * DefaultMessageListenerContainer clears resources of paused tasks when shutting down after stop (SPR-10092) * tx timeouts for JPA translate to "javax.persistence.query.timeout" only (for EclipseLink compatibility; SPR-10068) * ResourceDatabasePopulator and JdbcTestUtils now support comments within SQL statements (SPR-10075, SPR-9982) * AbstractCachingViewResolver uses a cache limit of 1024 by default, avoiding overflow for redirect URLs (SPR-10065) * fixed HierarchicalUriComponents equals implementation (SPR-10088) Changes in version 3.2 RC2 (2012-11-27) --------------------------------------- * overhauled non-void JavaBean write method support (SPR-10029) * CachedIntrospectionResults uses full WeakReference for any non-safe ClassLoader arrangement (SPR-10028) * DefaultListableBeanFactory avoids wide/interleaved metadata locks to avoid deadlock potential (SPR-10020) * DefaultListableBeanFactory avoids singletonObjects lock wherever possible for non-singleton performance (SPR-9819) * DefaultListableBeanFactory doesn't cache for autowireBean calls anymore, avoiding ClassLoader leaks (SPR-8956) * Java 5 Closeable's and Java 7 AutoCloseable's "close()" automatically detected as destroy methods (SPR-10034) * @Bean destroy method inference not applying for DisposableBean implementers (avoiding double destruction) * @Lazy and @DependsOn not marked as @Inherited anymore - only supported on actual bean types (SPR-9589, SPR-9476) * AsyncAnnotationBean/MethodValidation/PersistenceExceptionTranslationPostProcessor cache eligible beans (SPR-7328) * ConfigurableApplicationContext, LobCreator and Client/ServerHttpResponse implement Closeable for Java 7 (SPR-9962) * spring-jms-3.2.xsd declares former nmtoken attributes as string, allowing for placeholders (SPR-9597) * ResourceDatabasePopulator explicitly closes its LineNumberReader (SPR-9912) * introduced TransactionAwareCacheManagerProxy for cache put synchronization with Spring transactions (SPR-9966) * added "transactionAware" bean property to EhCacheCacheManager and JCacheCacheManager (SPR-9966) * moved "cache.ehcache" and "cache.jcache" packages from spring-context to spring-context-support module * deprecated "scheduling.backportconcurrent" package in favor of native JDK 6 "scheduling.concurrent" support * deprecated Oracle OC4J support (OC4JJtaTransactionManager, OC4JLoadTimeWeaver) in favor of Oracle WebLogic * deprecated ExpressionEvaluationUtils, turning off Spring's own JSP expression support in favor of JSP 2.0 * deprecated EJB 2.x implementation class hierarchy in "ejb.support" package * deprecated DefaultAnnotationHandlerMapping and AnnotationMethodHandlerAdapter/ExceptionResolver (SPR-10005) * Hibernate 4 support independently compiled against Hibernate 4.1, avoiding the use of reflection (SPR-10039) * added integration with Tiles 3 (SPR-8825) Changes in version 3.2 RC1 (2012-11-04) --------------------------------------- * added "getApplicationName()" method to ApplicationContext interface * introduced LiveBeansView MBean and LiveBeansViewServlet (SPR-9662) * ResourceBundleMessageSource supports "defaultEncoding", "fallbackToSystemLocale", "cacheSeconds" (SPR-7392) * BeanWrapper does not fall back to String constructor if ConversionService attempt failed before (SPR-9865) * @Autowired, @Value, and qualifiers may be used as meta-annotations for custom injection annotations (SPR-9890) * @DateTimeFormat may now be used as a meta-annotation for custom formatting annotations * allow replaced-method 'arg-type' matches against element body as well as 'match' attribute (SPR-9812) * fixed potential race condition in concurrent calling of autowired methods on a prototype bean (SPR-9806) * cancel on a Future returned by a TaskScheduler works reliably (SPR-9821) * LoadTimeWeaverAware beans are consistently being created early for JPA weaving to work reliably (SPR-9857) * @ManagedResource supports placeholder resolution on all of its String properties (SPR-8244) * Spring-backed DataSources consistently implement JDBC 4.0's Wrapper interface (SPR-9770, SPR-9856) * optimized ResourceDatabasePopulator to work around JDK 1.7 substring performance regression (SPR-9781) * JdbcTestUtils no longer interprets SQL comments as statements (SPR-9593) * JPA persistence.xml files may use jar-file entries relative to the unit root (as per the JPA spec; SPR-9797) * added "jtaDataSource" property to JPA LocalContainerEntityManagerFactoryBean (for default units; SPR-9883) * Hibernate 4 LocalSessionFactoryBuilder sets thread context ClassLoader (for JBoss 7 compatibility; SPR-9846) * HttpComponentsHttpInvokerRequestExecutor uses HttpComponents 4.2 to explicitly release connections (SPR-9833) * UriComponentsBuilder is capable of handling opaque URIs as well (SPR-9798) * CookieGenerator supports "cookieHttpOnly" flag for Servlet 3.0 (SPR-9794) * added Spring MVC Test framework (SPR-9859, SPR-7951) * introduced support for loading a WebApplicationContext in the TestContext framework (SPR-5243) * introduced support for session & request scoped beans in the TestContext framework (SPR-4588) * introduced support for setting locales in MockHttpServletRequest (SPR-9724) * improved regular expression for parsing query params (SPR-9832) * added mock implementations of Http[Input|Output]Message * MediaType's include method now recognizes wildcards in media types with a suffix (SPR-9841) * added support for wildcard media types in AbstractView and ContentNegotiationViewResolver (SPR-9807) * added support for opaque URIs in UriComponentsBuilder (SPR-9798) * added ObjectToStringHttpMessageConverter that delegates to a ConversionService (SPR-9738) * fixed NullPointerException in AbstractMessageConverterMethodProcessor (SPR-9868) * fixed issue in AnnotationMethodHandlerExceptionResolver (SPR-9209) * added CallableProcessingInterceptor and DeferredResultProcessingInterceptor * added Jackson2ObjectMapperBeanFactory (SPR-9739) * the Jackson message converters now include "application/*+json" in supported media types (SPR-7905) * DispatcherPortlet uses a forward for rendering a view as resource response (SPR-9876) * prevent duplicate @Import processing and ImportBeanDefinitionRegistrar invocation (SPR-9925) * throw AopInvocationException on advice returning null for primitive type (SPR-4675) * resolve Collection element types during conversion (SPR-9257) * allow SpEL reserved words in type package names (SPR-9862) * provide alternative message code resolver styles (SPR-9707) * support conversion from Enum Interface (SPR-9692) * bypass conversion when possible (SPR-9566) * extend conditional conversion support (SPR-9928) * introduce @EnableMBeanExport (SPR-8943) * add StringToUUIDConverter (SPR-9765) * allow MapToMap conversion even without a default constructor (SPR-9284) * allow SpEL to resolve getter method against object of type Class (SPR-9017) * prevent memory leaks with @Configuration beans (SPR-9851) * support inferred base package for @ComponentScan (SPR-9586) * sort candidate @AspectJ methods deterministically (SPR-9729) * improve SimpleStreamingClientHttpRequest performance (SPR-9530) * added UnknownHttpStatusCodeException (SPR-9406) * support for custom global Joda DateTimeFormatters (SPR-7121) * support DateTimeFormat annotation without Joda (SPR-6508) * use concurrent cache to improve performance of GenericTypeResolver (SPR-8701) * cache and late resolve annotations on bean properties to improve performance (SPR-9166) * allow PropertyResolver implementations to ignore unresolvable ${placeholders} (SPR-9569) * FormHttpMessageConverter now adds Jackson JSON converters if available on the classpath (SPR-10055) Changes in version 3.2 M2 (2012-09-11) -------------------------------------- * inlined ASM 4.0 into spring-core, removed spring-asm subproject and jar (SPR-9669) * inlined CGLIB 3.0 into spring-core, eliminating external dependency (SPR-9669) * spring-test module now depends on junit:junit-dep (SPR-6966) * SpEL now supports method invocations on integers (SPR-9612) * SpEL now supports case-insensitive null literals in expressions (SPR-9613) * SpEL now supports symbolic boolean operators for OR and AND (SPR-9614) * SpEL now supports nested double quotes in expressions (SPR-9620) * SpEL now throws an ISE if a MethodFilter is registered against custom resolvers (SPR-9621) * now using BufferedInputStream in SimpleMetaDataReader to double performance (SPR-9528) * fixed cache handling for JNLP connections (SPR-9547) * now inferring return type of generic factory methods (SPR-9493) * added Field context variant to TypeConverter interface in beans module * @Value injection works in combination with formatting rules such as @DateTimeFormat (SPR-9637) * @Autowired-driven ObjectFactory/Provider resolution works in non-singleton beans as well (SPR-9181) * @Resource processing properly works with scoped beans and prototypes again (SPR-9627) * introduced "repeatCount" property in Quartz SimpleTriggerFactoryBean (SPR-9521) * introduced "jtaTransactionManager" property in Hibernate 4 LocalSessionFactoryBean/Builder (SPR-9480) * now raising RestClientException instead of IllegalArgumentException for unknown status codes * introduced JacksonObjectMapperFactoryBean for configuring a Jackson ObjectMapper in XML * introduced ContentNegotiationManager/ContentNegotiationStrategy for resolving requested media types * introduced support for content negotiation options in MVC namespace and MVC Java config * added ContentNegotiationManagerFactoryBean (SPR-8420) * introduced support for the HTTP PATCH method in Spring MVC and RestTemplate (SPR-7985) * enabled smart suffix pattern matching in @RequestMapping methods (SPR-7632) * introduced "defaultCharset" property in StringHttpMessageConverter (SPR-9487) * introduced @ExceptionResolver annotation for detecting classes with @ExceptionHandler methods * moved RSS/Atom message converter registration ahead of Jackson/JAXB2 * now handling BindException in DefaultHandlerExceptionResolver * now setting "javax.servlet.error.exception" in DefaultHandlerExceptionResolver (SPR-9653) * added ResponseEntityExceptionHandler alternative to DefaultHandlerExceptionResolver (SPR-9290) * now using reflection to instantiate StandardServletAsyncWebRequest * fixed issue with forward before async request processing * DeferredResult type is now parameterized * added async options to MVC namespace and Java config (SPR-9694) * refactored Spring MVC async support (SPR-9433) * media types in HTTP Accept headers can be parsed with single quotes (-> Android 2.x) (SPR-8917) * DispatcherPortlet no longer forwards event exceptions to the render phase by default (SPR-9287) * fixed Portlet request mapping priorities in cross-controller case (SPR-9303, SPR-9605) * introduced exclude patterns for mapped interceptors in MVC namespace and MVC Java config * introduced support for ApplicationContextInitializers in the TestContext framework (SPR-9011) * introduced support for named dispatchers in MockServletContext (SPR-9587) * introduced support for single, unqualified tx manager in the TestContext framework (SPR-9645) * introduced support for TransactionManagementConfigurer in the TestContext framework (SPR-9604) * introduced MockEnvironment in the spring-test module (SPR-9492) * deprecated SimpleJdbcTestUtils in favor of JdbcTestUtils (SPR-9235) * introduced "countRowsInTableWhere()" and "dropTables()" in JdbcTestUtils (SPR-9235) * introduced JdbcTemplate in tx base classes in the TestContext framework (SPR-8990) * introduced "countRowsInTableWhere()" and "dropTables()" in tx base test classes (SPR-9665) * introduced support for @ComponentScan base package inference (SPR-9586) * now building, testing and publishing against JDK7, maintaining compat with JDKs 5&6 (SPR-9715) * added support for filter registrations in AbstractDispatcherServletInitializer (SPR-9696) * improved no-match handling for @RequestMapping methods (SPR-9603) * added support for matrix variables (SPR-5499, SPR-7818) * added support generic types in @RequestBody arguments (SPR-9570) * added support for generic types in the RestTemplate (SPR-7023) * added fix to decode target parameters prior to saving a FlashMap (SPR-9657) * now allowing an Errors argument after @RequestBody and @RequestPart (SPR-7114) * introduced @ControllerAdvice annotation (SPR-9112) * added exclude patterns for mapped interceptors (SPR-6570) * now ignoring parse errors in HttpPutFormContentFilter (SPR-9769) * optimized performance of HandlerMethod (SPR-9747, SPR-9748) * optimized performance of AntPathStringMatcher (SPR-9749) * added support for Filters/Servlet invocation in MockFilterChain (SPR-9745) Changes in version 3.2 M1 (2012-05-28) -------------------------------------- * upgrade to AspectJ 1.6.12, JUnit 4.10, TestNG 6.5.2 * Servlet 3.0-based async support * HttpMessageConverter and View types compatible with Jackson 2.0 * better handling on failure to parse invalid 'Content-Type' or 'Accept' headers * handle a controller method's return value based on the actual returned value (vs declared type) * fix issue with combining identical controller and method level request mapping paths * fix concurrency issue in AnnotationMethodHandlerExceptionResolver * fix case-sensitivity issue with some containers on access to 'Content-Disposition' header * fix issue with encoded params in UriComponentsBuilder * add pretty print option to Jackson HttpMessageConverter and View types * translate IOException from Jackson to HttpMessageNotReadableException * fix issue with resolving Errors controller method argument * implement InitializingBean in RequestMappingHandlerMapping to detect controller methods * fix content negotiation issue when sorting selected media types by quality value * prevent further writing to the response when @ResponseStatus contains a reason * deprecate HttpStatus codes 419, 420, 421 * support access to all URI vars via @PathVariable Map * add "excludedExceptions" property to SimpleUrlHandlerMapping * add CompositeRequestCondition for use with multiple custom request mapping conditions * add ability to configure custom MessageCodesResolver through the MVC Java config * add option in MappingJacksonJsonView for setting the Content-Length header * decode path variables when url decoding is turned off in AbstractHandlerMapping * add required flag to @RequestBody annotation * Jaxb2Marshaller performs proper "supports" check for scanned packages (SPR-9152) * add convenient WebAppInitializer base classes (SPR-9300) * support executor qualification with @Async#value (SPR-6847) * support initial delay attribute for scheduled tasks (SPR-7022) * cache by-type lookups in DefaultListableBeanFactory (SPR-6870) * merge rather than add URI vars to data binding values (SPR-9349) * support not (!) operator for profile selection (SPR-8728) * fix regression in ClassPathResource descriptions (SPR-9413) * improve documentation of @Bean 'lite' mode (SPR-9401) * improve documentation of annotated class support in the TestContext framework (SPR-9401) * document support for JSR-250 lifecycle annotations in the TestContext framework (SPR-4868) * improve dependency management for spring-test (SPR-8861) * fix MultipartResolver Resin compatibility (SPR-9299) * handle non-existent files in ServletContextResource (SPR-8461) * apply cache settings consistently in EhCacheFactoryBean (SPR-9392) * initial support for JCache (JSR-107) compliant cache providers (SPR-8774) Changes in version 3.1.1 (2012-02-16) ------------------------------------- * official support for Hibernate 4.0.0/4.0.1 as well as Hibernate 4.1 * JBossNativeJdbcExtractor is compatible with JBoss AS 7 as well * restored JBossLoadTimeWeaver compatibility with JBoss AS 5.1 * Provider injection works with generically typed collections of beans as well * @ActiveProfiles mechanism in test context framework works with @ImportResource as well * context:property-placeholder's "file-encoding" attribute value is being applied correctly * clarified Resource's "getFilename" method to return null if resource type does not have a filename * Resource "contentLength()" implementations work with OSGi bundle resources and JBoss VFS resources * PathMatchingResourcePatternResolver preserves caching for JNLP (Java Web Start) jar connections * optimized converter lookup in GenericConversionService to avoid contention in JDK proxy check * DataBinder correctly handles ParseException from Formatter for String->String case * CacheNamespaceHandler actually parses cache:annotation-driven's "key-generator" attribute * introduced CustomSQLExceptionTranslatorRegistry/Registrar for JDBC error code translation * officially deprecated TopLinkJpaDialect in favor of EclipseLink and Spring's EclipseLinkJpaDialect * fixed LocalContainerEntityManagerFactoryBean's "packagesToScan" to avoid additional provider scan * LocalContainerEntityManagerFactoryBean's "persistenceUnitName" applies to "packagesToScan" as well * DefaultPersistenceUnitManager uses containing jar as persistence unit root URL for default unit * added protected "isPersistenceUnitOverrideAllowed()" method to DefaultPersistenceUnitManager * Hibernate synchronization properly unbinds Session even in case of afterCompletion exception * Hibernate exception translation covers NonUniqueObjectException to DuplicateKeyException case * Hibernate 4 LocalSessionFactoryBean implements PersistenceExceptionTranslator interface as well * Hibernate 4 LocalSessionFactoryBean does not insist on a "dataSource" reference being set * added "entityInterceptor" property to Hibernate 4 LocalSessionFactoryBean * added "getConfiguration" accessor to Hibernate 4 LocalSessionFactoryBean * added "durability" and "description" properties to JobDetailFactoryBean * fixed QuartzJobBean and MethodInvokingJobDetailFactoryBean for compatibility with Quartz 2.0/2.1 * JMS CachingConnectionFactory never caches consumers for temporary queues and topics * JMS SimpleMessageListenerContainer silently falls back to lazy registration of consumers * added "receive-timeout" attribute to jms:listener-container element in JMS namespace * ServletServerHttpRequest/Response fall back on the Content-Type and encoding of the request * preserve quotes in MediaType parameters * added "normalize()" method to UriComponents * remove empty path segments from input to UriComponentsBuilder * added "fromRequestUri(request)" and "fromCurrentRequestUri()" methods to ServletUriComponentsBuilder * Servlet/PortletContextResource's "isReadable()" implementation returns false for directories * allow adding flash attributes in methods with a ModelAndView return value * make flash attributes available in the model of Parameterizable/UrlFilenameViewController * revised the FlashMapManager contract and implementation to address a flaw in its design * removed check for HTTP POST when resolving multipart request controller method arguments * fixed request mapping bug involving direct vs pattern path matches with HTTP methods * updated @RequestMapping and reference docs wrt differences between @MVC 3.1 and @MVC 2.5-3.0 * improved @SessionAttributes handling to provide better support for clustered sessions * added property to RedirectView to disable expanding URI variables in redirect URL Changes in version 3.1 GA (2011-12-12) -------------------------------------- * SmartLifecycle beans in Lifecycle dependency graphs are only being started when isAutoStartup=true * ConversionService is able to work with "Collections.emptyList()" as target type (again) * restored DataBinder's ability to bind to an auto-growing List with unknown element type * added SmartValidator interface with general support for validation hints * added custom @Validated annotation with support for JSR-303 validation groups * JSR-303 SpringValidatorAdapter and MVC data binding provide support for validation groups * restored SpringValidatorAdapter's ability to handle bean constraints with property paths * added MethodValidationInterceptor/PostProcessor for Hibernate Validator 4.2 based method validation * fixed QuartzJobBean to work with Quartz 2.0/2.1 as well * @Transactional qualifiers match against transaction manager definitions in parent contexts as well * optimized AnnotationTransactionAspect and AnnotationCacheAspect pointcuts to avoid runtime checks * renamed @CacheEvict's "afterInvocation" attribute to "beforeInvocation" (for better readability) * added "mappingResources" property to LocalContainerEntityManagerFactoryBean (pointing to orm.xml) * Hibernate 4.0 variant of HibernateTransactionManager properly works with Open Session in View now * JmsInvokerClientInterceptor/FactoryBean always uses createConnection/createSession when on JMS 1.1 * added out-of-the-box MappingJacksonMessageConverter impl for Spring's JMS MessageConverter facility * DispatcherServlet's "dispatchOptionsRequest" only sets the default 'Allow' header if actually needed * ResourceHttpRequestHandler sends content without content-type header if no media type found * ResourceHttpRequestHandler and ContentNegotiatingViewResolver use consistent mime type resolution * simplified support package layout in "web.method" and "web.servlet.mvc.method" * added "useTrailingSlashMatch" property to RequestMappingHandlerMapping * Portlet MVC annotation mapping allows for distributing action names across controllers * added String constants to MediaType Changes in version 3.1 RC2 (2011-11-28) --------------------------------------- * fixed OSGi manifest for spring-web bundle to not require Apache HttpComponents anymore * fixed GenericTypeResolver to consistently return null if not resolvable * added proper "contentLength()" implementation to ByteArrayResource * refined Resource "exists()" check for HTTP URLs to always return false for 404 status * LocaleEditor and StringToLocaleConverter do not restrict variant part through validation * LinkedCaseInsensitiveMap overrides putAll method as well (for IBM JDK 1.6 compatibility) * optimized DefaultListableBeanFactory's PropertyDescriptor caching for concurrent access * renamed ValueWrapperImpl to SimpleValueWrapper (for use in Cache implementations) * exposed EHCache 1.7's "statisticsEnabled"/"sampledStatisticsEnabled" on EhCacheFactoryBean * SpringValidatorAdapter accepts non-indexed set paths (for Hibernate Validator compatibility) * TransactionSynchronizationManager eagerly cleans up void ResourceHolders on any access * SimpleJdbcTestUtils executeSqlScript properly closes its LineNumberReader after use * JDO PersistenceManager synchronization performs close attempt after completion (if necessary) * JPA EntityManagerFactoryUtils silently ignores IllegalArgumentExceptions from setHint calls * fixed HibernateTransactionManager for Hibernate 4.0 to refer to correct openSession() method * added "namingStrategy" property to Hibernate 4 LocalSessionFactoryBean variant * HibernateJpaDialect does NOT expose underlying Session for underlying SessionFactory anymore * fixed MethodInvokingJobDetailFactoryBean's Quartz 2.0 support * added Quartz 2.1 compatibility while preserving Quartz 2.0 support * introduced JobDetail/CronTrigger/SimpleTriggerFactoryBean variants for Quartz 2.0/2.1 support * added "forwarder" property to ConnectorServerFactoryBean, accepting an MBeanServerForwarder * RmiClientInterceptor detects nested SocketException as connect failure as well * fixed StandardServlet/PortletEnvironment to check for JNDI (for Google App Engine compatibility) * Servlet/PortletContextResource's getFile prefers "file:" URL resolution over calling getRealPath * Portlet session mutex uses global session attribute to be shared among all portlets in the session * using original request URI in FlashMap matching logic to account for URL rewriting * now supporting target request with multiple parameter values in FlashMap matching logic * fixed issue in SimpleMappingExceptionResolver causing exception when setting "statusCodes" property * added ignoreDefaultModelOnRedirect attribute to * added methods to UriComponentsBuilder for replacing the path or the query * support UriComponentsBuilder as @Controller method argument * added ServletUriComponentsBuilder to build a UriComponents instance starting with a ServletRequest * fixed issue with cache ignoring prototype-scoped controllers in RequestMappingHandlerAdapter * fixed issue with setting Content-Length header depending on the charset of the response * fixed @RequestMapping header matching to correctly process negated header conditions * added getObjectMapper() accessor to MappingJacksonHttpMessageConverter * AbstractCachingViewResolver caches unresolved view names by default ("cacheUnresolved"=true) * form input tag now allows type values other than "text" such as HTML5-specific types * form hidden tag now supports "disabled" attribute * fixed "formMultiSelect"/"formCheckboxes" FreeMarker macros to compare against actual field value * MockHttpServletRequest/Response now keep contentType field and Content-Type header in sync * updated Spring MVC configuration section to include MVC Java config and the MVC namespace Changes in version 3.1 RC1 (2011-10-11) --------------------------------------- * upgraded to JUnit 4.9 * updated Quartz support package for Quartz 2.0 compatibility * support for load-time weaving on WebSphere 7 and 8 * updated JBossLoadTimeWeaver to automatically detect and support JBoss AS 7 as well * added support for Hibernate 4.0 (HibernateJpaDialect as well as natively in orm.hibernate4) * added 'destroy method inference' (SPR-8751) * prepared Spring's DataSource and RowSet adapters for forward compatibility with JDBC 4.1 * introduced ForkJoinPoolFactoryBean for Java 7 (alternative: add new jsr166.jar to Java 6) * introduced extended WritableResource interface * ConversionService prevents Converter from trying to convert to a subtype of its actual target type * CollectionCollection/MapToMapConverter preserve original Collection/Map if no converted elements * DefaultListableBeanFactory is only deserializable through a SerializedBeanFactoryReference * DefaultListableBeanFactory's getBean(name, type) attempts type conversion if necessary * DefaultListableBeanFactory allows for init methods to register further bean definitions (again) * XmlBeanDefinitionReader accepts description subelement within map entry as well (as per the XSD) * ConfigurationClassPostProcessor supports use of same processor instance with several factories * SpringBeanAutowiringSupport is able to process @Value annotations on any given target instance * introduced @EnableAspectJAutoProxy * overridden @PersistenceContext annotations on subclass methods are being processed correctly * DataBinder uses a default limit of 256 for array/collection auto-growing * added "autoGrowNestedPaths" property to ConfigurableWebBindingInitializer * added "getMultipartContentType(String)" method to MultipartRequest interface * added headers support to MultipartFile abstraction (actually supported on Servlet 3.0) * revised Servlet 3.0 based StandardServletMultipartResolver for correct param/file distinction * MultipartFilter uses a Servlet 3.0 based StandardServletMultipartResolver by default * added RequestPartServletServerHttpRequest and corresponding @RequestPart support in Spring MVC * added "connectTimeout" and "readTimeout" properties to Simple/CommonsClientHttpRequestFactory * added flash attribute support through FlashMap and FlashMapManager abstractions * added RedirectAttributes abstraction as supported method argument type of @RequestMapping methods * added "ignoreDefaultModelOnRedirect" flag to RequestMappingHandlerAdapter * fixed @ExceptionHandler exception type matching (ExceptionDepthComparator) * ResourceHttpRequestHandler detects invalid directory traversal in given path * HtmlUtils properly escapes single quotes as well * Spring JSP tags do not use their own expression support on Servlet 3.0 containers by default * added support for web.xml context-param "springJspExpressionSupport" (explicit "true"/"false") * ContextLoader and FrameworkServlet support "contextId" parameter for custom serialization id * added "acceptProxyClasses" flag to RemoteInvocationSerializingExporter * refined WebLogic RMI descriptor to only mark 'getTargetInterfaceName' method as idempotent * revised JMS CachedConnectionFactory to avoid unnecessary rollback calls on Session return * fixed JMS CachedConnectionFactory to fully synchronize its Session list * JpaTransactionManager etc can find EntityManagerFactory by "persistenceUnitName" property now * HibernateJpaDialect exposes underlying Session for underlying SessionFactory * deprecated JpaTemplate/JpaInterceptor/JpaDaoSupport and JdoTemplate/JdoInterceptor/JdoDaoSupport * updated H2 error codes in sql-error-codes.xml * fixed NamedParameterJdbcTemplate to use correct maximum type for queryForInt/Long * jdbc:script's "separator" and "execution" attributes work nested with embedded-database as well * added "encoding" attribute to jdbc:script element * JavaMailSenderImpl detects and respects "mail.transport.protocol" property in existing Session * added ConcurrentMapCacheManager, dynamically building ConcurrentMapCache instances at runtime * added "disabled" property to EhCacheFactoryBean * introduced generic invokeMethod() in ReflectionTestUtils * introduced DelegatingSmartContextLoader as new default ContextLoader for TestContext framework * deprecated @ExpectedException * AnnotationConfigContextLoader now detects default configuration classes within test classes * TestContext now uses MergedContextConfiguration for the ContextCache key * extended Servlet API mocks for Servlet 3.0 forward compatibility as far as possible * made MockHttpServletResponse compatible with Servlet 3.0 getHeader(s) method returning Strings * added getHeaderValue(s) method to MockHttpServletResponse for raw value access Changes in version 3.1 M2 (2011-06-08) -------------------------------------- * revised TypeDescriptor signature and implementation for clearer handling of nested generics * full support for arbitrary nesting of collections in fields * proper type detection in nested collections within arrays * collection/array conversion returns original collection if possible (instead of first element) * AnnotatedBeanDefinitionReader now inherits Environment of supplied BeanDefinitionRegistry * eliminated @Feature support in favor of @Enable* and framework-provided @Configuration classes * introduced @EnableTransactionManagement, @EnableScheduling, etc * add Java config alternative to MVC namespace via @EnableWebMvc annotation * introduce HandlerMethod abstraction selecting and invoking @RequestMapping methods * add HandlerMethod-based implementations of HandlerMapping, HandlerAdapter, HandlerExceptionResolver * merge @PathVariables in the model before rendering except for JSON/XML serialization/marshalling. * use @PathVariables in addition to request parameters in data binding * support URI variable placeholders in "redirect:" prefixed view names * add flag to extract value from single-key model in MappingJacksonJsonView * support @Valid on @RequestBody method arguments * allow bean references in mvc:interceptor namespace elements * consolidate initialization and use of MappedInterceptors in AbstractHandlerMapping * added Servlet 3.0 based WebApplicationInitializer mechanism for programmatic bootstrapping * added Servlet 3.0 based StandardServletMultipartResolver * added "packagesToScan" feature to LocalContainerEntityManagerFactoryBean (avoiding persistence.xml) * fixed JPA 2.0 timeout hints to correctly specify milliseconds * added support for shutdown scripts to DataSourceInitializer (see "databaseCleaner" property) * added "separator" and "execution" attributes to jdbc:script element * revised cache abstraction to focus on minimal atomic access operations * updated Quartz package to support Quartz 1.8 as well (note: not fully supporting Quartz 2.0 yet) * RemoteExporter uses an opaque proxy for 'serviceInterface' (no AOP interfaces exposed) * introduced AnnotationConfigContextLoader to provide TestContext support for @Configuration classes * introduced @ActiveProfiles for declarative configuration of bean definition profiles in tests * TestContext generates context cache key based on all applicable configuration metadata * deprecated AbstractJUnit38SpringContextTests and AbstractTransactionalJUnit38SpringContextTests Changes in version 3.1 M1 (2011-02-11) -------------------------------------- * upgraded to JUnit 4.8.1 and TestNG 5.12.1 * fixed aspects bundle to declare dependencies for @Async aspect as well * introduced Environment abstraction with flexible placeholder resolution * introduced support for environment profiles in XML bean definition files * introduced @Profile annotation for configuration classes and individual component classes * introduced PropertySourcesPlaceholderConfigurer as alternative to PropertyPlaceholderConfigurer * introduced "c:" namespace for constructor argument shortcuts (analogous to the "p:" namespace) * introduced @FeatureConfiguration classes with @Feature methods that return FeatureSpecifications * added TxAnnotationDriven, MvcAnnotationDriven, etc. as out-of-the-box FeatureSpecifications * introduced caching abstraction and cache annotation support * moved EhCache FactoryBeans from context-support to context module * EhCacheManagerFactoryBean properly closes "ehcache.xml" input stream, if any * exceptions thrown by @Scheduled methods will be propagated to a registered ErrorHandler * ProxyCreationContext uses "ThreadLocal.remove()" over "ThreadLocal.set(null)" as well * BeanDefinitionVisitor now actually visits factory method names * fixed potential InjectionMetadata NPE when using SpringBeanAutowiringInterceptor * fixed AbstractBindingResult to avoid NPE in "hashCode()" if target is null * Servlet/PortletRequestDataBinder perform unwrapping for MultipartRequest as well * ResourceHttpRequestHandler does not set Content-Length header for 304 response * LocaleChangeInterceptor validates locale values in order to prevent XSS vulnerability Changes in version 3.0.5 (2010-10-20) ------------------------------------- * support for Hibernate 3.6 final * added core serializer abstraction with default implementations using Java Serialization * consistent use of JDK 1.5's "ThreadLocal.remove()" over "ThreadLocal.set(null)" * fixed JodaTimeContextHolder to use a non-inheritable ThreadLocal and expose a reset method * revised "ClassUtils.isAssignable" semantics to cover primitives vs wrappers in both directions * optimized AnnotationUtils findAnnotation performance for repeated search on same interfaces * ConversionService protects itself against infinite recursion in ObjectToCollectionConverter * fixed TypeDescriptor to correctly resolve nested collections and their element types * BeanWrapper does not attempt to populate Map values on access (just auto-grows Map itself) * fixed Autowired/CommonAnnotationBeanPostProcessor to prevent race condition in skipping check * fixed @Value injection to correctly cache temporary null results for non-singleton beans * ApplicationContext registers context-specific ClassArrayEditor for its bean ClassLoader * refined ApplicationContext singleton processing to not fail for manually registered null instances * fixed ApplicationContext event processing for repeated invocations to non-singleton listener beans * optimized @Bean error messages for static factory methods as well as for argument type mismatches * modified expression parsing to pass full TypeDescriptor context through to ConversionService calls * adapted expression parser's Constructor/MethodResolver to accept TypeDescriptors instead of raw types * SpEL supports projection on any kind of Collection (not just on Lists and arrays) * SpEL MapAccessor consistently rejects "target.key" style access to Maps if no such key is found * SpEL method invocations prefer method with fewest parameters (e.g. no-arg over vararg) * AspectJExpressionPointcut uses bean ClassLoader for initializing the AspectJ pointcut parser * added AnnotationAsyncExecutionAspect as AspectJ-based variant of @Async processing * added mode="proxy"/"aspectj" and proxy-target-class options to task:annotation-driven * JDBC bundle uses local ClassLoader as bean ClassLoader for "sql-error-codes.xml" parsing * EmbeddedDatabaseFactory shuts down database when failing to populate it in "initDatabase()" * embedded database support now also works with Derby >= 10.6 * "jdbc:embedded-database" uses id as database name to allow multiple ones in parallel * ResourceDatabasePopulator throws descriptive ScriptStatementFailedException with resource details * added configurable Connection/Statement/ResultSet target types to Jdbc4NativeJdbcExtractor * added OracleJdbc4NativeJdbcExtractor with pre-configured Oracle JDBC API types * DefaultLobHandler's "wrapAsLob" mode works with PostgreSQL's "getAsciiStream()" requirement * ResultSetWrappingSqlRowSet (as used by JdbcTemplate's "queryForRowSet") supports column labels now * LocalSessionFactoryBean's "entityCacheStrategies" works with region names on Hibernate 3.6 as well * fixed DefaultMessageListenerContainer's no-message-received commit to work without Session caching * DefaultMessageListenerContainer's skips no-message-received commit on Tibco (avoiding a deadlock) * JaxWsPortClientInterceptor does not fall back to annotation-specified name as portName anymore * UriTemplate is serializable now * fixed AnnotationMethodHandlerAdapter's caching to avoid concurrency issues in RequestMappingInfo * fixed @MVC processing of parameter-level annotations to work with interface-based proxies again * revised @RequestParam processing to support CSV-to-array/collection binding with ConversionService * fixed EvalTag's EvaluationContext caching to properly handle JSP tag caching across requests * AbstractJasperReportsView only sets locale model attributes if not present already * DispatcherPortlet throws custom NoHandlerFoundException instead of misleading UnavailableException * DispatcherPortlet copies all action parameters to render parameters in case of an action exception * DispatcherPortlet's default resource serving explicitly prevents access to WEB-INF and META-INF * Portlet @ExceptionHandler methods allow for writing the response directly (like in the Servlet case) * MockHttpServletRequest/HttpSession/etc returns independent Enumeration from "getAttributeNames()" Changes in version 3.0.4 (2010-08-19) ------------------------------------- * support for Hibernate Core 3.6, Hibernate Validator 4.1, EclipseLink 2.1, EHCache 2.2 * OSGi manifest version range accepts EHCache 2.x as well * added "contentLength()" method to Resource abstraction * URL-based Resource variants introspect "last-modified" and "content-length" response headers * refined "exists()" check for UrlResource (HEAD request) and ClassPathResource (URL resolution) * ConversionService is able to deal with empty collections and nested collections (fixed regression) * ConversionService properly handles nested Resource arrays in Map values (fixed regression) * ConversionService does not accidentally use copy constructor for same type * fixed double ConversionFailedException nesting for ObjectToObjectConverter invocations * BeanWrapper preserves annotation information for individual array/list/map elements * Spring's constructor resolution consistently finds non-public multi-arg constructors * revised constructor argument caching, avoiding a race condition for converted argument values * SpEL passes full collection type context (generics, annotations) to ConversionService * SpEL 'select last' operator now works consistently with maps * BeanWrapper/DataBinder's "autoGrowNestedPaths" works for Maps as well * fixed concurrency issue in TypedStringValue, showing for nested typed Maps in prototype beans * fixed WeakReferenceMonitor to never stop its monitoring thread if an entry has been registered * fixed CronTrigger to correctly parse month parts expressed as numbers (1-12 instead of 0-11) * TaskExecutorFactoryBean (as used by task:executor) exposes full ThreadPoolTaskExecutor type * JmsResourceHolder does not ignore IllegalStateException from locally synchronized transaction * fixed JMS CachingConnectionFactory to correctly cache a producer without fixed destination as well * DefaultMessageListenerContainer triggers Session commit even if no message has been received * DefaultMessageListenerContainer supports client id setting even for non-shared Connections * Spring's MessageEndpointFactory classes are now JCA 1.6 compliant as well * AbstractJaxWsServiceExporter supports "bindingType" bean property, overriding @BindingType * AbstractJaxWsServiceExporter supports "webServiceFeatures" bean property on JAX-WS 2.2 * JaxWsPortProxyFactoryBean takes "wsdlDocumentUrl", "namespaceUri" etc defaults from @WebService * Jaxb2Marshaller's "marshallerProperties" Map accepts any value type * SpringTemplateLoader for FreeMarker supports last-modified timestamp through Resource abstraction * HibernateJpaDialect correctly closes borrowed connections even for nested JDBC executions * DefaultJdoDialect supports JDO 3.0 query timeout facility (as supported by DataNucleus 2.1) * transaction names based on method id from most specific method (target class instead of interface) * added "validationMessageSource" to LocalValidatorFactoryBean, for Spring-based validation messages * Spring field error arguments include actually declared annotation attributes in alphabetical order * JSR-303 Pattern message resolvable through Spring MessageSource (despite special characters) * DispatcherServlet applies default view name translation to error views as well * mvc:annotation-driven reliably detects JSR-303 and JAXB2 in an OSGi environment as well * revised @MVC handler method resolution with respect to handler methods on generic interfaces * @MVC handler methods reliably resolve MultipartRequest arguments with HiddenHttpMethodFilter * WebDataBinder and @MVC request params detect and introspect MultipartFile arrays as well * fixed @PathVariable regression in combination with ConversionService usage on DataBinder * @CookieValue returns decoded cookie value in a Servlet environment (analogous to @RequestParam) * MVC HandlerExceptionResolvers prevent caching for exception views if preventResponseCaching=true * @ExceptionHandler works for inherited method and CGLIB proxies on Portlet controllers as well * Portlet @MVC's implicit render model will be updated at the end of the event phase * Portlet AbstractController consistently uses session mutex if "synchronizeOnSession" is active * PortletWrappingController supports Portlet 2.0 resource and event requests as well * fixed JSP EvalTag to render null result as empty String instead of "null" String * JSP EvalTag resolves "@myBeanName" references in expressions against the WebApplicationContext * added support for static resource serving: ResourceHttpRequestHandler, mvc:resources * revised DispatcherServlet's last-modified handling to properly work with scoped controllers * MockMultipartHttpServletRequest pre-defines method "POST" and content type "multipart/form-data" Changes in version 3.0.3 (2010-06-15) ------------------------------------- * Spring autodetects JodaTime 1.3 or higher (as required), ignoring older JodaTime versions * clarified that Spring's Jackson support requires Jackson 1.3 or higher * JPA 2.0 support tested and supported with Hibernate 3.5.2 and OpenJPA 2.0.0 GA as well * revised VFS support for Spring's component scanning to work on JBoss AS 6.0.0 M3 as well * fixed URIEditor's URI construction to consider fragment as well * added default InputSourceEditor for SAX InputSource construction with a URL String as system id * CachedIntrospectionResults only caches GenericTypeAwarePropertyDescriptors if fully safe * revised BeanWrapper's exception wrapping to consistently handle ConversionExceptions * DefaultListableBeanFactory checks for alias circle on registerAlias (avoiding endless loop) * ConversionService is able to apply Converters to interface-based array elements * ConversionService fully supports conversion from String to MediaType now (through 'valueOf') * revised exception handling in ObjectToObjectConverter, avoiding InvocationTargetExceptions * a context ConversionService is able to override an ApplicationContext's resource editors * refined LifecycleProcessor exception handling, properly wrapping a start exception from a bean * revised DefaultLifecycleProcessor's handling of circular dependencies to avoid stack overflow * fixed constructor argument caching for prototypes with multiple constructor matches * specific detection of CGLIB subclasses in order to properly handle CGLIB interfaces * registerDependentBean resolves to the canonical bean name in order to handle alias references * fixed registerResolvableDependency mechanism to correctly handle non-serializable factory objects * added "expose-proxy" attribute to aop namespace (enforcing AopContext proxy exposure with CGLIB) * revised AbstractInterceptorDrivenBeanDefinitionDecorator for further alignment with auto-proxying * BeanDefinitionVisitor/PropertyPlaceholderConfigurer finds and resolves values in arrays as well * property placeholders can deal with nested expressions which happen to use the same suffix * SpEL's Elvis operator is able to deal with #{${myProp}?:defaultValue} case if myProp is empty * introduced EmbeddedValueResolverAware callback interface for convenient placeholder resolution * @Transactional qualifier value matches against @Qualifier annotations on @Bean methods as well * setTransactionIsolation on JDBC Connection only called when actually necessary (for PostgreSQL) * added limit for parsed SQL cache to NamedParameterJdbcTemplate (default is 256; configurable) * CachingConnectionFactory detects destination equality for WebSphere MQ as well (using toString) * DefaultPersistenceUnitManager's getPersistenceUnitInfo method has 2.5 compatible signature again * DefaultMessageListenerContainer reacts to maxConcurrentConsumers reduction for long-lived tasks * added "idleConsumerLimit" bean property to DefaultMessageListenerContainer (default is 1) * AsyncAnnotationBeanPostProcessor consistently adds @Async processing as first Advisor in the chain * ScheduledTaskRegistrar (as used for @Scheduled processing) properly shuts down its default executor * CronTrigger defensively protects itself against accidental re-fires if a task runs too early * MailSendException includes all messages as failed messages in case of a connect failure * added support for JAX-WS 2.1 WebServiceFeatures to JaxWsPortClientInterceptor/PortProxyFactoryBean * added XmlAwareFormHttpMessageConverter, taking over the 3.0.2-introduced XML multipart support * ServletContextResourcePatternResolver handles "/WEB-INF/lib/*.jar!/**/context.xml" style patterns * fixed MVC mapping regression for servlet url-pattern "/" case on servers other than WebSphere * MVC mappings properly apply even to welcome file entries that forward to a DispatcherServlet * fixed @ExceptionHandler resolution in case of multiple matches at different inheritance levels * revised Portlet SessionStatus.setComplete() to avoid re-exposure of attributes in render phase * shortened Portlet MVC's implicit model render parameter name to "implicitModel" * added convenient "checkRefresh" bean property to TilesConfigurer * TilesConfigurer's "definitionsFactoryClass" property applies common Tiles DefinitionsFactory setup * JSP FormTag calculates proper default form action even when using a rewrite filter on WebSphere * JSP HiddenInputTag allows for using common HTML attributes (equivalent to LabelTag) * fixed JSP ErrorsTag to avoid invalid "*.errors" id, using form object name as id prefix instead * fixed JSP SelectTag's support for rendering enum constants * JSP Radiobutton/CheckboxesTag utilizes PropertyEditor/ConversionService for label rendering * MockHttpServletResponse supports multiple includes Changes in version 3.0.2 (2010-04-02) ------------------------------------- * 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 Changes in version 3.0.1 (2010-02-18) ------------------------------------- * upgraded to AspectJ 1.6.8 * full support for JPA 2.0 persistence schema and PersistenceUnitInfo SPI * support for JPA PersistenceContext/Unit injection on Google App Engine * support for Hibernate 3.5 (as native Hibernate API and as JPA 2.0 provider) * support for Tiles 2.2.1 (preserving compatibility with Tiles 2.1.2 and above) * consistent treatment of unresolvable placeholders for Resource and Resource array properties * ConversionFailedException exDLBFposes offending value through public "getValue()" method * fixed BeanFactory's "getBeansWithAnnotation" to ignore beans with non-determinable type * widened FactoryBean's "getObjectType" signature to return any Class (Class) * do not ever consider Object as a candidate type for autowiring by type (autowire="byType") * BeanDefinitionReader and ClassPath/FileSystemXmlApplicationContext use varargs where possible * introduced BeanDefinitionRegistryPostProcessor extension to BeanFactoryPostProcessor * @Configuration classes support definition of BeanFactoryPostProcessor beans * component-scan's scoped-proxy attribute applies to scope-annotated singleton beans as well * generic ApplicationListener event type gets detected through AOP proxy as well * ApplicationListeners will only be executed once per event (even for scripted objects) * ApplicationListeners will get detected lazily as well (e.g. on @Bean's concrete result) * inner bean ApplicationListeners will be invoked through their proxy (if any) * fixed SimpleApplicationEventMulticaster's retriever caching to allow for proper removal * context-specific "conversionService" bean may refer to annotation-configured converter beans * refined DefaultLifecycleProcessor's start/stop logging and stop exception handling * DefaultLifecycleProcessor allows for overriding specific hooks in subclasses * BeanNameAutoProxyCreator detects alias matches for specified bean names * proxies with AspectJ pointcuts are fully serializable within a BeanFactory now * SharedEntityManagerCreator's EntityManager proxies are fully serializable now * Query call chaining works with shared EntityManager proxy outside of transaction as well * TransactionInterceptor is able to serialize "transactionManagerBeanName" as well * non-matching @Transactional qualifier value will lead to IllegalStateException * fixed WebSphereUowTransactionManager regression: correctly roll back in case of exception * JndiObjectFactoryBean explicitly only chooses public interfaces as default proxy interfaces * added vararg variants of query methods to JdbcTemplate (as known from SimpleJdbcTemplate) * MBeanClientInterceptor/MBeanProxyFactoryBean understands CompositeData/TabularData arrays * added "workManagerMBeanName" property to JBossWorkManagerTaskExecutor * task:executor's id value is now used as thread name prefix of ThreadPoolTaskExecutor * fixed @Scheduled processing to kick in once only even in an ApplicationContext hierarchy * fixed MediaType's Comparable behavior to do a full comparison, aligned with equals behavior * added "sortBySpecificity" method to MediaType, for typical use with accept header matching * MimeMessageHelper encodes from, to, cc, bcc String addresses with given encoding as well * changed HttpStatus.REQUEST_TOO_LONG constant to REQUEST_ENTITY_TOO_LARGE * relaxed generic Class declaration in HttpMessageConverter's canRead/canWrite/read signatures * fixed "mvc:view-controller" to work in a fully isolated fashion on Spring Dynamic Modules * DefaultRequestToViewNameTranslator strips trailing slashes as well (can also be turned off) * @RequestParam/RequestHeader/CookieValue's defaultValue allows for declaring empty String * @SessionAttributes works when used on an annotated controller interface with AOP proxying * WebRequest is a resolvable dependency in Servlet/Portlet web application contexts * revised JSP-based views to never fail when trying to set Servlet API forward attributes * lenient evaluation of boolean 'true' attribute expressions in JSP form tag library * added new spring:eval tag for evaluating SpEL expressions from JSP pages * SpringBeanAutowiringSupport works in extra ClassLoaders as well (e.g. WebLogic JAX-WS) Changes in version 3.0.0.GA (2009-12-16) ---------------------------------------- * component scanning autodetects the new EE 6 "javax.annotation.ManagedBean" stereotype * updated JPA 2.0 support to the final spec (tested compatibility with EclipseLink 2.0 GA) * full support for GlassFish V3 GA (includes component scanning and load-time weaving) * upgraded to JRuby 1.4 (while remaining compatible with JRuby 1.1 and above) * bean property names are matched leniently ("title" and "Title"; "ISBN" and "iSBN") * bean properties of type enum array/collection can be populated with comma-separated String * removed getBeansWithAnnotation(Class,boolean,boolean) method from ListableBeanFactory * PropertyPlaceholderConfigurer is compatible with Spring 2.5 extensions (again) * SmartLifecycle beans will get auto-started on demand even if marked as lazy-init * MBeanExporter detects FactoryBean-exported resources independent from declaration order * refactored SpelExpressionParser to accept SpelParserConfiguration object with boolean flags * revised TypeDescriptor's valueOf and forObject factory methods with some level of caching * revised GenericConverter's "getConvertibleTypes" signature to return Set of ConvertiblePair * GenericConversionService prefers matches against inherited interfaces over superclasses * renamed ConverterRegistry's addGenericConverter(GenericConverter) method to addConverter * no default converters for Object-to-Map and Map-To-Object anymore * default converter for String-to-Properties parsing only applies for actual Properties objects * default ObjectToStringConverter only stringifies objects that indicate proper toString behavior * added "converters" property to FormattingConversionServiceFactoryBean as well * full support for formatters and formatting annotations on array/collection elements * no default number formatter (relying on plain java.lang.Number parsing and rendering) * no default formatters for Date/Calendar (requiring explicit use of @DateTimeFormat) * BeanValidationPostProcessor runs in before-initialization phase (before init methods) by default * removed MultipartRequest mixin interface again (avoiding a package dependency cycle) * revised RestTemplate method signatures to accept Object values instead of just Strings * revised path variable extraction to properly deal with dots in variable values (again) * reintroduced createBinder template method in Servlet/Portlet AnnotationMethodHandlerAdapter Changes in version 3.0.0.RC3 (2009-12-01) ----------------------------------------- * prepared for Grails and ROO requirements * restored compatibility with Apache CXF * fixed bean definition import via "classpath*:" URLs * added chaining-capable "add" method to MutablePropertyValues * constructor arguments can be overridden by name in child bean definitions * BeanDefinitions return isSingleton()=true by default again, with scope name empty * init/destroy methods get processed in the order of declaration at each hierarchy level * fixed lookup of LifecycleProcessor bean in a Spring Dynamic Modules environment * refined lifecycle processing through introduction of startup/shutdown phases * fixed transaction synchronization setup with TransactionAwareDataSourceProxy involved * added support for Hibernate 3.3 RegionFactory cache SPI to LocalSessionFactoryBean * JSR-303 SpringValidatorAdapter uses field name as first argument (analogous to bind errors) * replaced DefaultConversionService with ConversionServiceFactory(Bean) * revised FormatterRegistry interface and FormattingConversionServiceFactoryBean setup * mvc:annotation-driven exposes default Validator and ConversionService as top-level beans * mvc:annotation-driven registers applicable HttpMessageConverters by default, if available * added interceptors support to mvc namespace, for path-based interceptor mappings Changes in version 3.0.0.RC2 (2009-11-13) ----------------------------------------- * 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) Changes in version 3.0.0.RC1 (2009-09-25) ----------------------------------------- * upgraded to CGLIB 2.2, AspectJ 1.6.5, Groovy 1.6.3, EHCache 1.6.2, JUnit 4.7, TestNG 5.10 * introduced early support for JSR-330 "javax.inject" annotations (for autowiring) * introduced early support for JSR-303 Bean Validation (setup and MVC integration) * added default editors for "java.util.Currency" and "java.util.TimeZone" * refined PathMatchingResourcePatternResolver's treatment of non-readable directories * PathMatchingResourcePatternResolver understands VFS resources (i.e. works on JBoss 5.x) * revised AccessControlContext access from BeanFactory * AbstractBeanDefinitionParser can deal with null return value as well * PropertyOverrideConfigurer's "ignoreInvalidKeys" ignores invalid property names as well * PropertyPlaceholderConfigurer supports "${myKey:myDefaultValue}" defaulting syntax * BeanFactory's default type conversion falls back to String constructor on target type * BeanFactory tries to create unknown collection implementation types via default constructor * BeanFactory supports ObjectFactory as a dependency type for @Autowired and @Value * BeanFactory supports JSR-330 Provider interface as a dependency type for @Inject * BeanFactory prefers local primary bean to primary bean in parent factory * protected @Autowired method can be overridden with non-annotated method to suppress injection * private @Autowired methods with same signature will be called individually across a hierarchy * @PostConstruct processed top-down (base class first); @PreDestroy bottom-up (subclass first) * ConfigurationClassPostProcessor detect @Bean methods on registered plain bean classes as well * support for default "conversionService" bean in an ApplicationContext * MBeanServerFactoryBean returns JDK 1.5 platform MBeanServer for agent id "" (empty String) * changed NamedParameter/SimpleJdbcOperations parameter signatures to accept any Map value type * refined logging in JMS SingleConnectionFactory and DefaultMessageListenerContainer * introduced "ui.format" package as an alternative to PropertyEditors for data binding * @RequestMapping annotation now supported for annotated interfaces (and JDK proxies) as well * @RequestParam and co support placeholders and expressions in their defaultValue attributes * @Value expressions supported as MVC handler method arguments as well (against request scope) * JSR-303 support for validation of @MVC handler method arguments driven by @Valid annotations * refined response handling for @ExceptionHandler methods * @ResponseStatus usage in handler methods detected by RedirectView * all @SessionAttributes get exposed to the model before handler method execution * @Event/ResourceMapping uniquely mapped to through event/resource id, even across controllers * MultipartRequest is available as a mixin interface on (Native)WebRequest as well * removed outdated "cacheJspExpressions" feature from ExpressionEvaluationUtils * introduced common ErrorHandler strategy, supported by message listener container * Jpa/JdoTransactionManager passes resolved timeout into Jpa/JdoDialect's beginTransaction * HibernateJpaDialect applies timeout onto native Hibernate Transaction before begin call * Spring's Hibernate support is now compatible with Hibernate 3.5 beta 1 as well * Spring's JPA support is now fully compatible with JPA 2.0 as in EclipseLink 2.0.0.M7 * SpringJUnit4ClassRunner is now compatible with JUnit 4.5, 4.6, and 4.7 * SpringJUnit4ClassRunner once again supports collective timeouts for repeated tests * deprecated @NotTransactional annotation for test classes in favor of @BeforeTransaction Changes in version 3.0.0.M4 (2009-08-10) ---------------------------------------- * upgraded to JUnit 4.6, TestNG 5.9, and EasyMock 2.5.1 * updated all Spring Framework OSGI manifests to list unversioned imports explicitly * relaxed several OSGi bundle dependencies (optional, extended version ranges) * revised Java 6 checks to test for the presence of specific Java 6 interfaces/classes only * replaced Commons Collections dependency with Spring-provided LinkedCaseInsensitiveMap * case-insensitive Maps and key Sets preserve original casing for introspection/logging * constructor argument type matching supports arrays and simple class names now * XML constructor-arg element allows for specifying a constructor argument by name now * XML import elements with relative resource patterns are supported as well now * introduced non-lenient constructor resolution mode for BeanDefinitions (for RFC-124) * revised DefaultListableBeanFactory's access control when running within a SecurityManager * BeanWrapper and DefaultListableBeanFactory accept a custom ConversionService now * DefaultListableBeanFactory references are serializable now when initialized with an id * scoped proxies are serializable now, for web scopes as well as for singleton beans * injected request/session references are serializable proxies for the current request now * Servlet/Portlet ApplicationContexts use a specific id based on servlet/portlet name * ReloadableResourceBundleMessageSource correctly calculates filenames for all locales now * @PostConstruct works for multiple private init methods of the same name in a hierarchy * @Primary/@Lazy/@DependsOn supported as meta-annotations as well * @Bean/@Scope etc supported as meta-annotations on factory methods as well now * @Required does not get processed on beans returned by @Bean factory methods * @Import detects and accepts existing configuration class of the desired type * @Transactional supports qualifier value for choosing between multiple transaction managers * WebSphereUowTransactionManager falls back to UOWManagerFactory lookup by default * JMS SingleConnectionFactory performs start call within connection monitor (for Oracle AQ) * @ManagedResource is marked as inherited now, for generic management-aware base classes * introduced dedicated @ManagedMetric annotation for metric attributes in a JMX environment * added task namespace with scheduler/executor configuration and scheduled task definitions * added jdbc namespace with embedded-database tag (supporting HSQL, H2, and Derby) * Hibernate AnnotationSessionFactoryBean detects Hibernate's special @Entity annotation too * added SimpleJaxWsServiceExporter workaround for WebLogic 10.3's address format requirements * added support for @WebServiceProvider annotation to Spring's JaxWsServiceExporters * updated Hessian support for Hessian 3.2 compatibility (requiring Hessian 3.2 or above now) * updated Tiles support for Tiles 2.1 compatibility (requiring Tiles 2.1.2 or above now) * Velocity/FreeMarker/TilesViewResolver only returns a view if the target resource exists now * @DirtiesContext is now supported at the test class level with configurable class modes * added beforeTestClass() and afterTestClass() to the TestExecutionListener API * ProfileValueUtils now enforces class-level overrides for @IfProfileValue * @ContextConfiguration's loader attribute is now inherited if not declared locally * TransactionalTestExecutionListener no longer flushes transactions before rolling back Changes in version 3.0.0.M3 (2009-05-06) ---------------------------------------- * Spring 3.0 includes reference documentation now * Spring 3.0 is shipping with proper Maven POMs now * updated to JRuby 1.2 (remaining compatible with JRuby 1.1 and above) * updated to Hessian 3.2.1 (remaining compatible with Hessian 3.1.3 and above) * updated to FreeMarker 2.3.15 (for exposure of FreeMarkerServlet-style HTTP scopes) * removed Axis 1.x support package, keeping basic JAX-RPC support only (next to JAX-WS) * introduced explicit XML array element in spring-beans-3.0.xsd * introduced new type conversion SPI and converter API in spring-core convert package * introduced annotated @Bean factory methods and JavaConfig-style @Configuration classes * introduced @Primary, @Lazy and @DependsOn annotations for scanned components * custom stereotype annotations can be meta-annotated with @Service, @Controller etc as well * @Scope and @Transactional are now supported as meta-annotations on custom annotations * @Autowired uses field/parameter name as fallback qualifier value * qualifier annotations can be used at method level as well (applying to all parameters) * @Value annotation can be used at method level as well (e.g. on bean property setters) * @Value values may use ${...} placeholders (driven by PropertyPlaceholderConfigurer) * @Resource names may use ${...} placeholders (driven by PropertyPlaceholderConfigurer) * fixed EL evaluation of prepared constructor arguments for repeated prototype creation * ConstructorArgumentValues exposed indexed arguments in the order of definition * AutowiredAnnotationBeanPostProcessor calculates cached arguments in a synchronized block * declarative destroy-method="..." specifications get validated at bean creation time * component-scan's "base-package" attribute supports spaces as separators as well * CachedIntrospectionResults always caches bean classes except in case of custom BeanInfo * GenericTypeResolver's type variable cache uses weak values (for OSGi compatibility) * fixed CachingMapDecorator to support garbage-collected weak references (again) * AOP ProxyFactory excludes non-public interfaces when autodetecting proxy interfaces * added DuplicateKeyException to DAO exception hierachy * added EmbeddedDatabase support in spring-jdbc embedded package, with initial HSQL support * SessionAwareMessageListener supports generic declaration of concrete JMS Message type * RmiServiceExporter and RmiRegistryFactoryBean synchronize registry lookup/creation * added "unregisterManagedResource" method to MBeanExporter/MBeanExportOperations * TimerTaskExecutor creates non-daemon Timer and uses bean name as default Timer name * added TaskScheduler interface and Trigger abstraction * added ConcurrentTaskScheduler and ThreadPoolTaskScheduler * added CommonJ TimerManagerTaskScheduler * added CronTrigger implementation for cron expression support * renamed "contextProperties" attribute to "contextParameters" (matching web.xml naming) * "contextParameters" contains Servlet/PortletConfig parameters as well * added default "servletContext" and "servletConfig" environment beans * added default "portletContext" and "portletConfig" environment beans * added default web scope "application", wrapping a ServletContext/PortletContext * JSF FacesContext and ExternalContext are resolvable dependencies by default, if available * FacesRequestAttributes (as used by RequestContextHolder) can access global Portlet session * revised @RequestMapping semantics for REST support purposes * request handler methods with @ModelAttribute annotation always return a model attribute * introduced @ExceptionHandler annotation for used in annotated web controllers * introduced ModelAndViewResolver SPI for custom handler method return types * FreeMarkerView can be initialized with ServletContext only (e.g. for testing) * MockPortletSession supports destruction of session attributes on invalidation * completed upgrade of the TestContext Framework to JUnit 4.5 * SpringJUnit4ClassRunner subclasses can now override the default ContextLoader class * added "value" alias for @ContextConfiguration's "locations" attribute Changes in version 3.0.0.M2 (2009-02-25) ---------------------------------------- * revised expression parser API design * added SimpleThreadScope implementation * refined OSGi version constraints for "javax.annotation" and "junit.framework" * "systemProperties" bean is not considered a default match for type Properties anymore * SimpleAliasRegistry's "getAliases" method returns transitive aliases now * SimpleAliasRegistry detects resolved aliases that loop back to the original name * PropertyPlaceholderConfigurer does not modify Map in case of equal String keys * improved NoClassDefFoundError handling during constructor resolution * inner class names in Java source style ("java.lang.Thread.State") supported as well * pre-converted property values are preserved more eagerly for re-created beans * prototype beans receive independent collection/array even when based on single value * registered plain singletons will be fully matched according to their qualifiers * @Qualifier value matching takes chained aliases of target beans into account as well * ASM-based AnnotationMetadata fully resolves class arguments and enums into Java types * ProceedingJoinPoint resolves parameter names using ASM-based parameter name discovery * MethodInvocations and ProceedingJoinPoints always expose original method (not bridge) * bridge method resolution works with Hibernate-generated CGLIB proxies as well * generic collection type resolution respects upper bound (e.g. ? extends Number) as well * TypeUtils detects variations of ParameterizedType/GenericArrayType assignability as well * ReflectionUtils findMethod detects methods on "java.lang.Object" as well * UrlResource eagerly closes HTTP connections in case of "getInputStream()" failure * PathMatchingResourcePatternResolver avoids NPE when initialized with null ClassLoader * all "taskExecutor" bean properties now accept any "java.util.concurrent.Executor" * added "Future submit(Runnable)" and "Future submit(Callable)" to AsyncTaskExecutor * SimpleAsyncTaskExecutor supports a custom "java.util.concurrent.ThreadFactory" * SchedulingTaskExecutor interface extends AsyncTaskExecutor now * added ThreadPoolExecutorFactoryBean (exposing the native ExecutorService interface) * added ExecutorServiceAdapter class as a standard wrapper for a Spring TaskExecutor * reduced backport-concurrent support to TaskExecutor adapters * added @Async annotation and AsyncAnnotationAdvisor (namespace support coming in M3) * EJB 3.1's @Asynchronous annotation gets detected and supported by default as well * ApplicationListener beans get obtained on demand, supporting non-singletons as well * ApplicationListeners will be called in the order according to the Ordered contract * generified ApplicationListener interface, narrowing the event type to be received * introduced SmartApplicationListener interface for supported event/source types * generified Transaction/Hibernate/Jdo/JpaCallback with generic "doInXxx" return type * HibernateOperations uses generic parameter/return types where possible * JdoOperations uses generic parameter/return types where possible (following JDO 2.1) * removed "flush" operation from JdoDialect (fully relying on JDO 2.0+ compliance now) * added JDO 2.1 compliant StandardPersistenceManagerProxy/SpringPersistenceManagerProxy * Spring-created EntityManagers support JPA 2.0 draft API ("unwrap", "getQueryBuilder") * Spring initiates JPA 2.0 query timeout with remaining Spring transaction timeout * added support for WebSphere's ResourceAdapter-managed messaging transactions * made SpringBeanAutowiringInterceptor callback signature compatible with WebSphere * WebSphereUowTransactionManager preserves original exception in case of rollback * added "flush()" method to TransactionStatus and TransactionSynchronization interfaces * test context manager automatically flushes transactions before rolling back * DefaultLobHandler uses explicit Blob/Clob access for reading when "wrapAsLob"=true * fixed JmsException/JmsUtils to fully avoid NPEs in case of cause messages being null * fixed MessageListenerAdapter's "getSubscriptionName()" to work without delegate as well * fixed HTTP invoker to support resolution of multi-level primitive array classes again * deprecated support for JMS 1.0.2 providers (JmsTemplate102 etc) * introduced top-level HTTP support package "org.springframework.http" * introduced RestTemplate facility in package "org.springframework.web.client" * introduced OXM support package (originating from Spring Web Services) * introduced OXM-based MarshallingMessageConverter for Spring JMS * introduced OXM-based MarshallingView for Spring MVC * refined @PathVariable handling in MVC handler methods * updated Spring Portlet MVC infrastructure and mocks for Portlet API 2.0 * added resource and event methods to Portlet HandlerAdapter/HandlerInterceptor * added resolveException method for resource requests to HandlerExceptionResolver * introduced Resource/EventAwareController subinterfaces of Portlet Controller * introduced @Action/@Render/@Resource/@EventMapping annotations for Portlet MVC * added @RequestHeader support for Portlet MVC (based on Portlet request properties) * introduced @CookieValue annotation for Servlet and Portlet MVC handler methods * @RequestMapping type-level param constraints taken into account consistently * optional boolean parameters in MVC handler methods resolve to "false" if not present * "url" macro in "spring.ftl" performs standard Servlet URL encoding automatically Changes in version 3.0.0.M1 (2008-12-05) ---------------------------------------- * revised project layout and build system (module-based sources, bundle repository) * updated entire codebase for Java 5 code style (generics, varargs, StringBuilder) * updated to JUnit 4.5 and JRuby 1.1 * removed WebLogic 8.1 and WebSphere 5.1 support * removed native TopLink API support (superseded by JPA) * removed Commons Attributes support (superseded by Java 5 annotations) * removed Jakarta JSTL support for JSP 1.2 (superseded by JSP 2.0) * removed outdated Struts 1.x Action delegation support * removed ContextLoaderServlet and Log4jConfigServlet * deprecated form controller hierarchy in favor of @MVC form object handling * deprecated JUnit 3.8 test class hierarchy in favor of test context framework * revised TaskExecutor interface to extend "java.util.concurrent.Executor" now * introduced Spring EL parser in org.springframework.expression package * introduced #{...} expression support in bean definitions * introduced @Value annotation for embedded expression support * introduced @PathVariable annotation for MVC handler methods * introduced ShallowEtagHeaderFilter * introduced AbstractAtomFeedView and AbstractRssFeedView * introduced default value support for @RequestParam * introduced @RequestHeader annotation for MVC handler methods * introduced "spring:url" and "spring:param" JSP tags