SPRING FRAMEWORK CHANGELOG ========================== http://www.springsource.org 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