Changelog

SPRING FRAMEWORK CHANGELOG
==========================
http://www.springframework.org
Changes in version 2.5.6.SEC01 (2009-04-22)

-------------------------------------
Package org.springframework.aop
* changed serialization behavior of AbstractRegexpMethodPointcut and JdkRegexpMe
thodPointcut to avoid recompilation
Package org.springframework.core
* fixed issue with GenericTypeResolver where garbage collection was prevented un
der certain circumstances
Changes in version 2.5.6 (2008-10-31)

-------------------------------------
General
* removed outdated EAR support from sample applications
* upgraded to AspectJ 1.6.2 (retaining compatibility with AspectJ 1.5.x and 1.6.
x)
* upgraded to EHCache 1.5.0 (retaining compatibility with EHCache 1.2 and higher
)
* upgraded to TestNG 5.8 (retaining compatibility with TestNG 5.5 and higher)
* upgraded to OpenJPA 1.1.0 (retaining compatibility with OpenJPA 1.0.x as well
as 1.2.0)
* upgraded to EclipseLink 1.0.1 (EclipseLinkJpaVendorAdapter requires EclipseLin
k 1.0.0+ now)
* AbstractAutoProxyCreator (as used by "aop:config") correctly ignores null bean
instances
* "aop:aspect" doesn't insist on aspect bean reference to be specified when just
containing declare-parents elements
* "bean" pointcut matches exposed FactoryBean products only; "&..." syntax suppo
rted for matching FactoryBean itself
Package org.springframework.beans
* BeanUtils skips conventional editor check for array classes (in order to not b
reak AspectJ weaving)
* BeanWrapper's introspection resolves bridge methods to find setter method for
getter method with covariant return type
* TypeMismatchException message differentiates between editor with inappropriate
value returned versus no editor at all
* containing bean definition is exposed to ParserContext for BeanDefinitionDecor
ators as well
* BeanDefinition objects are considered equal even if their originating resource
objects are different
* AbstractFactoryBean's early singleton proxy handles equals, hashCode and toStr
ing calls locally (avoiding eager init)
* PropertyPathFactoryBean logs a warning if the target bean is still in creation
at the time of obtaining the property
* exposed public "copyRegisteredEditorsTo" method on ConfigurableBeanFactory int
erface
* fixed corner case in AbstractBeanDefinition where a ClassCastException could a
rise in "getBeanClass(Name)"
* DefaultSingletonBeanRegistry eagerly cleans up cached dependency information w
hen destroying a bean
* AbstractBeanFactory rejects getBean request with arguments in case of a pre-ex
isting singleton of same name as well
* AbstractAutowireCapableBeanFactory preserves possible matches hint in property
exception
* SmartInstantiationAwareBeanPostProcessor's "determineCandidateConstructors" is
only invoked for non-null bean Class
* ServiceLocatorFactoryBean handles equals and hashCode based on proxy object id
entity
* factored out "createBeanDefinition" template method in BeanDefinitionParserDel
egate
* turned visibility of BeanDefinitionParserDelegate's "checkNameUniqueness" meth
od to protected
* XML list/set/map elements (in both the beans and the util namespace) support n
ested description element
Package org.springframework.cache
* EhCacheFactoryBean obtains decorated Ehcache instead of raw Cache, honoring pr
e-configured cache decorators
* removed useless "diskStorePath" property from EhCacheFactoryBean (ignored by a
ll current EHCache versions anyway)
Package org.springframework.context
* DefaultMessageSourceResolvable and FieldError implement "equals" and "hashCode
" such that all fields are respected
* ClassPathBeanDefinitionScanner performs trace/debug logging during class resou
rce introspection
* ClassPathBeanDefinitionScanner ignores same class found multiple times in the
classpath (i.e. equal bean definition)
* component-scan preserves original source of scanned bean definitions, for sile
ntly ignoring already scanned classes
* annotation-config registers PersistenceAnnotationBeanPostProcessor independent
from client bundle's class loader
* added CUSTOM value to FilterType enumeration
* ClassPathResource uses cleaned path for relative resources as well
* PathMatchingResourcePatternResolver considers URL protocol "vfszip" as jar fil
e (to search JBoss-managed jars)
* GenericCollectionTypeResolver correctly resolves collection element type even
when target bean is a collection itself
Package org.springframework.ejb
* SpringBeanAutowiringInterceptor calls "InvocationContext.proceed()" in order t
o invoke subsequent interceptors as well
Package org.springframework.instrument
* ShadowingClassLoader excludes "net.sf.cglib." package from shadowing by defaul
t
Package org.springframework.jdbc
* provided Jdbc4SqlXmlHandler as default implementation of the SqlXmlHandler int
erface
* added SqlValue class to "jdbc.support" package, with SqlXmlValue derived from
SqlValue instead of SqlTypeValue
* SQLErrorCodesFactory always loads its "sql-error-codes.xml" files from Spring'
s class loader (-> static singleton)
* added "transientDataAccessResourceCodes" category to "sql-error-codes.xml", wi
th default codes for DB2 and Sybase
* SQLErrorCodeSQLExceptionTranslator applies default SQLExceptionSubclassTransla
tor after error code translation only
* SQLErrorCodeSQLExceptionTranslator is able to work without fallback SQLState t
ranslation as well
* SQLExceptionSubclassTranslator translates SQLFeatureNotSupportedException to I
nvalidDataAccessApiUsageException
* SQLStateSQLExceptionTranslator returns TransientDataAccessResourceException fo
r well-known vendor-specific SQL states
* factored out AbstractFallbackSQLExceptionTranslator base class for consistent
"fallbackTranslator" capabilities
* CallableStatementCreatorFactory strictly honors "SqlParameter.isInputValueProv
ided" (allowing for statement caching)
* JdbcTemplate passes full Calendar argument to JDBC driver even in case of no S
QL type specified
* JdbcTemplate does not call the costly "Statement.getWarnings()" unless ignoreW
arnings=false or debug logging is on
* added "checkFullyPopulated" setting to BeanPropertyRowMapper, for validating t
hat all bean properties have been mapped
Package org.springframework.jms
* JmsException message and logged JMSException message explicitly includes linke
d exception now if not already contained
* SingleConnectionFactory only calls "Connection.stop()" on reset when the share
d Connection has actually been started
* SingleConnectionFactory explicitly creates Queue/TopicConnection when first ca
ll is createQueue/TopicConnection method
* CachingConnectionFactory explicitly creates Queue/TopicSession when first call
is createQueue/TopicConnection method
* CachingConnectionFactory's JMS Session proxies implement SessionProxy interfac
e, allowing for access to target Session
* CachingConnectionFactory rolls back cached transacted JMS Sessions on logical
close if no commit/rollback was issued
* CachingConnectionFactory explicitly closes cached JMS Sessions on Connection c
lose
* CachingConnectionFactory's cached producers pass on "disableMessageID" and "di
sableMessageTimestamp" properties
* CachingConnectionFactory also caches MessageConsumers (controlled through "cac
heConsumers" property)
* AbstractJmsListeningContainer eagerly clears shared JMS Connection after relea
sing, avoiding repeated close exceptions
* revised DefaultMessageListenerContainer to correctly work with non-JMS transac
tion manager and CACHE_CONNECTION level
* DefaultMessageListenerContainer supports a stop notification callback for unli
mited maxMessagesPerTask as well now
* introduced SubscriptionNameProvider interface for message listener objects sug
gesting default subscription names
* "jms:listener-container" uses actual message listener object's class name as d
efault subscription name
Package org.springframework.jmx
* fixed NotificationListenerHolder to correctly handle multiple specified object
names
* added "allowEagerInit" property to MBeanExporter, for autodetecting lazy-init
beans and FactoryBean-produced objects
* added "environment" property to MBeanClientInterceptor and NotificationListene
rRegistar, allowing for JMX env entries
* added "refreshOnConnectFailure" property to MBeanClientInterceptor, allowing f
or reconnect in case of I/O failure
Package org.springframework.mail
* ConfigurableMimeFileTypeMap explicitly closes the InputStream that it uses for
"mime.types" resource reading
Package org.springframework.mock
* SimpleNamingContextBuilder supports "deactivate()"+"activate()", with the stan
dard JNDI provider exposed inbetween
Package org.springframework.orm
* HibernateTemplate detects Spring-managed transactional Session even with Sessi
onFactory proxy and allowCreate=false
* HibernateTemplate's "loadAll" operation selects distinct root entities (avoidi
ng duplicate entries in result list)
* HibernateTemplate translates Hibernate's DataException into a Spring DataInteg
rityViolationException (for consistency)
* fixed HibernateTransactionManager's "earlyFlushBeforeCommit" feature to apply
to the outermost transaction only
* added "packagesToScan" property to Hibernate AnnotationSessionFactoryBean, for
autodetection of @Entity classes
* HibernateJpaDialect checks "EntityManager.getDelegate()" as well to find Hiber
nate Session (for Seam compatibility)
* added "persistenceXmlLocation" property to DefaultPersistenceUnitManager, as a
lternative to "persistenceXmlLocations"
* @PersistenceContext of type TRANSACTION allows returned Query objects to be pa
rameterized and executed as well
* @PersistenceContext for default EntityManagerFactory lookup works even in an @
Configurable Hibernate entity
Package org.springframework.remoting
* added "interceptors" property to RemoteExporter, allowing for registering cust
om AOP interceptors before the endpoint
* RmiClientInterceptor always logs connect failure at warn level, even when debu
g logging (incl. stacktrace) is active
* JndiRmiClientInterceptor skips narrowing for RmiInvocationHandler stubs (fixin
g a regression in 2.5.4)
* Hessian/Burlap service exporters explicitly close input and output streams now
(not relying on servlet container)
* Simple/CommonsHttpInvokerRequestExecutor set the current locale according to L
ocaleContextHolder as HTTP lang header
* JaxWsPortProxyFactoryBean exposes the JAX-WS BindingProvider interface in the
Spring-generated proxy as well
Package org.springframework.scheduling
* SchedulerFactoryBean populates scheduler context first before satisfying Sched
ulerContextAware on a given JobFactory
* SchedulerFactoryBean uses bean name as default scheduler name (when "scheduler
Name" property not explicitly specified)
* SchedulerFactoryBean does not accept a pre-registered Scheduler instance in th
e Quartz SchedulerRepository anymore
* SchedulerFactoryBean does not expose the Spring-created/managed Scheduler to t
he Quartz SchedulerRepository anymore
* added "exposeSchedulerInRepository" flag to SchedulerFactoryBean, for explicit
exposure to the SchedulerRepository
* introduced SchedulerAccessorBean for registering jobs/triggers/listeners on an
existing Quartz Scheduler instance
* ScheduledExecutorFactoryBean uses Runnable decorator for logging exceptions th
at lead to termination of execution
Package org.springframework.test
* SpringJUnit4ClassRunner skips execution of test classes with non-matching @IfP
rofileValue annotation completely
Package org.springframework.transaction
* AbstractPlatformTransactionManager resumes after any kind of inner begin failu
re (not just after TransactionException)
* TransactionSynchronizationManager interaction gets logged at trace level only
(minimizing debug log per transaction)
* JotmFactoryBean sets "defaultTimeout" value as actual JOTM default (even if no
transaction timeout specified at all)
Package org.springframework.util
* fixed "StringUtils.delete" to prevent an eternal loop in case of the pattern b
eing empty
* "StringUtils.cleanPath" preserves leading slash if given in original path
* "FileSystemUtils.copyRecursively" ignores 'special' files (i.e. neither a regu
lar file nor a directory)
Package org.springframework.web
* HttpRequestHandlerServlet propagates HTTP request locale into Spring's LocaleC
ontextHolder
* revised "WebUtils.extractFilenameFromUrlPath" to search actual URI part only e
ven when given a URL with query string
* Log4jNestedDiagnosticContextFilter/Interceptor explicitly remove the NDC stack
if depth=0 after the "NDC.pop()" call
* fixed FacesWebRequest's "getParameterValues" implementation to use "ExternalCo
ntext.getRequestParameterValuesMap"
* PortletContextResource cleans given path (analogous to ServletContextResource)
* Servlet/PortletContextResource accept path with leading "/../" part as well (a
s accepted by most servlet containers)
* DispatcherServlet removes error-view-driven servlet request attributes after r
endering (for Tomcat compatibility)
* exposed "getParamName()" method on LocaleChangeInterceptor and ThemeChangeInte
rceptor
* added "cacheSecondsForSessionAttributeHandlers" property to Servlet/Portlet An
notationMethodHandlerAdapter
* AnnotationMethodHandlerAdapter exposes special ModelMap that removes BindingRe
sult if target attribute gets replaced
* Servlet AnnotationMethodHandlerAdapter always takes first exact @RequestMappin
g path match as best path match
* @MVC handler methods, model attribute methods and init binder methods allow fo
r overriding a generic superclass method
* @ModelAttribute annotated handler method arguments can resolve to a null value
as well (when contained in the model)
* standard method argument subtypes (such as a Principal subclass) fail with a d
escriptive exception if incompatible
* Portlet AbstractCommandController falls back to lazy command creation if sessi
on timed out after action phase
* ByteArray/StringMultipartFileEditor do not log warning but rather include root
cause in IllegalArgumentException
* InternalResourceView's "preventDispatchLoop" checks against the same request's
URI only (for Portlet compatibility)
* made RedirectView's "renderMergedOutputModel" implementation non-final
* VelocityConfigurer exposes ServletContext as VelocityEngine attribute (analogo
us to the standard VelocityViewServlet)
* revised XsltView to specify full resource URI as StreamSource system id, for p
roperly resolving relative paths
* officially deprecated AbstractXsltView in favor of XsltView and its more flexi
ble "locateSource" mechanism
* revised error logging during XSLT processing to properly log compilation error
s before an eventual fatal exception
* moved internal TransformerUtils helper class to generic "org.springframework.u
til.xml" package
-------------------------------------
General
* fixed SCM URL in Maven POMs
* "-with-dependencies" distribution includes "jarcontent" folder now (needed for
building from the source)
* upgraded to Quartz 1.6.1 (includes a fix for the Spring trigger persistence pr
oblem that was introduced in 1.6.0)
* upgraded to Hibernate 3.3.0 (while retaining compatibility with Hibernate 3.1/
3.2)
* upgraded to iBATIS SQL Maps 2.3.2 (while retaining compatibility with iBATIS 2
.3.0)
* added "proxyClassLoader" property to ProxyFactoryBean, AbstractSingletonProxyF
actoryBean and AbstractAutoProxyCreator
* CustomizableTraceInterceptor hides proxy class names even in log replacement s
trings (if hideProxyClassNames=true)
* CustomizableTraceInterceptor properly escapes all "\" and "$" symbols in repla
cement values
* revised GenericTypeAwarePropertyDescriptor for compatibility with IBM's JDK 1.
6 (avoiding NPE)
* TypeMismatchException shows type description for mismatching JDK proxy values
(listing their implemented interfaces)
* CustomNumberEditor explicitly removes all inline whitespace from input Strings
(for compatibility with French locales)
* added "getDescription()" method to BeanDefinition interface (exposing the valu
e of the XML bean description element)
* AbstractFactoryBean uses bean ClassLoader for the generation of early singleto
n proxies
* PropertyPlaceholderConfigurer correctly manages resolution of set entries and
map keys with modified hash code
* fixed DefaultSingletonBeanRegistry's singleton exposure to remove singleton fa
ctory after creation of singleton object
* DefaultSingletonBeanRegistry only exposes related causes on outermost creation
exception (avoiding excessive logging)
* DefaultSingletonBeanRegistry only registers same related cause (i.e. same mess
age, same chained cause) once
* DefaultListableBeanFactory only registers causes during constructor resolution
when resolution eventually fails
* DefaultListableBeanFactory checks primary attribute in bean definitions of par
ent factory as well
* fixed DefaultListableBeanFactory to use a post-processing lock (for proper syn
chronization of annotation scanning)
* dependency check "simple" accepts Number, Date, URI, URL and Locale as well (c
onsistent with simple MVC value types)
* UnsatisfiedDependencyException preserves full nested exception stacktrace in c
ase of a BeansException
* added overloaded BeanComponentDefinition constructor with aliases argument
* GenericBeanFactoryAccessor's "getBeansWithAnnotation" performs deep search (in
cluding interfaces and target class)
* added "findAnnotationOnBean" method to GenericBeanFactoryAccessor, performing
a deep search on a specific bean
* BeanConfigurerSupport (@Configurable processing) includes type of bean in warn
log when called in unconfigured state
* restored BeanConfigurerSupport's silent skipping in case of no BeanFactory con
figured yet
* factored out MessageSourceSupport base class from AbstractMessageSource, provi
ding common MessageFormat handling
* DelegatingMessageSource resolves message arguments in default messages even if
there is no parent MessageSource
* MessageSourceResourceBundle exposes Spring-specified locale through overridden
"ResourceBundle.getLocale()" method
* revised CommonAnnotationBeanPostProcessor's "getResource" method to allow for
proper overriding in subclasses
* ClassPathBeanDefinitionScanner always accepts explicit bean definition of same
name as override for scanned bean
* added type="custom" expression="<classname>" option to component-scan's "inclu
de-filter"/"exclude-filter"
* component-scan's "include-filter"/"exclude-filter" entries are validated indiv
idually (for Spring IDE)
* added assertions to GenericTypeResolver (avoiding NPEs)
* factored out generic ConfigurableObjectInputStream class from CodebaseAwareObj
ectInputStream in RMI support
* re-enabled PathMatchingResourcePatternResolver's JarURLConnection handling (ac
cidentally disabled in 2.5.4)
* "jee:local/remote-slsb" accepts plain object returned from EJBHome create meth
od (for JBoss 4.2 EJB3 compatibility)
* added "exposeAccessContext" flag to AbstractSlsbInvokerInterceptor, for WebLog
ic resource factories with authorization
* added "expose-access-context" flag to "jee:local-slsb", "jee:remote-slsb" and
"jee:jndi-lookup"
* added SimpleDriverDataSource alternative to DriverManagerDataSource, avoiding
class loading and synchronization issues
* BeanPropertySqlParameterSource uses specific integer/decimal SQL types by defa
ult now (e.g. TINYINT, BIGINT, DOUBLE)
* introduced SqlXmlHandler abstraction (for the XML support in the Advanced Pack
for Oracle Database)
* added further SQL error code mapping for MS SQL Server
* SingleConnectionFactory and TransactionAwareConnectionFactoryProxy use JMS API
ClassLoader for proxy generation
* JmsTemplate properly allows for overriding "getDefaultDestination()" and "getD
efaultDestinationName()"
* AbstractJmsListeningContainer sets Connection to null on shutdown, allowing fo
r smooth reinitialization
* DefaultMessageListenerContainer performs lazy setup in case of any connection
exception (also JNDI lookup failure)
* DefaultMessageListenerContainer is able to recover all cases where the provide
r is not available on startup
* fixed DefaultMessageListenerContainer to avoid race condition when stopping th
rough lock on unified monitor
* added "container-class" attribute to "jms:listener-container" element, for spe
cifying a custom implementation class
* MessageListenerAdapter and JmsInvokerServiceExporter use message id as correla
tion id if no request correlation id set
* MBeanExporter performs default MBeanServer lookup even when registering notifi
cation listeners only
Package org.springframework.jndi
* added "exposeAccessContext" flag to JndiObjectFactoryBean, for WebLogic resour
ce factories with authorization
* removed overlapping "application/x-pointplus" MIME type for "css" extension fr
om MimeMessageHelper's default mappings
* improved HibernateTransactionManager's InvalidIsolationLevelException exceptio
n message (-> SpringTransactionFactory)
* added "hibernateManagedSession" flag to HibernateTransactionManager, for worki
ng with a custom CurrentSessionContext
* documented use of Hibernate StatelessSession with Spring's DataSourceTransacti
onManager/HibernateTransactionManager
* added support for Derby and H2 through Hibernate/OpenJpa/TopLink/EclipseLinkJp
aVendorAdapter's "database" property
* Hibernate/TopLink/JDO/JPA proxy classes are generated in the ORM provider's Cl
assLoader (for full visibility in OSGi)
* Spring-enriched JPA proxies are created in the application's ClassLoader (maki
ng any vendor interfaces work in OSGi)
* fixed AbstractEntityManagerFactoryBean's EMF proxy to handle equals/hashCode l
ocally (for correct equals behavior)
* iBATIS SqlMapClientFactoryBean supports multiple sql-map-config files and also
patterns ("configLocations" property)
* iBATIS SqlMapClientFactoryBean supports Spring resource/pattern lookup of sql-
map files ("mappingLocations" property)
* RemoteAccessException explicitly declares serialVersionUID (for serialization
compatibility on WebLogic)
* (Simple)HttpInvokerServiceExporter uses the ClassLoader of the containing Bean
Factory for deserialization
* fixed JaxWsClientInterceptor to throw a RemoteConnectFailureException (if appl
icable) instead of returning it
* added support for "username"/"password"/"maintainSession"/"useSoapAction"/etc
properties to JaxWsClientInterceptor
* added SimpleHttpServerJaxWsServiceExporter, allowing for exposure through a fu
lly configurable Sun JDK 1.6 HttpServer
* added "filters" and "authenticator" property to SimpleHttpServerFactoryBean fo
r Sun's JDK 1.6 HttpServer
* revised HessianExporter's "debug" feature to work on Hessian 3.0.20+ as well (
with input debugging only)
* SchedulerFactoryBean's "jobSchedulingDataLocation" feature is compatible with
Quartz 1.6.1 now (requiring 1.6.1+)
Package org.springframework.scripting
* ScriptFactoryPostProcessor ignores any "predictBeanType" failure (in particula
r reference to currently created bean)
* GroovyScriptFactory also converts CompilationFailedException to ScriptCompilat
ionException during type determination
* added "prepareApplicationContext(GenericApplicationContext)" template method t
o AbstractSingleSpringContextTests
* added "prepareContext(GenericApplicationContext)" template method to AbstractG
enericContextLoader
* removed unnecessary "throws Exception" declarations from ReflectionTestUtils
* added "getField" and "invokeGetterMethod" methods to ReflectionTestUtils
* transactional resource synchronization works even for operations triggered dur
ing commit (e.g. by JPA PostUpdate)
* strengthened warning regarding @Transactional use on interfaces versus classes
* "tx:annotation-driven" registers revised TransactionAttributeSourceAdvisor, in
itializing TransactionInterceptor lazily
* publicly exposed "isVisible" method on ClassUtils
* added "getField" and simple "findField" method to ReflectionUtils
* NumberUtils avoids overflow when converting from BigDecimal to BigInteger
* NumberUtils automatically supports JDK 1.5+ localized BigDecimal parsing
* added various overloaded methods with a CharSequence argument (as alternative
to a String argument) to StringUtils
* removed Commons Log usage from SystemPropertyUtils, ClassUtils, FileCopyUtils
(avoiding early Log4J initialization)
* revised CachingMapDecorator to expose all state representations in a thread-sa
fe manner, even for pure introspection
* revised CachingMapDecorator to use weak references for caching only (not losin
g a value from get)
Package org.springframework.validation
* fixed DefaultBindingErrorProcessor to register correct "missing field" errors
within specified nested path
* revised RequestAttributes access from child threads in order to not touch the
request object after request completion
* DispatcherServlet exposes the Servlet spec's error attributes to error views (
for JSP error page compatibility)
* HandlerMethodInvoker does not eagerly copy entire model Map in order to avoid
lazy initialization of attribute values
* Servlet AnnotationMethodHandlerAdapter throws ambiguity exception in case of e
quivalent mappings with same method name
* Portlet AbstractMapBasedHandlerMapping sorts predicates before checking them (
according to their natural order)
* Portlet DefaultAnnotationHandlerMapping checks default mappings last, independ
ent from order of controller definition
* RedirectView uses request's encoding (default ISO-8859-1) if no encoding schem
e specified (previous default was UTF-8)
* RedirectView considers arrays and collections with eligible values, turning th
em into multi-value request parameters
* RedirectView accepts StringBuffers, StringBuilders, Numbers, Dates, URIs, URLs
and Locales as eligible values as well
* factored out common temporary byte array handling from AbstractPdfView etc int
o AbstractView base class
* added AbstractPdfStamperView as alternative to AbstractPdfView, operating on a
n existing document with an AcroForm
* fixed AbstractJasperReportsView to fully isolate a model-specified JDBC DataSo
urce (not setting it as view DataSource)
* AbstractJasperReportsView gives specified JDBC DataSource precedence over impl
icit report data value in model
* AbstractJasperReportsView proceeds without report data value in case of multip
le collections or object arrays
* added "autocomplete" attribute to JSP FormTag (for a form-wide setting, as alt
ernative to InputTag's "autocomplete")
* JSF DelegatingVariableResolver and SpringBeanFacesELResolver log resolution su
ccess at trace level only

-------------------------------------
General
* upgraded to AspectJ 1.6 (while retaining compatibility with AspectJ 1.5.x)
* fixed spring-core.jar's manifest to contain correct OSGi Import-Package declar
ation
* removed superfluous DynamicImport-Package declarations from OSGi manifests
* all decorator proxies are using identity hash code of the proxy instead of the
InvocationHandler hash code now
* fixed various AspectJ expression evaluation bugs through upgrading aspectjweav
er.jar to AspectJ 1.6
* added CharsetEditor for JDK 1.4's "java.nio.charset.Charset" class to default
property editors
* BeanWrapper explicitly finds default PropertyEditor according to "Editor" suff
ix convention
* deprecated BeanWrapper's fallback to the global JavaBeans PropertyEditorManage
r
* DirectFieldAccessor registers Spring's common default PropertyEditors (like Be
anWrapperImpl does)
* fixed AbstractBeanDefinition to properly include qualifiers and primary flag i
n equals comparison
* AbstractAutowireCapableBeanFactory's handling of lazy-init singletons is threa
d-safe again
* AbstractAutowireCapableBeanFactory only invokes "predictBeanType" post-process
or method for non-null bean Class
* introduced InfrastructureProxy interface for resource proxies to be implemente
d if supposed to be considered as equal
* DefaultResourceLoader's ClassPathContextResource also returns ClassPathContext
Resource from "createRelative"
* PathMatchingResourcePatternResolver resolves encoded jar URIs before creating
JarFiles (for WebSphere compatibility)
* PathMatchingResourcePatternResolver catches NoClassDefFoundError when looking
for presence of Equinox classes
* SimpleMetadataReaderFactory uses ResourceLoader's ClassLoader for loading anno
tation classes (for OSGi compatibility)
* JdbcTemplate explicitly detects and skips null ResultSets returned from Callab
leStatement
* BeanPropertySqlParameterSource avoids default use of JDBC 3.0's Types.BOOLEAN
(for compatibility with MySQL)
* fixed CachedMessageProducer to initialize its deliveryMode, priority and timeT
oLive fields with the target's settings
* fixed Hibernate 3.2 support to flush updates before queries even within purely
Spring-managed JTA transactions
* Hibernate3 LocalSessionFactoryBean sets new SpringTransactionFactory as defaul
t in case of no JTA TransactionManager
* JndiRmiClientInterceptor/ProxyFactoryBean work for JNDI objects which do not i
mplement the Remote interface as well
* "executeSqlScript" (as in SimpleJdbcTestUtils) allows for multi-line statement
s, each separated by a semicolon
* TransactionSynchronizationManager automatically unwraps InfrastructureProxy ob
jects for raw key comparisons
* AbstractFallbackTransactionAttributeSource uses concurrent Map for attribute c
ache in order to avoid lock contention
* AbstractPropertyBindingResult's "formatFieldValue" finds PropertyEditor accord
ing to "Editor" suffix convention too
* DefaultBindingErrorProcessor registers "missing field" errors within specified
nested path (if any)
* added "findParameterValue" convenience method to WebUtils
* ContextLoader uses its own ClassLoader for loading the default strategy (XmlWe
bApplicationContext)
* added "contextAttribute" property (for WebApplicationContext retrieval) to Del
egatingFilterProxy and FrameworkServlet
* RequestContext does not fail when WebApplicationContext's ServletContext is nu
ll (like in a plain Portlet environment)
* HandlerMethodInvoker does not copy whole model Set for session attribute expos
ure anymore (avoiding lazy value init)
* fixed JSP form tags to properly return SKIP_BODY instead of the non-defined EV
AL_PAGE (for WebLogic compatibility)

-------------------------------------
General
* replaced junit-4.4.jar in with-dependencies distribution with official JUnit 4
.4 jar
* spring.jar does not include InstrumentationSavingAgent class anymore (for pare
nt-last class loaders)
* spring-context.jar includes optional OSGi imports for "context:annotation-conf
ig"'s autodetection purposes
* Spring reference documentation covers JSF 1.2 and contains updated Struts 2.0
and Tapestry references
* Spring reference documentation covers annotation-based controllers in Portlet
chapter
* deprecated ProxyFactoryBean's support for a target as last element in "interce
ptorNames" in favor of "targetName"
* ProxyFactoryBean assumes a target bean if type cannot be determined for last e
lement in "interceptorNames" list
* AbstractAutoProxyCreator predicts proxy class as bean type if known already (i
nstead of predicting the target class)
* AbstractAutoProxyCreator exposes early singleton proxies (for resolving circul
ar reference between proxied beans)
* "bean(...)" pointcut designator matches against bean name aliases as well, not
just against the canonical bean name
* CharacterEditor's "allowEmpty" only translates empty String to null, keeping a
single space String as space character
* CustomNumberEditor treats number with leading zeros as decimal (removed unwant
ed octal support while preserving hex)
* GenericTypeAwarePropertyDescriptor respects "propertyEditorClass" specified on
original PropertyDescriptor
* renamed ListableBeanFactory's "includePrototypes" flag to "includeNonSingleton
s" (affects javadoc only)
* added "getEarlyBeanReference" hook to SmartInstantiationAwareBeanPostProcessor
interface
* AbstractBeanFactory does not log full exception stack trace (at debug level) o
n FactoryBean type check anymore
* AbstractAutowireCapableBeanFactory allows for resolving circular reference bet
ween beans wrapped by BeanPostProcessors
* DefaultListableBeanFactory passes full inherited AccessControlContext to the A
ccessController for bean creation
* DefaultListableBeanFactory does not eagerly initialize target beans when autow
iring a PriorityOrdered post-processor
* PropertyPlaceholderConfigurer supports nested keys in placeholder keys as well
(e.g. "${db.${environment}}")
* PropertyPlaceholderConfigurer works properly even in case of default-autowire=
"byType" with FactoryBeans involved
* fixed PropertyPlaceholderConfigurer's "nullValue" handling to avoid NPE for ne
sted value
* added "ignoreUnresolvableEditors" property to CustomEditorConfigurer, allowing
to ignore type/editor classes not found
* XmlBeanDefinitionReader's "getValidationModeForResource" method is protected n
ow in order to allow for overriding
* AbstractSimpleBeanDefinitionParser properly ignores namespace declaration attr
ibutes ("xmlns"/"xmlns:")
* AutowiredAnnotationBeanPostProcessor processes @Autowired annotation on most s
pecific method only (when overriding)
* AutowiredAnnotationBeanPostProcessor marks @Autowired bean properties as proce
ssed (for @Required to accept them)
* ReloadableResourceBundleMessageSource is able to detect updates for a properti
es file stored in a jar/zip as well
* AbstractApplicationContext's temporary ClassLoader explicitly excludes types t
o match (for OSGi LTW compatibility)
* restored support for null location array argument in ClassPathXmlApplicationCo
ntext (for Apache CXF compatibility)
* added "registration" attribute to mbean-export element, accepting "failOnExist
ing"/"ignoreExisting"/"replaceExisting"
* CommonAnnotationBeanPostProcessor processes @Resource annotation on most speci
fic method only (when overriding)
* revised default annotation post-processor ordering to apply most specific proc
essors first
* Conventions detects special generated subclasses (e.g. by OpenJPA) and derives
the variable name from the superclass
* revised LocalVariableTableParameterNameDiscoverer to avoid potential NPE in ca
se of no parameter names found on Java 5
* revised DefaultValueStyler (and deprecated ReflectiveVisitorHelper) for better
performance and no class loader leaks
* StaticLabeledEnumResolver uses weak references to LabeledEnum class in order t
o avoid class loader leaks
* added "lastModified()" method to Resource interface, for abstract access to th
e last-modified timestamp
* ClassPathResource and UrlResource use the last-modified timestamp of the archi
ve file for jar/zip contents
* PathMatchingResourcePatternResolver sets "useCaches=false" on any JarURLConnec
tion that it opens for path matching
* PathMatchingResourcePatternResolver detects WebSphere 6.1 "bundleresource:" UR
Ls and resolves them for path matching
* added "cacheSessionBean" flag to SimpleRemoteStatelessSessionProxyFactoryBean,
for caching the session bean object
* added "cache-session-bean" attribute to "jee:remote-slsb" configuration elemen
t
* Spring 2.5 "jee:*" config elements use resource-ref="true" by default (non-res
ource-ref names will still work as well)
* JndiDataSourceLookup uses "resourceRef"=true by default (being able to resolve
J2EE "jdbc/myDb" ENC names by default)
* NativeJdbcExtractorAdapter only processes DatabaseMetaData Connection if non-n
ull (for WebLogic cluster compatibility)
* fixed SQLException translation for IBM DB2 and MS SQL to operate on error code
s first, just falling back to SQL state
* added MySQL NDB error codes and further DB2 error codes to default "sql-error-
codes.xml" file
* factored out common AbstractColumnMaxValueIncrementer base class from Derby/Hs
ql/MySQLMaxValueIncrementer
* added DB2MainframeSequenceMaxValueIncrementer for DB2/390 and DB2/400 (differi
ng from DB2 UDB for Unix and Windows)
* added "wrapAsLob" property to DefaultLobHandler, for passing Blob/Clob instanc
es to the JDBC driver (for PostgreSQL)
* DefaultLobHandler's "streamAsLob" setting (requires JDBC 4.0) applies to byte
array and String arguments as well
* JdbcTemplate creates LinkedHashMap (instead of plain HashMap) as default resul
ts Map returned from "call" operation
* JdbcDaoSupport does not override specified JdbcTemplate on subsequent "setData
Source" call for same DataSource
* NamedParameterJdbcTemplate ignores Postgres-style "::" casting operator (i.e.
not treated as named parameter)
* SimpleJdbcInsert supports "autoGeneratedKey" simulation using "insert ... retu
rning" for PostgreSQL 8.2 and later
* SimpleJdbcCall supports metadata lookup of procedure columns for PostgreSQL (r
equires JDBC driver 8.3 or later)
* SingleConnectionFactory accepts "Connections.setClientID" calls with the same
client ID as specified on the factory
* SingleConnectionFactory accepts further "Connection.setExceptionListener" call
s in "reconnectOnException" mode
* introduced CachingConnectionFactory (as subclass of SingleConnectionFactory) f
or JMS 1.1 session and producer pooling
* SimpleMessageListenerContainer registers itself as ExceptionListener for autom
atic Connection recovery
* added "runningAllowed()" template method to DefaultMessageListenerContainer, a
llowing subclass to temporarily suspend
* DefaultMessageListenerContainer scales concurrent invokers eagerly in case of
a sudden burst (revised idle handling)
* DefaultMessageListenerContainer uses a "maxMessagesPerTask" default of 10 when
associated with a ScheduledTaskExecutor
* DefaultMessageListenerContainer propagates JMSExceptions thrown from a listene
r, potentially triggering recovery
* MessageListenerAdapter propagates JMSExceptions thrown from listener method as
-is (no wrapping in runtime exception)
* MessageListenerAdapter invokes target (SessionAware)MessageListener immediatel
y, not extracting the content upfront
* added "cache" attribute to "jms:listener-container" configuration element, for
customizing the resource cache level
* MBeanExporter's autodetection does not cause CannotLoadBeanClassException for
lazy-init beans (Spring 2.0 compatible)
* JndiLocatorSupport tries fallback lookup for originally specified JNDI name if
resource-ref adapted name wasn't found
* JndiObjectFactoryBean exposes the bean ClassLoader as thread context ClassLoad
er (if necessary)
* MockHttpServletResponse's "encodeURL" allows for central overriding in subclas
ses (affecting "encodeRedirectURL" too)
* SimpleNamingContext's "createSubcontext" works correctly for given subcontext
names without trailing slash as well
* XxxDaoSupport does not override specified XxxTemplate on subsequent "setZzzFac
tory" call for same factory
* added "executeWithNewSession" and "executeWithNativeSession" methods to Hibern
ateTemplate
* revised EntityManagerFactoryInfo handling to autodetect all EntityManager inte
rfaces if no JpaVendorAdapter specified
* PersistenceAnnotationBeanPostProcessor processes annotations on most specific
method only (when overriding)
* revised (Simple)Hessian/BurlapServiceExporter's handling of non-POST requests
(avoiding unnecessary warnings)
* added "waitForTasksToCompleteOnShutdown" property to ThreadPoolTaskExecutor
* changed ThreadPoolTaskExecutor's default behavior to shutdown immediately, not
waiting for scheduled tasks
* ThreadPoolTaskExecutor extends CustomizableThreadFactory for common bean prope
rties and uses itself as default factory
* ThreadPoolTaskExecutor uses its bean name as default thread name prefix (analo
gous to DefaultMessageListenerContainer)
* MethodInvokingRunnable logs target exception directly at error level (instead
of InvocationTargetException wrapper)
* MethodInvokingJobDetailFactoryBean propagates invocation exceptions as non-Job
ExecutionExceptions (for error logging)
* DelegatingJob propagates exceptions as-is instead of wrapping them in JobExecu
tionExceptions (for error logging)
* ResourceScriptSource is able to detect updates for a script file stored in a j
ar/zip as well
* @IfProfileValue correctly checked against concrete test class, even in case of
overridden test methods
* @IfProfileValue annotation without specified value checks against presence (no
n-null value) of the given profile key
* "executeSqlScript" (as in SimpleJdbcTestUtils) allows for multiple statements
per line, separated by semicolons
* SpringJUnit4ClassRunner catches AssumptionViolatedException in @Before methods
(analogous to standard JUnit 4.4)
* SpringJUnit4ClassRunner executes befores/afters in same thread for test method
with JUnit timeout (-> transactions)
* TransactionalTestExecutionListener is able to manage concurrent transactions f
or different test methods (with timeout)
* TransactionalTestExecutionListener reobtains transaction manager for every tra
nsaction (picking up context changes)
* fixed Abstract(Transactional)JUnit(38/4)SpringContextTests classes to be actua
lly marked as abstract
* JtaTransactionManager" checks JNDI location "java:appserver/TransactionManager
" for GlassFish's primary TM handle
* "ClassUtils.resolveClassName" preserves the original root cause in the rethrow
n IllegalArgumentException
* NumberUtils treats number with leading zeros as decimal (removed unwanted octa
l support while preserving hex)
* MethodInvoker scans all declared methods (of any visibility), being able to in
voke protected/private methods as well
* added "getChildElementsByTagNames" method with tag names Collection argument t
o DomUtils
* factored out AbstractErrors base class from AbstractBindingResult, providing c
ommon access to evaluated errors
* added "getRawFieldValue" and "findEditor" methods to BindingResult interface (
for a completely decoupled BindStatus)
* fixed AbstractPropertyBindingResult's "getFieldType" to correctly apply nested
path to field name
* added convenience constructors to ObjectError and FieldError
* ContextLoader accepts system property placeholders in "contextConfigLocation"
value (again)
* OncePerRequestFilter cleans up its marker attribute at the end of each outer r
equest (for Portlet compatibility)
* RequestContextFilter supports "threadContextInheritable" init-param (analogous
to DispatcherServlet)
* HttpRequestHandlerServlet translates HttpRequestMethodNotSupportedException in
to HTTP status code 405
* DispatcherServlet translates HttpRequestMethodNotSupportedException into HTTP
status code 405 by default
* introduced WEB_APPLICATION_CONTEXT_ATTRIBUTE in RequestContext, for overriding
the DispatcherServlet context
* ControllerClassNameHandlerMapping detects @Controller beans by default as well
* ControllerClassNameHandlerMapping registers plain path for multi-action contro
llers too ("/welcome/*" + "/welcome")
* added ControllerBeanNameHandlerMapping, deriving URL paths from bean names for
well-known controller types
* AnnotationMethodHandlerAdapter's @RequestMapping matching is deterministic ind
ependent from the declared methor order
* AnnotationMethodHandlerAdapter accepts @RequestParam annotations for @InitBind
er methods as well
* AnnotationMethodHandlerAdapter always exposes BindingResult objects for model
attributes which are binding candidates
* AnnotationMethodHandlerAdapter throws clear IllegalStateException in case of i
nvalid BindingResult argument
* Portlet AnnotationMethodHandlerAdapter supports Servlet ModelAndView and View
objects as handler method return values
* default attribute names for annotated handler method return values are consist
ently derived from the declared type
* added "exposedContextBeanNames" property to InternalResourceView(Resolver), fo
r exposing specific Spring beans only
* InternalResourceView does not enforce ApplicationContext to be set anymore (al
lowing for "getServletContext" checking)
* JstlView, Tiles(Jstl)View and AbstractJasperReportsView expose current Request
Context's MessageSource for localization
* JSP form tags do not autogenerate id in case of empty id specified (empty id s
ignals no id to be rendered)
* JSP OptionTag and OptionsTag support "id" attribute now, analogous to RadioBut
ton(s)Tag and Checkbox(es)Tag
* added standard HTML "target" attribute to JSP FormTag, for submitting to anoth
er window/frame
* fixed JSP LabelTag to render valid default "for" attribute for collection/map
paths as well
* fixed AbstractJasperReportsView to build exception messages for the specific s
ub-report location

-------------------------------------
General
* various reference documentation revisions (e.g. updated transaction management
chapter)
* removed outdated showcases sample applications from Spring distribution
* spring-context.jar does not include InstrumentationSavingAgent class anymore (
for parent-last class loaders)
* AbstractRegexpMethodPointcut matches against target class as well, not just ag
ainst method's declaring class
* ProxyFactoryBean and AbstractAutoProxyCreator check autodetected proxy interfa
ces for visibility in the ClassLoader
* Cglib2AopProxy properly detects overridden "finalize()" methods, never dispatc
hing them to the interceptor chain
* CustomizableTraceInterceptor properly escapes method names and exception messa
ges for regex parsing (wrt "$" signs)
* marked AbstractRefreshableTargetSource's status accessors as synchronized
* AbstractBeanFactoryBasedTargetSourceCreator applies containing BeanFactory's c
onfiguration to internal BeanFactory
* AbstractBeanFactoryBasedTargetSourceCreator creates an independent internal Be
anFactory per target bean
* deprecated ClassLoaderAnalyzerInterceptor and associated ClassLoaderUtils clas
s
* reintroduced AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(ParserConte
xt,Object) for Spring 2.0 compatibility
* introduced PropertyAccessorFactory facade for obtaining BeanWrapper and direct
field accessor instances
* deprecated BeanWrapper's "setWrappedInstance" method in favor of recreating a
BeanWrapper per target instance
* BeanWrapperImpl trims an enum candidate value before matching it against the a
vailable enum values
* BeanWrapperImpl resolves the target type for a generically typed bean property
, performing appropriate type conversion
* StringArrayPropertyEditor (for comma-delimited splitting of array elements) re
gistered for short[], int[], long[] too
* CustomDateEditor and CustomNumberEditor preserve original ParseException as ro
ot cause of IllegalArgumentException
* MethodInvokingFactoryBean falls back to interpreting specified arguments as si
ngle method argument of array type
* deprecated RefreshablePagedListHolder class and associated PagedListSourceProv
ider interface
* added "getOriginatingBeanDefinition()" method to BeanDefinition interface, exp
osing the decorated definition (if any)
* PropertyOverrideConfigurer is able to properly override target bean definition
s behind a scoped proxy decorator
* added "nullValue" property to PropertyPlaceholderConfigurer, allowing for reso
lving specific Strings into a null value
* CustomEditorConfigurer and CustomScopeConfigurer accept editor/scope values as
class names as well
* factored out AliasRegistry/SimpleAliasRegistry from BeanDefinitionRegistry/Abs
tractBeanFactory
* introduced SimpleBeanDefinitionRegistry implementation for bean definition rea
der testing
* "registerAlias" allows for overriding as long as bean definition overriding is
allowed
* added convenient "autowireBean(Object existingBean)" method to AutowireCapable
BeanFactory
* AbstractAutowireCapableBeanFactory removes singleton if created for type check
in case of circular reference issues
* AbstractAutowireCapableBeanFactory applies specified TypeConverter to bean ref
erences as well (not just to literals)
* AbstractAutowireCapableBeanFactory resolves the target type for a generically
typed dependency (method parameter)
* AbstractAutowireCapableBeanFactory's "applyBeanPropertyValues" fully initializ
es the BeanWrapper used for binding
* AbstractAutowireCapableBeanFactory's "applyBeanPropertyValues" and "configureB
ean" use a cached merged bean definition
* fixed AbstractAutowireCapableBeanFactory's "configureBean" (@Configurable) to
avoid bean name creation for inner beans
* fixed AbstractAutowireCapableBeanFactory to skip invocation of InstantiationAw
areBeanPostProcessors for null bean
* fixed AbstractAutowireCapableBeanFactory to always resolve the bean class befo
re a FactoryBean type check
* added "freezeConfiguration()" method to Configurable/DefaultListableBeanFactor
y, allowing for eager metadata caching
* revised bean destruction logging to log at WARN level with exception toString
only (full exception at DEBUG level)
* AutowiredAnnotationBeanPostProcessor resolves the target type for a genericall
y typed dependency (method parameter)
* fixed AutowiredAnnotationBeanPostProcessor to correctly cache a collection wit
h a single autowired bean as element
* fixed AutowiredAnnotationBeanPostProcessor to not cache special dependencies s
uch as request and session references
* deprecated AbstractBeanDefinition's Spring 1.2 style "setSingleton" method in
favor of Spring 2.0's "setScope"
* deprecated BeanDefinitionBuilder's "addConstructorArg" in favor of the consist
ently named "addConstructorArgValue"
* deprecated various rarely used BeanDefinitionBuilder methods in favor of setti
ngs on the raw BeanDefinition object
* added overloaded "genericBeanDefinition(beanClass)" method and "setParentName"
method to BeanDefinitionBuilder
* added support for "(scope)" key to PropertiesBeanDefinitionReader: e.g. "myBea
n.(scope)=prototype"
* refactored AbstractBeanConfigurerAspect into Abstract(InterfaceDriven)Dependen
cyInjectionAspect
* nested XML decoration elements (e.g. "aop:scoped-proxy") are explicitly reject
ed if no corresponding handler present
* InitDestroy/Autowired/Common/PersistenceAnnotationBeanPostProcessor perform ap
propriate debug logging
* factored out generic SpringBeanELResolver and SimpleSpringBeanELResolver from
"web.jsf.SpringBeanFacesELResolver"
* added "getId()" method to ApplicationContext interface, with corresponding "se
tId" in AbstractApplicationContext class
* moved CONFIG_LOCATION_DELIMITERS constant from ConfigurableWebApplicationConte
xt to ConfigurableApplicationContext
* fixed AbstractApplicationContext to correctly ignore FactoryBean results that
implement the Lifecycle interface
* AbstractApplicationContext processes Lifecycle callbacks in the order of bean
creation by default
* AbstractApplicationContext explicitly freezes its bean factory configuration a
t the end of the "refresh()" phase
* exposed "allowBeanDefinitionOverriding"/"allowCircularReferences" properties i
n AbstractRefreshableApplicationContext
* factored out AbstractRefreshableConfigApplicationContext base class for common
handling of specified config locations
* ClassPathXmlApplicationContext and FileSystemXmlApplicationContext allow for b
ean-style configuration
* StaticApplicationContext builds GenericBeanDefinitions by default (instead of
RootBeanDefinitions)
* added "initApplicationContext(ApplicationContext)" template method to Applicat
ionObjectSupport
* ClassPathBeanDefinitionScanner detects scoped-proxy bean definitions as compat
ible (in case of duplicate scanning)
* refactored ClassPathBeanDefinitionScanner into various template methods (for e
asier overriding)
* refactored ComponentScanBeanDefinitionParser into various template methods (fo
r easier overriding)
* ComponentScanBeanDefinitionParser includes annotation config processors in nes
ted composite component
* "context:component-scan" resolves "${...}" placeholders in package paths again
st system properties
* "context:component-scan" explictly ignores directories that accidentally match
a specified custom resource pattern
* fixed "context:load-time-weaver" to not break post-processor detection in case
of Spring jars deployed as shared libs
* added "context:property-override" configuration element, as a sibling to "cont
ext:property-placeholder"
* introduced Named(Inheritable)ThreadLocal, used throughout the framework for se
lf-descriptive thread-bound context
* added "getParameterName()" method to MethodParameter, activated through a Para
meterNameDiscoverer
* factored out GenericTypeResolver from BridgeMethodResolver and GenericCollecti
onTypeResolver
* factored out DecoratingClassLoader base class from OverridingClassLoader and S
hadowingClassLoader
* added "isReadable()" method to Resource interface, giving a readability hint u
pfront (supported by FileSystemResource)
* fixed ClassMetadataReadingVisitor (as used by "context:component-scan") to cor
rectly ignore *usage* of inner classes
Package org.springframework.dao
* PersistenceExceptionTranslationPostProcessor extends ProxyConfig and applies i
ts settings to newly created proxies
* Local/SimpleRemoteSlsbInvokerInterceptor use EJB(Local)Home for EJB 2.x detect
ion, for WebSphere compatibility
* SimpleRemoteSlsbInvokerInterceptor properly detects CORBA connect failures on
the IBM JVM (for WebSphere EJB access)
* added public "isInstrumentationAvailable()" method to InstrumentationLoadTimeW
eaver, avoiding direct access to agent
* fixed ShadowingClassLoader to not attempt defining a package in case of a clas
s in the default package
Package org.springframework.jca
* ResourceAdapterApplicationContext registers BootstrapContext as resolvable dep
endency type (for @Autowired)
* ResourceAdapterApplicationContext registers WorkManager as lazily resolvable d
ependency type (for @Autowired)
* added "workManagerName" property to WorkManagerTaskExecutor, for J2EE env look
ups in JNDI (e.g. a Geronimo gbean-ref)
* introduced JBossWorkManagerTaskExecutor as adapter for the JBoss JCA WorkManag
er (analogous to CommonJ)
* introduced GlassFishWorkManagerTaskExecutor as adapter for the GlassFish JCA W
orkManager (analogous to CommonJ)
* DriverManagerDataSource's "driverClassName" throws IllegalStateException inste
ad of CannotGetJdbcConnectionException
* added "defaultTransactionIsolationName" property to LazyConnectionDataSourcePr
oxy
* SQLStateSQLExceptionTranslator translates "01*" data truncation codes into Dat
aIntegrityViolationException
* SQLStateSQLExceptionTranslator translates "61*" deadlock codes into Concurrenc
yFailureException
* SQLErrorCodesSQLExceptionTranslator falls back to SQL state translation for IB
M DB2 and MS SQL by default
* added further default "sql-error-codes.xml" mappings for MS SQL, MySQL, Postgr
eSQL and Oracle
* DatabaseStartupValidator lets startup continue instead of 'busy' waiting in ca
se of thread interruption
* JdbcTemplate falls back to type VARCHAR for a null value in case of an unknown
SQL type specified against IBM DB2
* JdbcTemplate uses "PreparedStatement.setString" in case of LONGVARCHAR and CLO
B (if given a String value)
* fixed CallMetaDataContext to skip SqlParameter objects without name (avoiding
NPE)
* merged AbstractBeanPropertyRowMapper into concrete BeanPropertyRowMapper class
* removed BeanPropertyRowMapper's "newInstance" method to avoid confusion with P
arameterizedBeanPropertyRowMapper
* revised BeanPropertyRowMapper to use JavaBean property introspection instead o
f expecting field/setter name matches
* factored out "initBeanWrapper"/"getColumnValue" template methods in BeanProper
tyRowMapper, allowing for customization
* BeanPropertyRowMapper shares ResultSet value access logic with SingleColumnRow
Mapper
* BeanPropertyRowMapper and SingleColumnRowMapper perform Oracle-specific "getOb
ject" checks for unknown specified types
* added ParameterizedSingleColumnRowMapper with a convenient "newInstance" metho
d to specify the required type only once
* BeanPropertySqlParameterSource derives a default SQL type from the correspondi
ng property type (for typed null values)
* improved SimpleMessageConverter's exception message for an unsupported message
payload
* DefaultMessageListenerContainer logs listener setup failures at INFO instead o
f ERROR level
* DefaultMessageListenerContainer allows for specifying a callback on "stop", fo
r a notification after actual stopping
* DefaultMessageListenerContainer lets shutdown continue instead of 'busy' waiti
ng in case of thread interruption
* fixed DefaultMessageListenerContainer to correctly process "sessionTransacted=
true" in case of locally exposed Session
* SimpleMessageListenerContainer exposes listener Session as thread-bound resour
ce for JmsTemplate calls (like DMLC)
* deprecated ServerSessionMessageListenerContainer in favor of DefaultMessageLis
tenerContainer/JmsMessageEndpointManager
* DefaultJmsActivationSpecFactory is compatible with WebSphere MQ 6.0.2.1 as wel
l now
* factored out "doUnregister(objectName)" and "onRegister(objectName,mbean)" met
hods in MBeanRegistrationSupport
* MBeanExporter actually sets "exposeManagedResourceClassLoader" to "true" by de
fault (matching the 2.5 javadoc now)
* MBeanExporter explicitly removes all of its registered NotificationListeners f
rom the target MBeanServer on shutdown
* introduced NotificationListenerRegistrar for registering a listener with any M
Bean on any MBeanServer(Connection)
* added "text/csv" to ConfigurableMimeFileTypeMap's and thus MimeMessageHelper's
default MIME mappings
* added "getServletContext()" method to MockHttpServletRequest (not available in
the HttpServletRequest interface)
* introduced "postProcessMappings" template method in Hibernate LocalSessionFact
oryBean
* fixed Hibernate AnnotationSessionFactoryBean to allow for mixed mapping source
s (despite 2.5.1's "buildMappings" call)
* HibernateTemplate exposes the "org.hibernate.event.EventSource" and "org.hiber
nate.classic.Session" interfaces as well
* introduced "EntityManagerFactoryUtils.closeEntityManager" method that protects
against exceptions thrown from close
* Hibernate/Jpa/JdoTransactionManager explicitly rollback an active transaction
before closing when begin failed
* fixed TopLinkTransactionManager to correctly expose the underlying JDBC Connec
tion in read-write transaction scenarios
* JDO/JPA factories check autodetected proxy interfaces for visibility in the Cl
assLoader (for WebSphere compatibility)
* added "entityManagerFactoryInterface" property to AbstractEntityManagerFactory
Bean, as alternative to autodetection
* added "getEntityManagerFactoryInterface()" to JpaVendorAdapter (for WebSphere
compatibility of OpenJpaVendorAdapter)
* added "getPersistenceProviderRootPackage()" to JpaVendorAdapter, for excluding
provider classes from class overriding
* introduced EclipseLinkJpaVendorAdapter and EclipseLinkJpaDialect, supporting E
clipseLink 1.0 M4 or higher
* factored out RemotingSupport base class from RemoteAccessor and RemoteExporter
* (Jndi)RmiClientInterceptor properly detects CORBA connect failures on the IBM
JVM
* HessianClientInterceptor and BurlapClientInterceptor expose the bean ClassLoad
er as thread context CL (if necessary)
* added overloaded "executeRequest" method with original MethodInvocation argume
nt to HttpInvokerClientInterceptor
* added "hostname" bean property to SimpleHttpServerFactoryBean, for a specific
network address to bind to
* introduced "ScriptFactory.requiresScriptedObjectRefresh(ScriptSource)" for obj
ect refresh even after a type check call
* GroovyScriptFactory and JRubyScriptFactory refresh scripted object instances e
ven after an intermediate type check
* introduced "ScriptSource.suggestedClassName()" for dynamic Groovy scripts that
do not define a class themselves
* GroovyScriptFactory uses resource filename (for files) or bean name (for inlin
e scripts) as suggested class name
* added "depends-on" attribute to "lang:bsh/groovy/jruby" configuration element
* TestContextManager ignores default TestExecutionListeners that cannot be insta
ntiated (e.g. due to spring-tx missing)
* AbstractJUnit38SpringContextTests runs "afterTestMethod" callbacks even when "
beforeTestMethod" or "setUp" failed
* AbstractTestNGSpringContextTests executes Spring default callbacks in any case
(marked with "alwaysRun = true")
* added configurable "sqlScriptEncoding" property to AbstractTransactionalXxxSpr
ingContextTests (for reading scripts)
* revised ConcurrencyThrottleSupport's interruption handling to throw an Illegal
StateException instead of 'busy' waiting
* deprecated ResponseTimeMonitor and PerformanceMonitorListener classes in favor
of custom classes for specific needs
* DataBinder's "initDirectFieldAccess()" sets the "extractOldValueForEditor" fla
g by default, analogous to bean access
* ServletRequestAttributes keeps hold onto the original session if a "request.ge
tSession" call suddenly returns null
* added "setConfigLocation" method to ConfigurableWeb/PortletApplicationContext,
accepting an init-param style value
* added "initServletContext(ServletContext)" template method to WebApplicationOb
jectSupport
* optimized ServletContextResource's and PortletContextResource's "exists()" che
ck to avoid unnecessary stream opening
* Commons(Portlet)MultipartResolver catches and logs any exception thrown from f
ile item cleanup (not propagating it)
* introduced NativeWebRequest and MultipartRequest interfaces for even finer-gra
ined generic request access options
* introduced FacesRequestAttributes adapter, with attributes access falling back
to current JSF FacesContext by default
* added "dispatchOptionsRequest/TraceRequest" properties to FrameworkServlet, fo
r dispatching all HTTP request methods
* deprecated PathMap attribute and CommonsPathMapHandlerMapping class in favor a
nnotation-based request mapping
* deprecated ThrowawayController and ThrowawayControllerHandlerAdapter in favor
annotation-based controllers
* @RequestMapping's "method" attribute supported at type level as well, expressi
ng restriction for entire handler
* @RequestMapping's "params" attribute supported at type level for Servlets, exp
ressing precondition for entire handler
* @RequestMapping's "params" attribute supported at type level for Portlets, map
ping mode+params onto specific handler
* @RequestMapping annotation supports "!myParam" expressions for non-presence of
a specific parameter as well
* introduced WebArgumentResolver interface and "customArgumentResolver(s)" prope
rty on AnnotationMethodHandlerAdapter
* factored out common HandlerMethodResolver/Invoker classes from Servlet/Portlet
AnnotationMethodHandlerAdapter
* AnnotationMethodHandlerAdapter does not restrict supported HTTP methods by def
ault (allowing for PUT, DELETE as well)
* AnnotationMethodHandlerAdapter narrows through method name resolution even for
a set of equal non-empty mappings
* AnnotationMethodHandlerAdapter resolves the target type for a generically type
d @RequestParam/@ModelAttribute argument
* AnnotationMethodHandlerAdapter properly allows for resolving a Principal argum
ent to null (in case of none defined)
* AnnotationMethodHandlerAdapter resolves InputStream/OutputStream and Reader/Wr
iter subclasses as well
* added "synchronizeOnSession" property to AnnotationMethodHandlerAdapter, analo
gous to AbstractController
* fixed AnnotationMethodHandlerAdapter to avoid NPE in case of plain model attri
bute returned from handler method
* Servlet AnnotationMethodHandlerAdapter sends HTTP 404 instead of throwing Ille
galState if no handler method found
* Portlet AnnotationMethodHandlerAdapter throws UnavailableException instead of
IllegalState if no handler method found
* added "prepareResponse"/"generatesDownloadContent" methods to AbstractView, fo
r HTTPS cache header workaround for IE
* AbstractPdfView and Abstract(J)ExcelView participate in AbstractView's HTTPS c
ache header workaround for IE
* AbstractJasperReportsView does not perform a hard response reset, in favor of
AbstractView's HTTPS cache workaround
* AbstractTemplateView catches "HttpServletResponse.getContentType()" exceptions
(for JBoss Portal compatibility)
* InternalResourceView only exposes forward attributes when running on Servlet <
2.5 (for GlassFish compatibility)
* InternalResourceView detects circular dispatching to the same view even in cas
e of pattern matches for same handler
* InternalResourceView prevents dispatch to same handler path only if the "preve
ntDispatchLoop" flag is set to "true"
* InternalResourceViewResolver sets "preventDispatchLoop" to "true" for conventi
onal name-based View instances only
* JstlView exposes a JSTL-aware MessageSource even for a custom MessageSource pa
ssed in through the constructor
* re-added AbstractDataBoundFormElementTag's COMMAND_NAME_VARIABLE_NAME in depre
cated form (Spring 2.0.x compatibility)
* made FormTag's MODEL_ATTRIBUTE_VARIABLE_NAME public (as replacement of COMMAND
_NAME_VARIABLE_NAME)
* JSP Checkbox(es)Tag and RadioButton(s)Tag render label as HTML label element a
fter input element (for HTML compliance)
* JSP CheckboxesTag and RadioButtonsTag compare raw item / raw Map key for selec
tion check as well
* JSP SelectTag and OptionsTag compare raw Map key for selection check as well

-------------------------------------
General
* refined PDF formatting settings for the reference documentation
* added coverage of JAX-WS support to the reference documentation
* added section on J2EE RAR deployment to the reference documentation
* moved "org.springframework.web.bind/multipart" packages from spring-web.jar to
spring-webmvc.jar
* updated AspectJ jar in "-with-dependencies" distribution to AspectJ 1.5.4
* updated Groovy jar in "-with-dependencies" distribution to Groovy 1.5.1
* updated Hessian jar in "-with-dependencies" distribution to Hessian 3.1.3
* updated iText jar in "-with-dependencies" distribution to iText 2.0.7
* updated POI jar in "-with-dependencies" distribution to POI 3.0.1
* ProxyFactory caches CGLIB proxies only when underlying (Smart)ClassLoader does
not indicate a reloadable Class
* added "logTargetClassInvocation" property to AbstractMonitoringInterceptor, fo
r logging the target invocation trace
* ConfigurablePropertyAccessor extends the TypeConverter interface (moved up fro
m BeanWrapper interface)
* BeanWrapper supports well-known collection implementation types for generic el
ement conversion again (like Spring 2.0)
* TypeConverterDelegate protects its text conversion step against PropertyEditor
s which don't support "setValue" calls
* factored out FactoryBeanRegistrySupport base class from AbstractBeanFactory an
d AbstractAutowireCapableBeanFactory
* optimized AbstractBeanFactory's access to cached FactoryBean-exposed objects,
avoiding unnecessary locks
* ConstructorResolver prefers concrete class matches over interface matches at t
he same level when checking arguments
* revised accidental public exposure of "isPrimary" method in ConfigurableListab
leBeanFactory/DefaultListableBeanFactory
* moved "resolveDependency" implementation from AbstractAutowireCapableBeanFacto
ry down to DefaultListableBeanFactory
* revised DefaultListableBeanFactory's "resolveDependency" exceptions with respe
ct to clarity and context inclusion
* DefaultListableBeanFactory does not eagerly initialize FactoryBeans for type c
hecks even with factory-bean reference
* DefaultListableBeanFactory throws descriptive exception in case of factory-bea
n circular reference
* DefaultListableBeanFactory supports ObjectFactory indirection for resolvable d
ependencies
* DefaultListableBeanFactory always resolves bean class before checking a bean d
efinition as autowire candidate
* AbstractBeanDefinition stores and exposes the originating Resource (rather tha
n just the resource description)
* XmlBeanDefinitionReader detects recursive loading of the same resource (e.g. t
hrough import cycles)
* DefaultBeanDefinitionDocumentReader sends ImportDefinition events containing t
he actually resolved Resource objects
* DefaultDocumentLoader includes the JAXP IllegalArgumentException in the rethro
wn ParserConfigurationException
* ClassPathBeanDefinitionScanner marks default init/destroy methods as not enfor
ced (accepting beans without those)
* SingletonBeanFactoryLocator falls back to a single bean of type BeanFactory (i
f any) when given a null locator key
* SingletonBeanFactoryLocator removes bean factory group definition if its initi
alization fails
* factored out protected "getTargetBean" method in ObjectFactoryCreatingFactoryB
ean (for easier overriding)
* revised BeanConfigurerSupport to allow for usage as a delegate as well, not ju
st as a base class
* revised BeanConfigurerSupport to re-initialize its default BeanWiringInfoResol
ver for each context refresh
* fixed AutowiredAnnotationBeanPostProcessor to properly cache dependencies that
do not correspond to a registered bean
* annotation processors detect already managed methods/fields, avoiding double i
nvocation in case of multiple processors
* explicit annotation processors override implicit default processors (as built
by annotation-config / component-scan)
* added "cacheManagerName" property to EhCacheManagerFactoryBean
* fixed AbstractApplicationContext to only send ContextStoppedEvent in case of "
stop()" (i.e. not for "close()")
* fixed AbstractApplicationContext to always detect LoadTimeWeaverAwareProcessor
in the local ClassLoader (for OSGi)
* ClassPath/FileSystemXmlApplicationContext perform early check for null element
s in config location array
* added "addMessages(Map, Locale)" method to StaticMessageSource, for bulk addin
g messages
* ContextTypeMatchClassLoader does not generally exclude classes in the "org.spr
ingframework" package anymore
* DefaultContextLoadTimeWeaver only chooses GlassFishLoadTimeWeaver when running
in the EAR ClassLoader
* DefaultContextLoadTimeWeaver removes all registered transformers from the VM I
nstrumentation object (if applicable)
* CommonAnnotationBeanPostProcessor properly ignores @Resource-annotated JAX-WS
WebServiceContext references
* AnnotationBeanNameGenerator (used by "context:component-scan") detects default
name values in custom annotation types
* ClassPathScanningCandidateComponentProvider ("context:component-scan") ignores
non-static inner and local classes
* "context:property-placeholder" configuration element does not require a "locat
ion" attribute (for system properties)
* introduced SmartClassLoader marker interface, declaring a "boolean isClassRelo
adable(Class clazz)" operation
* OverridingClassLoader excludes the "oracle." package by default as well (e.g.
for TopLink's custom annotations)
* MethodParameter uses reflection to obtain parameter annotations (for compatibi
lity with the IBM 1.4.2 VM's debug mode)
* LocalVariableTableParameterNameDiscoverer caches parameter names per method an
d obtained ASM ClassReaders per class
* added "getEnclosingClassName()", "hasEnclosingClass()" and "isIndependent()" m
ethods to ClassMetadata interface
* "jee:local-slsb" and "jee:remote-slsb" work for EJB3 Session Beans as well (as
alternative to "jee:jndi-lookup")
* introduced EJB3-compliant SpringBeanAutowiringInterceptor for processing Sprin
g's @Autowired in EJB3 SBs/MDBs
* InstrumentationLoadTimeWeaver allows for operating on a pre-defined ClassLoade
r and for removing transformers again
* TomcatInstrumentableClassLoader always passes local ClassLoader into ClassFile
Transformers (makes AspectJ LTW work)
* ShadowingClassLoader excludes the "com.ibm." package by default as well (for I
BM JDK classes, DB2 JDBC driver, etc)
* fixed JdbcUtils to not access the DatabaseMetaData implementation class for "e
xtractDatabaseMetaData" calls
* TransactionAwareDataSourceProxy obtains target Connections lazily when the fir
st call comes in on the Connection proxy
* added "reobtainTransactionalConnections" flag to TransactionAwareDataSourcePro
xy (for Connection handles on JBoss)
* WebSphereDataSourceAdapter, JBossNativeJdbcExtractor and CommonsDbcpNativeJdbc
Extractor propagate SQLExceptions as-is
* JmsUtils protects against misbehaving JMS providers (such as ActiveMQ) when cl
osing an interrupted MessageConsumer
* JmsTemplate's standard "execute(ProducerCallback)" pre-initializes producer wi
th default destination (if available)
* added overloaded execute methods with Destination/destination name and Produce
rCallback to JmsOperations/JmsTemplate
* added various "browse"/"browseSelected" methods JmsOperations/JmsTemplate, for
browsing a queue with a BrowserCallback
* DelegatingConnectionFactory adapts specific create(Queue/Topic)Connection call
s to a generic JMS 1.1 ConnectionFactory
* JmsInvokerClientInterceptor accepts any JMS 1.1 ConnectionFactory, not insisti
ng on a QueueConnectionFactory anymore
* MethodListenerAdapter uses type difference weight algorithm to choose between
ambiguous listener methods
* DefaultMessageListenerContainer catches TaskRejectedException and pauses affec
ted tasks for subsequent resuming
* DefaultMessageListenerContainer exposes listener Session as thread-bound resou
rce for JmsTemplate calls
* ServerSessionMessageListenerContainer always establishes a shared Connection (
even if autoStart="false")
* CommonsPoolServerSessionFactory removes specific ServerSessionPool on close (f
or proper reuse on stop and restart)
* "jms:listener-container" tag supports a concurrency range (e.g. "3-5"), for sp
ecifying a minimum number of consumers
* added "getServer()" method to MBeanRegistrationSupport (MBeanExporter), exposi
ng the underlying JMX MBeanServer
* JndiTemplate prepares a specific Hashtable for the InitialContext, exposing de
fault environment properties as well
* fixed potential NPE in MailSendException
* MockRequestDispatcher stores forwarded/included URL in MockHttpServletResponse
even in case of wrapped response
* LocalSessionFactoryBean uses LocalJtaDataSourceConnectionProvider (supporting
aggressive release) in case of JTA TM
* LocalSessionFactoryBean supports Connection release mode "after_statement" wit
hout "useTransactionAwareDataSource" too
* LocalSessionFactoryBean eagerly compiles registered mappings, for availability
in the post-processing phase
* added "cacheProvider" property to LocalSessionFactoryBean, allowing for a Spri
ng-managed CacheProvider instance
* added overloaded "delete" methods with "entityName" argument to HibernateOpera
tions and HibernateTemplate
* added "earlyFlushBeforeCommit" flag to HibernateTransactionManager, allowing t
o enforce a flush before synchronization
* fixed Jpa/JdoTransactionManager to correctly nest a REQUIRES_NEW transaction w
ithin a SUPPORTS scope with early access
* JPA PersistenceUnitReader supports location patterns for the "jar-file" attrib
ute in "persistence.xml" files
* PersistenceAnnotationBeanPostProcessor accepts vendor-specific EntityManager i
nterfaces for @PersistenceContext again
* HessianClientInterceptor/ProxyFactoryBean supports "debug", "chunkedPost", "re
adTimeout" and "hessian2" properties
* HessianServiceExporter supports "debug" property analogous to Hessian 3.1.3's
HessianServlet
* HessianServiceExporter and BurlapServiceExporter expose the bean ClassLoader a
s thread context CL (if necessary)
* factored out stream-based HessianExporter and BurlapExporter classes
* factored out abstract RemoteInvocationSerializingExporter base class from Http
InvokerServiceExporter
* introduced SimpleHttpInvokerServiceExporter and SimpleHessian/BurlapServiceExp
orter as HttpHandlers for Sun JRE 1.6
* introduced SimpleHttpServerFactoryBean for Spring-style set-up of a Sun JRE 1.
6 HttpServer
Package org.springframework.samples
* PetClinic's JPA version showcases AspectJ load-time weaving, including @Transa
ctional handling in AspectJ mode
* PetClinic's JPA EntityManagerClinic uses explicit flushing and id assigning to
make sure that the id is available
* ThreadPoolTaskExecutor supports Java 6's "allowCoreThreadTimeOut" feature (for
both native and backport-concurrent)
* fixed ScriptFactoryPostProcessor to avoid NPE in case of script that produces
null value and no interfaces specified
* StaticScriptSource exposes "StaticScript" as toString result, in order for Gro
ovy to derive a valid class name from it
* GroovyScriptFactory caches a temporarily created result object from "getScript
edObjectType" until "getScriptedObject"
* GroovyScriptFactory exposes "getGroovyClassLoader()" method and lazily initial
izes the GroovyClassLoader
* "lang:groovy/jruby/bsh" does not insist on an id for a scripted bean anymore (
i.e. allows for anonymous scripts)
* fixed AbstractContextLoader to detect and accept "classpath*:" URLs as well
* AbstractTestNGSpringContextTests does not define a "SpringTestContext" group a
nymore (for ease of using custom groups)
* added "validateExistingTransaction" property to AbstractPlatformTransactionMan
ager, for isolation level checks
* added "prepareForCommit" template method to AbstractPlatformTransactionManager
, called before commit synchronization
* JtaTransactionManager consistently throws TransactionSystemException in case o
f unexpected internal transaction state
* JtaTransactionManager detects JBoss 4.2 transaction rollbacks caused by a time
out, throwing a meaningful exception
* fixed WebSphereUowTransactionManager to correctly detect an existing global tr
ansaction (ignoring local tx contexts)
Package org.springframework.ui
* fixed ModelMap's "mergeAttributes" to correctly copy new attributes into the m
odel
* added "containsAttribute" method to ModelMap, as a more specific alternative t
o a general "containsKey" call
* introduced Java-5-specific Model interface (for use with MVC handler methods)
and corresponding ExtendedModelMap impl
* AutoPopulatingList is serializable now
* MethodInvoker (and subclasses) use type difference weight algorithm to choose
between multiple matching methods
* FreeMarker "formSingleSelect" macro also accepts options from a sequence (list
) as both labels and values
* clarified that BindingResult's "getPropertyEditorRegistry()" method may return
null to indicate no support for editors
* DataBinder implements the TypeConverter interface, delegating to the underlyin
g PropertyAccessor
* ContextLoader(Listener/Servlet) explicitly removes the context attribute from
the ServletContext (for WLS hot deploy)
* introduced static "getCurrentWebApplicationContext()" accessor on ContextLoade
r, for context lookup by thread
* introduced SpringBeanAutowiringSupport class for self-autowiring classes withi
n a web app (e.g. JAX-WS endpoints)
* WebApplicationContext impls register request/session/ServletContext as resolva
ble dependencies (e.g. for @Autowired)
* PortletApplicationContext impls register request/session/PortletContext as res
olvable dependencies (for @Autowired)
* CommonsMultipartResolver uses FileUpload 1.2's "isMultipartContent" variant wh
en available (for stricter checks)
* added "useCacheControlNoStore" property to WebContentGenerator, allowing to su
ppress the "no-store" header value
* SimpleUrlHandlerMapping explicitly trims specified handler bean names (in orde
r to ignore unintended whitespace)
* UrlPathHelper detects a context path of "/" (as exposed by Jetty for includes)
and processes it as root context ("")
* improved NoSuchRequestHandlingMethodException's error message to include reque
st URL and query string explicitly
* DispatcherServlet consistently logs correct request URI for include requests (
even in debug log messages)
* MultiActionController properly supports String return types for handler method
s (for consistency with @RequestMapping)
* MultiActionController detects and rejects invalid last-modified method return
types
* WebRequest interface (as supported for @RequestMapping) supports "checkNotModi
fied" method for last-modified handling
* @RequestMapping paths are considered a match even without suffix (e.g. "/users
" matches a request for "/users.do")
* @InitBinder methods apply to @RequestParam parameters as well, with the @InitB
inder value matched against param names
* @ModelAttribute's default attribute names are consistently derived from the *d
eclared* parameter/return type
* AnnotationMethodHandlerAdapter properly handles overridden handler methods wit
h overridden @RequestMapping annotation
* AnnotationMethodHandlerAdapter maps relative paths specified at method level a
nalogous to default method name mappings
* AnnotationMethodHandlerAdapter throws an exception if it cannot find a clear b
est path match for a specific request
* AnnotationMethodHandlerAdapter throws descriptive exception in case of optiona
l parameter being declared as primitive
* AnnotationMethodHandlerAdapter automatically resolves arguments of type Princi
pal as the request's user principal
* AnnotationMethodHandlerAdapter propagates checked exceptions as-is for handler
/attribute/init-binder methods
* AnnotationMethodHandlerAdapter applies @InitBinder methods for view preparatio
n as well (like WebBindingInitializers)
* AnnotationMethodHandlerAdapter applies binder initialization for 'end' views (
with processing being complete) as well
* factored out "createBinder" template method within AnnotationMethodHandlerAdap
ter, called for each binding attempt
* Servlet AnnotationMethodHandlerAdapter supports View return value for handler
methods (as alternative to view name)
* fixed Portlet AnnotationMethodHandlerAdapter to explicitly check for Action/Re
nder*Response* (to work on Liferay)
* InternalResourceView prevents dispatching to same path as handler (e.g. with d
efault view name and default resolver)
* JstlView detects session-scoped JSTL LocalizationContext/Locale attributes and
merges them with its own context
* JstlView and (JspAware)RequestContext consistently use JSTL Config class for s
coped attribute access
* reworked Spring's Tiles2 support such that it can operate against the Tiles2 (
2.0.5+) JDK 1.4 version as well
* Tiles2 TilesView explicitly checks whether the Tiles container has been initia
lized (throwing a descriptive exception)
* Tiles2 TilesView exposes Servlet 2.4 forward request attributes (for non-2.4-c
ompliant web containers like OC4J)
* fixed JSP BindTag to correctly detect and ignore a repeated nested path for th
e global errors case
* JSP CheckboxTag/CheckboxesTag and RadioButtonTag/RadioButtonsTag use registere
d property editor for value rendering
Changes in version 2.5 final (2007-11-19)

-----------------------------------------
General
* updated javadoc and reference documentation
* revised PetPortal sample application into a full-fledged Java 5 showcase (anno
tation-based configuration etc)
* fixed garbage collection problem with CGLIB proxies, using a strong reference
map for the fixed interceptors
* "context:load-time-weaver" autodetects the GlassFish ClassLoader even within a
GlassFish web app now
* "context:load-time-weaver" correctly detects the use of the Spring VM agent on
WebLogic 9
* URL-to-File conversion for ClassPathResource/UrlResource performs URI-based de
coding rather than using URLDecoder
* optimized UrlResource's handling of URI access and File access if constructed
with a URI directly
* fixed AbstractLabeledEnum to correctly determine the default enum type for a t
op-level enum class (again)
* added "registerDatabase" method to SQLErrorCodesFactory, for eager association
of database names with DataSources
* DefaultMessageListenerContainer avoids deadlock between Connection and Session
through the use of a shared monitor
* fixed "jee:jndi-lookup" tag to correctly handle "default-value" and "default-r
ef" attributes
* Hibernate SpringSessionSynchronization explicitly disconnects on suspend/compl
etion (to make "on_close" work on JBoss)
* fixed CommonJ TimerManagerFactoryBean to not require the "scheduledTimerListen
ers" property
* TestContextManager logs TestExecutionListener exceptions at error/warn level i
nstead of info/debug
* JtaTransactionManager swallows IllegalStateException when synchronizing with e
xisting transaction (for JBoss 4.2)
* CommonsMultipartResolver detects multiple files for the same field name and th
rows a corresponding exception
* RequestToViewNameTranslator kicks in before the "HandlerInterceptor.postHandle
" phase
* RequestToViewNameTranslator's "getViewName" is allowed to return null if no de
fault found
* fixed AnnotationMethodHandlerAdapter to expose the implicit model even when us
ing request-to-view-name translation
* fixed AnnotationMethodHandlerAdapter to correctly match parameters even in cas
e of request method specified as well
* DispatcherPortlet/AnnotationMethodHandlerAdapter swallows IllegalStateExceptio
n when setting implicit render parameter
* Portlet AnnotationMethodHandlerAdapter preserves implicit model from action ph
ase to render phase
* Portlet AnnotationMethodHandlerAdapter applies cache settings (prevents cachin
g when session attributes are involved)
* Portlet AnnotationMethodHandlerAdapter allows default @RequestMapping annotati
ons for action as well as render methods
* Portlet AnnotationMethodHandlerAdapter resolves PortletPreferences, PortletMod
e, WindowState, PortalContext arguments
* factored out AbstractWizardFormController's "getTargetPage" logic into WebUtil
s/PortletUtils, for reuse in custom code
* InternalResourceView explicitly sets content type on response in include case
(for correct charset handling on Tomcat)
* exposed applicable standard HTML attributes on JSP "form:option" and "form:opt
ions" tags
* JSP form tags always autogenerate valid HTML ids (not including "[" or "]" cha
racters from array element properties)
Changes in version 2.5 RC2 (2007-11-12)

---------------------------------------
General
* introduced complete rewrite of the Spring MVC step-by-step guide for version 2
.5
* fixed garbage collection problem with CGLIB proxies, now holding onto the Advi
sed configuration independent of factory
* DefaultListableBeanFactory now supports autowiring of FactoryBean instances 'b
y type'
* revised DefaultListableBeanFactory's exception handling for clearer wrapping o
f nested exceptions
* DefaultListableBeanFactory performs bean creation within a PrivilegedAction (f
or SecurityManager compatibility)
* optimized DefaultListableBeanFactory's invocation of setter methods for re-cre
ated bean instances
* optimized DefaultListableBeanFactory's invocation of post-processor methods
* changed XmlReaderContext's "getReader()" to expose the XmlBeanDefinitionReader
again (for backwards compatibility)
* AutowiredAnnotationBeanPostProcessor caches determined candidate constructors
per bean class
* RequiredAnnotationBeanPostProcessor caches validated bean names, skipping re-v
alidation for the same bean
* added bean type argument to MergedBeanDefinitionPostProcessor (for InitDestroy
AnnotationBeanPostProcessor)
* "context:mbean-export" autodetects WebLogic and WebSphere, performing an appro
priate MBeanServer lookup
* "context:mbean-export" falls back to a simple MBeanExporter on JDK 1.4, detect
ing standard MBeans
* introduced "context:mbean-server" configuration element, for setting up a stan
dalone MBeanServer reference
* "context:load-time-weaver" automatically activates "spring-configured" if Aspe
ctJ weaving is enabled
* "context:load-time-weaver"'s temporary ClassLoader for type matching uses a fu
lly isolated loader for each match
* PersistenceExceptionTranslationAdvisor detects @Repository on interfaces as we
ll
* added missing "refresh()" call to SpringContextResourceAdapter's ApplicationCo
ntext
* TransactionAwareDataSourceProxy exposes a special "toString()" result for its
Connection proxies
* fixed SingleColumnRowMapper to use passed-in required type in the default "con
vertValueToRequiredType" implementation
* SimpleJdbcCallOperations and SimpleJdbcInsertOperations return the interface t
ype (not the impl) for method chaining
* "jee:jndi-lookup" supports "default-value" and "default-ref" attributes, trans
lated to a default object
* MailSendExceptions keeps failed messages in a LinkedHashMap, allowing for acce
ss in the order of sending
* added "getMessageExceptions()" accessor to MailSendException, with "getFailedM
essages()" being transient now
* fixed Jpa/JdoTransactionManager to correctly suspend and resume even for diale
cts without JDBC Connection retrieval
* SqlMapClientTemplate explicitly checks for TransactionAwareDataSourceProxy, av
oiding double synchronization
* RmiClientInterceptor and AbstractSlsbInvokerInterceptor do not consider Marsha
lException as connect failure anymore
Package org.springframework.stereotype
* @Component, @Repository, etc are not marked as inherited anymore (i.e. inherit
ance checks to be performed explicitly)
* AbstractGenericContextLoader provides an opportunity for subclasses to customi
ze the context before calling refresh
* revised TestExecutionListener method signatures to declare Exception instead o
f Throwable
* "tx:jta-transaction-manager" autodetects Oracle OC4J as well, in addition to W
ebLogic and WebSphere
* ContextLoader provides an opportunity for subclasses to customize the context
before calling refresh
* made AbstractController's handleRequest entry point method non-final (allowing
for overriding and CGLIB proxying)
* AbstractUrlHandlerMapping always takes the first matching path (in case of mul
tiple path patterns of equal length)
* AnnotationMethodHandlerAdapter for Servlet MVC exposes UrlPathHelper and PathM
atcher configuration properties
* AnnotationMethodHandlerAdapter for Servlet MVC supports MethodNameResolver for
resolving default handler methods
* AnnotationMethodHandlerAdapter for Servlet MVC supports path patterns for @Req
uestMapping at the method level as well
* AnnotationMethodHandlerAdapter for Servlet MVC always prevents HTTP caching in
case of @SessionAttributes specified
* reworked @RequestMapping's "type" attribute into "method", accepting strongly
typed @RequestMethod enum values
* revised AnnotationMethodHandlerAdapter's resolution of multiple matching handl
er methods to take params into account
* @RequestParam's "value" attribute is not required anymore, defaulting to the m
ethod parameter name (if available)
* added "types" attribute to @SessionAttributes, allowing to enumerate model att
ributes types instead of names
* AbstractJasperReportsSingleFormatView converts exporter parameter values in th
e model (if appropriate)
* InternalResourceView lets explicit model attributes override Spring beans in c
ase of "exposeContextBeansAsAttributes"
* JstlView does not set "exposeContextBeansAsAttributes" flag to "true" by defau
lt (analogous to InternalResourceView)
* JSF 1.1 DelegatingVariableResolver checks original VariableResolver first agai
n (for strict backwards compatibility)
* introduced JSF 1.1 SpringBeanVariableResolver, letting Spring bean definitions
override other attributes of same name
* renamed JSF 1.2 DelegatingFacesELResolver to SpringBeanFacesELResolver, indica
ting its concrete lookup strategy
* fixed Tiles 1.x TilesConfigurer to explicitly set the factory name to empty St
ring by default
Changes in version 2.5 RC1 (2007-10-22)

---------------------------------------
General
* introduced spring-framework-with-docs.zip distribution; reduced spring-framewo
rk.zip to the minimal binaries
* spring.jar does not include Servlet Web MVC support anymore; add spring-webmvc
.jar separately
* spring.jar and spring-core.jar include repackaged version of ASM 2.2.3 (avoidi
ng side effects with other ASM versions)
* spring-orm.jar contains the web ORM support (again), in order to avoid split p
ackages across bundles
* spring-web.jar includes the entire Hessian, Burlap, HTTP invoker, JAX-RPC and
JAX-WS support (avoiding split packages)
* removed outdated Countries sample application
* revised PetClinic sample application into a full-fledged Java 5 showcase (anno
tation-based configuration etc)
* revised default handling in BeanDefinitionParsers for XML config namespaces to
work without XSD validation as well
* updated Spring's JDO support to require JDO 2.0 or higher, with early support
for JDO 2.1 features
* revised AdvisedSupport to avoid lock contention for method cache lookups (usin
g a concurrent map with special keys)
* fixed AspectJ pointcut handling to strictly match generic return types accordi
ng to Java language rules
* AspectJ pointcut matching only registers LocalVariableTableParameterNameDiscov
erer if ASM is present on the classpath
* removed unused pointcut type attribute from "spring-aop-2.5.xsd"
* BeanWrapperImpl obtains old value with converted key in case of a Map with non
-String keys
* TypeMismatchException and MethodInvocationException are serializable even in c
ase of non-serializable property values
* URIEditor only tries to resolve "classpath:" locations if explicitly construct
ed with a ClassLoader
* URIEditor converts spaces in location values into "%20" quotes (as required by
the URI format)
* exposed "autowireCandidate" property in BeanDefinition interface (avoiding cas
ts to AbstractBeanDefinition)
* deprecated ConfigurableBeanFactory's "registerCustomEditor" in favor of "addPr
opertyEditorRegistrar"
* AbstractBeanFactory ignores PropertyEditorRegistrars which tried to obtain a c
urrently created bean
* revised AbstractBeanFactory to detect FactoryBeans which are in turn created t
hrough factory methods
* DefaultListableBeanFactory freshly resolves autowired arguments even for cache
d constructors (re-resolving prototypes)
* DefaultListableBeanFactory removes a singleton bean instance if a new bean def
inition gets registered
* DefaultListableBeanFactory fully destroys singleton bean instance when the cor
responding bean definition gets replaced
* DefaultListableBeanFactory resets the caches for all derived beans as well if
a bean definition gets replaced
* fixed CglibSubclassingInstantiationStrategy to avoid CGLIB class leak for inne
r prototypes with MethodReplacer usage
* XmlBeanDefinitionReader initializes default EntityResolver lazily, avoiding cl
asspath scan in case of custom resolver
* DefaultNamespaceHandlerResolver exposes public DEFAULT_HANDLER_MAPPINGS_LOCATI
ON constant
* DefaultNamespaceHandlerResolver loads NamespaceHandler mappings and classes la
zily (only when namespace actually used)
* fixed BeanDefinitionParserDelegate to correctly parse property sub-elements ev
en with custom name for beans namespace
* BeanDefinitionParserDelegate stores definition source for metadata attributes
and qualifier attributes
* qualifier attributes consist of "key" and "value" in spring-beans-2.5.xsd (for
merly "name" and "value")
* AbstractBeanDefinition's qualifier handling provides a unified "addQualifier(A
utowireCandidateQualifier)" method
* AbstractSingleBeanDefinitionParser applies full scope to inner beans, making t
hem eligible for destruction callbacks
* added "getParentName" template method to AbstractSingleBeanDefinitionParser, a
llowing for child bean definitions
* @Autowired qualifier annotations may be defined with target 'type' as well, ma
rking the target bean class
* Autowired/Common/PersistenceAnnotationBeanPostProcessor implement PriorityOrde
red and expose an "order" bean property
* "depends-on" kicks in before the affected bean is entering its creation phase;
can be used to resolve circular refs
* added "registers-scope" annotation to spring-tool.xsd, allowing a tool to dete
rmine valid scope names
* AbstractApplicationContext calls "cancelRefresh" method in case of refresh fai
lure now, resetting the 'active' flag
* AbstractRefreshableApplicationContext calls the full "destroyBeans()" method w
hen refreshing the bean factory
* ClassPathXmlApplicationContext and FileSystemXmlApplicationContext trim passed
-in config location Strings
* added "concurrentUpdates" flag to AbstractApplicationEventMulticaster, enablin
g copy-on-write for the listener set
* AnnotationConfigUtils checks for EntityManagerFactory class instead of Persist
enceContext (for Tomcat 6 compatibility)
* moved CommonAnnotationBeanPostProcessor class from package "beans.factory.anno
tation" to "context.annotation"
* CommonAnnotationBeanPostProcessor supports @Resource's "mappedName" attribute
as (potentially global) JNDI location
* added "alwaysUseJndiLookup" flag to CommonAnnotationBeanPostProcessor, enforci
ng Java EE 5 JNDI lookups
* CommonAnnotationBeanPostProcessor detects and processes the JAX-WS @WebService
Ref annotation as well
* CommonAnnotationBeanPostProcessor detects and processes the EJB 3 @EJB referen
ce annotation (if present) as well
* @PostConstruct/@PreDestroy methods are only called once even if they are speci
fied as standard init/destroy methods
* added "context:mbean-export" configuration element to "spring-context-2.5" sch
ema, for annotation-driven JMX export
* NestedRuntimeException/NestedCheckedException's "contains" checks the nested c
auses of any kind of wrapped exception
* added "ConcurrentMap createConcurrentMap" method to CollectionFactory, exposin
g a common ConcurrentMap interface
* deprecated CollectionFactory's "createLinkedSet/LinkedMap/IdentityMapIfPossibl
e" (for usage on JDK 1.4 or higher)
* AttributeAccessorSupport uses a LinkedHashMap, keeping the attributes in the o
rder of registration
* "Conventions.getVariableName" follows JavaBeans property naming rules in case
of multiple upper case letters
* added "getURI()" method to Resource interface
* added constructor with URI argument to UrlResource class
* FileSystemResource's "getURL()" builds URLs that can be converted to an URI
* introduced ContextResource interface with "getPathWithinContext()" method (exp
osed for context-relative lookups)
* reworked "core.asm.ClassReaderFactory" into "core.classreading.MetadataReaderF
actory" (with internal ASM usage only)
* AspectJTypeFilter uses a given ClassLoader instead of the default ClassLoader
* spring-jee.xsd explicitly declares defaults for its boolean flags
* added WebLogicLoadTimeWeaver for BEA WebLogic version 10 or higher
* SimpleJdbcTemplate's varargs handling always considers a single array argument
as collection of arguments
* JmsTemplate only starts lazily created transactional Connections if actually n
ecessary (-> "startConnection" flag)
* JmsTransactionManager does not start transactional Connections until a transac
tional Session actually requires it
* added DestinationResolver support to StandardJmsActivationSpecFactory, for Des
tination objects on JCA ActivationSpecs
* DefaultJmsActivationSpecFactory autodetects WebSphere's JMS ResourceAdapter an
d extended ActivationSpec properties
* "spring-jms.xsd" supports "destination-resolver" attribute for "jca-listener-c
ontainer" element as well
* JmsNamespaceHandler registers class names only, allowing tools to run without
the JMS API on the classpath
* MBeanExporter applies NotificationPublisherAware callbacks to objects register
ed via "registerManagedResource" as well
* MBeanExporter's "exposeManagedResourceClassLoader" defaults to "true" now, for
interaction with third-party MBeans
* MBeanExporter uses AUTODETECT_ALL as default if no beans have been specified e
xplicitly
* MBeanExporter supports dynamic AOP proxies with the target class being a stand
ard MBean/MXBean
* introduced AnnotationMBeanExporter with conveniently pre-configured Annotation
JmxAttributeSource
* ManagedResource annotation allows for specifying the "objectName" as annotatio
n value as well
* MetadataNamingStrategy falls back to bean key (bean name) if no "objectName" s
pecified in source-level metadata
* fixed IdentityNamingStrategy to obtain the package name through class name ins
pection rather than "Class.getPackage()"
* MBeanClientInterceptor automatically converts MXBean CompositeData/TabularData
structures according to Java 5/6 rules
* MBeanClientInterceptor uses the standard JDK MBeanServerInvocationHandler if p
ossible (for full MXBean support)
* MBeanClientInterceptor propagates exceptions thrown by the target MBean direct
ly (i.e. not wrapped in a JmxException)
* added "getJavaMailProperties()" method to JavaMailSenderImpl, allowing for con
venient configuration of specific keys
* MockServletContext supports "getContext" (allowing to register contexts throug
h the new "registerContext" method)
* MockServletContext supports "getMimeType" if the Java Activation Framework is
present on the classpath
* added convenience constructors to MockPortletConfig, MockActionRequest and Moc
kRenderRequest
* LocalSessionFactoryBean always uses the bean ClassLoader for "mappingResources
" as well as for SessionFactory building
* HibernateInterceptor can be interleaved with JTA transactions and non-transact
ional access even with async tx timeouts
* removed custom detach/attach/newNamedQuery hooks from JdoDialect, expecting pr
oviders to follow the final JDO 2.0 API
* deprecated JdoTemplate's "attachCopy" methods in favor of revised "makePersist
ent" with a JDO2-style return value
* LocalPersistenceManagerFactoryBean passes the application ClassLoader into "JD
OHelper.getPersistenceManagerFactory"
* added "persistenceManagerFactoryName" property to LocalPersistenceManagerFacto
ryBean, supporting JDO 2.1 PMF lookup
* added "jdoPropertyMap" property to LocalPersistenceManagerFactoryBean, allowin
g for non-String JDO property values
* JdoTransactionManager and JpaTransactionManager support REQUIRES_NEW transacti
ons in afterCompletion callbacks
* JPA support exposes the application ClassLoader as PersistenceUnitInfo ClassLo
ader even without a LoadTimeWeaver
* JPA support uses InstrumentationLoadTimeWeaver as default weaver if Instrument
ationSavingAgent is active
* revised CommonsLoggingSessionLog to work with TopLink 11 as well (remaining co
mpatible with TopLink 10.1.3)
* fixed Hessian/BurlapClientInterceptor's "convertHessian/BurlapAccessException"
method to return the exception properly
* JndiRmiClientInterceptor's "prepare()" doesn't declare NamingException anymore
(just RemoteLookupFailureException)
* JaxRpcPortClientInterceptor's "prepare()" doesn't declare ServiceException any
more (just RemoteLookupFailureException)
* JaxRpcPortClientInterceptor extracts the original exception as far as provided
by JAX-RPC in case of a SOAP fault
* introduced JAX-WS 2.0/2.1 support in package "org.springframework.remoting.jax
ws"
* introduced RemoteInvocationFailureException, thrown by RMI/HTTP/JMS invoker pr
oxies in case of server-side failure
* introduced SoapFaultException, thrown by JAX-RPC/JAX-WS proxies in case of a S
OAP fault being reported
Package org.springframework.stereotype
* added @Service and @Controller stereotypes to the existing Component and Repos
itory annotations
* introduced TestNG support based on the new test context framework
* TransactionSystemException preserves the original application exception, if an
y, in case of commit/rollback failure
* revised AbstractFallbackTransactionAttributeSource's template methods for spec
ific attribute/annotation retrieval
* AnnotationTransactionAttributeSource supports a customizable TransactionAnnota
tionParser strategy
* AnnotationTransactionAttributeSource supports EJB3's TransactionAttribute anno
tation (if present) as well
* TransactionAspectSupport ignores transaction attributes when not configured wi
th a transaction manager
* added "tx:jta-transaction-manager" configuration element to "spring-tx-2.5" sc
hema
* "ModelMap.addObject(Object)" follows JavaBeans property naming rules in case o
f multiple upper case letters
* "ClassUtils.getShortNameAsProperty" strips the outer class name in case of an
inner class
* added "resolveLazily" flag to Commons(Portlet)MultipartResolver, allowing to s
witch to lazy multipart resolution
* reworked MultipartException into a RuntimeException (it may be thrown from fil
e/parameter access methods as well now)
* changed UrlPathHelper's and AbstractUrlHandlerMapping's/AbstractUrlMethodNameR
esolver's "urlDecode" default to "true"
* added "getAttributeNames" method to RequestAttributes interface
* introduced WebBindingInitializer interface, supported by BaseCommandController
and MultiActionController
* introduced annotation-based controller approach using @Controller, @RequestMap
ping, @RequestParam and @ModelAttribute
* introduced annotation-based command/form controller facilities using @InitBind
er, @FormAttributes and FormStatus
* introduced DefaultAnnotationHandlerMapping and AnnotationMethodHandlerAdapter
for Servlet MVC and Portlet MVC
* added "caseSensitive", "pathPrefix" and "basePackage" properties to Controller
ClassNameHandlerMapping
* added "getActualValue()" method to BindStatus, exposing the raw property value
for comparison purposes
* added "exposeModelAttributes" property to RedirectView, allowing to suppress m
odel exposure completely
* added "exposeContextBeansAsAttributes" property to InternalResourceView and In
ternalResourceViewResolver
* JstlView sets "exposeContextBeansAsAttributes" to "true" by default, allowing
JSTL expressions to access Spring beans
* factored out a "loadReport()" method in AbstractJasperReportsView (called by "
initApplicationContext()")
* revised AbstractJasperReportsView to allow for obtaining a report dynamically
(through overriding "getReport()")
* TagWriter in JSP AbstractFormTag reobtains the Writer from the PageContext all
the time (for FreeMarker compatibility)
* introduced "modelAttribute" property for JSP FormTag, superseding the "command
Name" property for general purposes
* JSP SelectTag, OptionTag and OptionsTag properly detect a selected value even
for Maps with converted keys
* JSP CheckboxTag caches converted candidate value when comparing it with collec
tion elements
* introduced JSP CheckboxesTag (form:checkboxes) and RadioButtonsTag (form:radio
buttons)
* JSF 1.1 DelegatingVariableResolver checks Spring bean match first (analogous t
o JSF 1.2 DelegatingFacesELResolver)
Changes in version 2.1 M4 (2007-09-09)

--------------------------------------
General
* updated build to use JUnit 4.4 for the tiger test suite while sticking with JU
nit 3.8 for the main test suite
* moved GlassFish and OC4J instrumentation support from spring-context-support.j
ar to spring-context.jar
* renamed spring-mock.jar to spring-test.jar, reflecting the focus on the test c
ontext framework
* factored out Struts 1.x support (including Tiles 1.x support) into spring-webm
vc-struts.jar
* Spring-style pattern matching ("*xxx", "xxx*", "*xxx*") supports multi-part pa
tterns as well now ("xxx*yyy")
* ProxyFactoryBean and AbstractSingletonProxyFactoryBean are serializable if the
ir target and interceptors are
* made parts of ReflectiveMethodInvocation and other internal impl classes publi
c again (for framework integration)
* "AopNamespaceUtils.registerAutoProxyCreatorIfNecessary" registers a plain Infr
astructureAdvisorAutoProxyCreator now
* "target()" pointcut handles types implemented in superclasses correctly
* "aop:scoped-proxy" applies a specified "autowire-candidate" flag to the proxy
* TypeConverterDelegate protects its value conversion step against PropertyEdito
rs which don't support "setValue" calls
* TypeConverterDelegate falls back to "toString()" conversion for a primitive va
lue type if the required type is String
* changed visibility of PropertyEditorRegistrySupport's "getDefaultEditor(requir
edType)" method to public
* PropertyEditorRegistrySupport's "copyCustomEditorsTo" copies all editors if 'n
estedProperty' argument is null
* exposed "String[] getDependentBeans(beanName)" method on ConfigurableBeanFacto
ry interface
* introduced "String[] getDependenciesForBean(beanName)" method on ConfigurableB
eanFactory interface
* DefaultSingletonBeanRegistry uses a concurrent Map for managing dependent bean
s, avoiding unnecessary synchronization
* removed superseded ResourceFactoryBean (String-to-Resource conversion has been
implicitly available for years)
* added overloaded "createBean(beanClass)" method to AutowireCapableBeanFactory
interface
* introduced "registerResolvableDependency" method on ConfigurableListableBeanFa
ctory interface
* introduced qualifier support, allowing to use custom parameter annotations for
identifying specific target beans
* introduced AutowireCandidateResolver mechanism and QualifierAnnotationAutowire
CandidateResolver implementation
* reworked Annotated/ScannedRootBeanDefinition into Annotated/ScannedGenericBean
Definition
* fixed AbstractBeanFactory's type check to ignore a null value (as potentially
exposed by a FactoryBean)
* fixed AbstractBeanFactory to never cache FactoryBean-exposed objects for inner
beans (avoiding name conflicts)
* optimized DefaultListableBeanFactory's shortcut access to cached merged bean d
efinitions
* optimized DefaultListableBeanFactory's resolution of bean references during pr
ototype creation
* DefaultListableBeanFactory performs SmartFactoryBean eager-init check even if
the FactoryBean singleton already exists
* CommonAnnotationBeanPostProcessor falls back to default type match if no bean
found for @Resource field/property name
* Common/Autowired/PersistenceAnnotationBeanPostProcessor reject injection annot
ations on static fields/methods
* factored out "isCandidateComponent(beanDefinition)" template method in ClassPa
thScanningCandidateComponentProvider
* ClassPathBeanDefinitionScanner does not apply scoped-proxy setting to prototyp
es (only to extended scopes)
* scoped inner beans are now eligible for scoped destruction callbacks, despite
not living as scoped attributes
* "spring-beans-2.1.xsd" supports "default-autowire-candidates" attribute, accep
ting Spring-style bean name patterns
* AbstractApplicationContext registers BeanFactory, ApplicationContext etc as re
solvable dependency types for @Autowired
* fixed AbstractApplicationContext's temporary ClassLoader to work for by-type a
utowiring in ApplicationListeners etc
* AbstractApplicationContext propagates "start()"/"stop()" call to LifecycleBean
s according to inter-bean dependencies
* AbstractApplicationContext sends ContextStartedEvent/ContextStoppedEvent when
propagating "start()"/"stop()" call
* factored out protected "openStreamForClass" template method in OverridingClass
Loader
* PathMatchingResourcePatternResolver's static "logger" variable is private now
* PathMatchingResourcePatternResolver detects Oracle OC4J's "code-source" URLs a
s jar files now
* strengthened SQLExceptionTranslator's contract to define root cause handling f
or returned DataAccessExceptions
* added batch update support to SimpleJdbcTemplate
* added new SimpleJdbcInsert and SimpleJdbcCall classes to provide ease-of-use f
or inserts and stored procedure calls
* MessageListenerAdapter logs at warn level if a listener method returned a resu
lt but no response message can be sent
* added BeanFactoryDestinationResolver, for use with "jms:listener-container"'s
"destination-resolver" attribute
* added "message-converter" attribute to "jms:listener-container/jca-listener-co
ntainer" XML configuration element
* added "response-destination" attribute to "jms:listener" element, defining a d
efault in case of no JMSReplyTo header
* HibernateJdbcException extracts the SQL statement and explicitly builds it int
o the exception message
* introduced EntityManagerProxy interface, allowing access to underlying EntityM
anager for shared/extended EM proxies
* container-managed extended EntityManager gets explicitly closed on destruction
of the containing bean
* PersistenceUnitReader checks for well-known explicit schema resource locations
instead of searching the classpath
* revised JpaTransactionManager to convert JPA RollbackExceptions into Spring Tr
ansactionSystemExceptions
* JpaTransactionManager provides fine-grained commit exceptions through translat
ing JPA RollbackException root causes
* HibernateJpaDialect translates native HibernateExceptions (introspecting them
as root causes of PersistenceExceptions)
* added savepoint support to JpaDialect, implemented by OpenJpaDialect, supporte
d by JpaTransactionManager
* OpenJpaDialect exposes a special JDBC ConnectionHandle that immediately return
s the Connection to the EntityManager
* OpenJpaVendorAdapter supports OpenJPA 1.0.0 (exposing the full OpenJPAEntityMa
nagerSPI interface)
* LocalJaxRpcServiceFactory trims whitespace from "namespaceUri" values
* ScriptCompilationException carries the ScriptSource of the offending script
* GroovyScriptFactory passes script source description to GroovyClassLoader.pars
eClass (for descriptive error messages)
* added "autowire" and "dependency-check" attributes to "lang:bsh/jruby/groovy"
XML configuration elements
* fixed AbstractSpringContextTests's "hasCachedContext" implementation to use th
e context key String translation
* reduced AbstractTransactionalSpringContextTests's log level for transaction ma
nagement from INFO to DEBUG
* introduced annotation-oriented test context framework based on test execution
listeners
* introduced JUnit4 support (SpringJUnit4ClassRunner) based on the new test cont
ext framework
* fixed "tx:annotation-driven" to not activate "aop:config"-style autodetection
of application-defined Advisor beans
* ModelMap extends LinkedHashMap, exposing model elements in registration order
* "ClassUtils.forName" supports the JDK's internal names for primitive array cla
sses as well (for JMX compatibility)
* ReflectionUtils provides a "findMethod" variant without parameter types argume
nt
* RequestContext uses a full ResourceBundleThemeSource as default again (for bac
kwards compatibility)
* RequestContext lazily obtains the Theme instance (for more efficiency when the
me support is not used)
* AbstractView does not log static attributes anymore, in order to allow for sco
ped proxies to be used as attributes
* factored out protected "isEligibleProperty(key, value)" template method in Red
irectView
* RedirectView only exposes Strings, primitives and primitive wrappers as query
properties by default
* JstlView properly allows for programmatic usage (added overloaded constructors
; exposing a MessageSource is optional)
* InternalResourceViewResolver uses JstlView as default (instead of InternalReso
urceView) if the JSTL API is present
* JSP MessageTag resolves arguments in default text even if no message code was
specified
* JSP tags in the form tag library default to htmlEscape=true in case of no defa
ultHtmlEscape setting given
* added support for Tiles2 in the "org.springframework.web.servlet.view.tiles2"
package (requiring Tiles 2.0.4+)
* JasperReports View classes support JasperReports 2.0 while remaining compatibl
e with JasperReports 1.3

--------------------------------------
General
* fixed and updated reference documentation on JMS listener container configurat
ion and transaction participation
* Cglib2AopProxy uses weak references for advised object, interceptors and valid
ated classes (avoiding a memory leak)
* ProxyFactoryBean avoids NPE in case of target class being null (due to misconf
iguration)
* fixed AspectJ pointcut handling to resolve bridge methods before matching
* fixed AspectJ pointcut handling to correctly match generic return types
* added support for "bean(name)" element in AspectJ pointcut expressions
* ReflectiveMethodInvocation, BeanFactoryAdvisorRetrieval and other internal imp
l classes are just package-visible now
* the pointcut element's "id" attribute is required as of the 2.1 version of the
AOP namespace (spring-aop-2.1.xsd)
* aop:aspectj-autoproxy's "proxy-target-class" attribute properly escalates clas
s proxying (not overriding the setting)
* ConfigBeanDefinitionParser turns "pointcut" attribute into inner bean definiti
on (instead of ref to an anonymous bean)
* fixed ConfigBeanDefinitionParser to properly handle empty pointcut/advice bean
names in a tooling environment
* added "getAspectClassLoader()" method to AspectInstanceFactory interface
* revised reflective class loading to use the correct ClassLoader according to t
he OSGi bundle structure (if any)
* declare-parents allows specifying "delegate-ref" to delegate introductions to
a bean as alternative to "default-impl"
* added "charsToDelete" and "emptyArrayAsNull" options to StringArrayPropertyEdi
tor
* URIEditor trims whitespace before parsing the URI (allowing for XML formatting
with whitespace)
* BeanWrapperImpl lazily performs JavaBeans introspection (avoiding introspectio
n failure for non-visible target class)
* TypeConverterDelegate protects its collection conversion process against misbe
having Collections with a null Iterator
* TypeConverterDelegate only attempts to convert well-known collection types (sk
ips custom types in the first place)
* PropertyBatchUpdateException synchronizes on PrintStream/PrintWriter (like the
JDK 1.6 Throwable class does)
* BeanFactoryUtils uses linked HashMaps for "beansOfTypeIncludingAncestors", pre
serving "getBeansOfType" order
* added "isEagerInit()" method to SmartFactoryBean interface, making post-proces
sors apply to an exposed object eagerly
* exposed "getBean(name, args)" method on BeanFactory interface
* exposed "BeanDefinition getMergedBeanDefinition(beanName)" method on Configura
bleBeanFactory interface
* exposed "isFactoryBean" and "registerDependentBean" methods on ConfigurableBea
nFactory interface
* introduced "isAutowireCandidate" method on ConfigurableListableBeanFactory int
erface
* passing in explicit arguments for bean creation is supported for constructors
as well (not just for factory methods)
* passing in different combinations of explicit arguments is supported for overl
oaded factory methods and constructors
* PropertyPathFactoryBean supports a null property value (removed historic restr
iction there)
* exposed "parentName", "factoryBeanName" and "factoryMethodName" properties in
BeanDefinition interface
* added "visitParentName", "visitFactoryBeanName" and "visitFactoryMethodName" c
allbacks to BeanDefinitionVisitor
* PropertyPlaceholderConfigurer resolves placeholders in parent, factory-bean an
d factory-method values as well
* fixed AbstractBeanFactory to correctly handle factory-bean references in case
of a temporary ClassLoader being used
* DefaultListableBeanFactory ignores invalid parent bean names when matching bea
ns by type with allowEagerInit=false
* DefaultListableBeanFactory only ignores invalid bean class names when matching
beans by type with allowEagerInit=false
* DefaultListableBeanFactory does not invoke custom init/destroy method twice if
pointing to Initializing/DisposableBean
* DefaultListableBeanFactory allows for concurrent "registerBeanDefinition" call
s after the configuration phase
* bean creation records suppressed exceptions, exposing them as related causes i
n a subsequent BeanCreationException
* added "setTypeConverter" method to ConfigurableBeanFactory, allowing to overri
de the default PropertyEditor mechanism
* introduced "removeBeanDefinition" method in BeanDefinitionRegistry interface a
nd DefaultListableBeanFactory class
* exposed "isBeanNameInUse" method on BeanDefinitionRegistry interface
* AbstractBeanFactory supports any BeanDefinition implementation (does not requi
re AbstractBeanDefinition anymore)
* reworked AbstractBeanFactory's bean definition merging for less coupling to Ro
otBeanDefinition as merge result
* introduced GenericBeanDefinition as one-stop shop for standard bean definition
purposes (with configurable parent)
* DefaultBeanNameGenerator does not require an AbstractBeanDefinition implementa
tion for bean name generation anymore
* DefaultBeanNameGenerator generates a "#0" suffix in the canonical name even fo
r the first occurence of an unnamed bean
* added "resolveDependency" methods to AutowireCapableBeanFactory interface
* @Autowired annotation ignores target beans marked as autowire-candidate="false
" (analogous to standard autowiring)
* added autowiring by type for arrays, collections, maps (available for @Autowir
ed, 'constructor', 'byType' autowiring)
* Autowired/CommonAnnotationBeanPostProcessor registers autowired beans as depen
dent on their injected target bean
* AnnotationBeanConfigurerAspect proceeds without injection in case of a circula
r reference problem, logging a warning
* added "registerBeanComponent" convenience method to ParserContext
* changed visibility of BeanDefinitionParserDelegate's "buildTypedStringValue(Fo
rMap)" methods to protected
* AspectJWeavingEnabler implements Ordered, exposing HIGHEST_PRECEDENCE (executi
ng before other factory post-processors)
* moved AnnotationConfigUtils to "context.annotation" package (post-processor be
ans are a context-specific feature)
* "context:annotation-config" XML tag activates JPA's @PersistenceContext and @P
ersistenceUnit as well (if available)
* AnnotationConfig/ComponentScanBeanDefinitionParser sends component registratio
n for each registered BeanPostProcessor
* AnnotationBeanNameGenerator does not silently adapt the default bean name in c
ase of overlap anymore
* "context:spring-configured" registers its bean configurer aspect with a fixed
internal bean name
* added "maxElementsOnDisk" bean property to EhCacheFactoryBean, supporting EHCa
che 1.2.4's extended Cache constructor
* added "isAtLeastJava16()" convenience method to JdkVersion class
* OverridingClassLoader (and hence SimpleThrowawayClassLoader) exclude classes f
rom the "sun." package
* fixed PathMatchingResourcePatternResolver to build correct JarFile URLs on Web
Logic and WebSphere
* PathMatchingResourcePatternResolver uses a static Log instance in order to avo
id repeated synchronization overhead
* turned visibility of AbstractEnterpriseBean and AbstractSessionBean to public
(showing up in the javadoc now)
* added "excludePackage" and "excludeClass" methods to ShadowingClassLoader, ana
logous to OverridingClassLoader
* added exception translation based on SQLException subclasses introduced in Jav
a 6
* added additional exceptions to divide hierarchy into Recoverable, Transient an
d NonTransient exceptions
* added support for arrays of values in parameter value lists: "select * from t
where (a, b) in ((1,'x'), (3,'y'))"
* added DerbyMaxValueIncrementer to provide an alternative for autoGeneratedKeys
used with IDENTITY columns
* added HsqlSequenceMaxValueIncrementer to support sequences now added to HSQL
* added H2SequenceMaxValueIncrementer to support sequences in H2 Database
* SingleConnectionFactory sets client ID before ExceptionListener (for providers
with strict Connection state handling)
* added "receiveTimeout" property to JmsInvokerClientInterceptor/ProxyFactoryBea
n (with reimplemented request execution)
* listener-container type "default102"/"simple102" leads to the implicit choice
of MessageListenerAdapter102
* MBeanExporter unregisters its MBeans in case of any kind of registration failu
re
* MBeanExporter accepts bean name keys in NotificationListener mappings (in addi
tion to ObjectName Strings)
* HibernateTemplate delegates to "SessionFactory.getCurrentSession()" when "allo
wCreate" has been set to "false"
* added overloaded "findByExample" methods with entityName argument to Hibernate
Operations/HibernateTemplate
* deprecated HibernateTemplate's "saveOrUpdateAll" method in favor of individual
"saveOrUpdate"/"merge" usage
* fixed Hibernate/JpaTransactionManager to clean up properly in case of transact
ion begin failure on pre-bound resource
* added "prepareTransaction" method to JpaDialect interface, for preparing a JTA
-joining EntityManager
* HibernateJpaDialect switches FlushMode to MANUAL in case of a read-only transa
ction even for JTA
* PersistenceAnnotationBeanPostProcessor registers autowired beans as dependent
on their EntityManagerFactory
* ExtendedEntityManagerCreator's "joinTransaction()" checks whether there is an
externally managed local transaction
* ExtendedEntityManagerCreator's EntityManager proxies are serializable now
* MockHttpServletResponse automatically flushes the Writer in case of a "write(i
nt)" call too
* RmiClientInterceptor and JaxRpcClientInterceptor propagate any kind of declare
d RemoteException as-is
* (Jndi)RmiClientInterceptor resets stub before a refresh attempt, avoiding race
condition in case of registry restart
* JndiRmiClientInterceptor wraps CORBA SystemExceptions in RemoteExceptions (if
declared)
* added "waitForTasksToCompleteOnShutdown" property to ScheduledExecutorFactoryB
ean
* changed ScheduledExecutorFactoryBean's default behavior to shutdown immediatel
y, not waiting for scheduled tasks
* updated JRuby support for JRuby 1.0 compatibility (still compatible with JRuby
0.9.8 / 0.9.9 as well)
* AbstractDependencyInjectionSpringContextTests allows for annotation-driven aut
owiring (even in case of AUTOWIRE_NO)
* Quartz SchedulerFactoryBean does not set default AdaptableJobFactory in case o
f RemoteScheduler (not supported there)
* "lang:*" configuration elements create their implicit ScriptFactoryPostProcess
or under a fully qualified bean name
* refined TransactionAspectSupport to allow for overriding the "getTransactionMa
nager()" method in subclasses
* TransactionInterceptor only uses ThrowableHolderException if necessary and mak
es sure to expose the cause in any case
* "tx:annotation-driven" registers its transaction aspect with a fixed internal
bean name
* fixed "StringUtils.parseLocaleString" to parse multiple variants correctly
* DefaultPropertiesPersister detects and uses JDK 1.6's "Properties.load/store"
variants with Reader/Writer argument
* added overloaded "rejectIfEmpty(OrWhitespace)" methods with args but without d
efault message to ValidationUtils
* factored out "invokeDelegate" template method in DelegatingFilterProxy
* fixed Servlet/PortletContextResourcePatternResolver to correctly match bounded
patterns
* fixed FrameworkServlet to always refresh its BeanNameUrlHandlerMapping with th
e correct context
* added "postProcessWeb/PortletApplicationContext" method to FrameworkServlet/Po
rtlet
* DispatcherServlet/Portlet's "noHandlerFound" declares Exception instead of jus
t IOException/PortletException
* added "addInterceptor" and "addInterceptors" methods to Servlet/Portlet Handle
rExecutionChain
* AbstractUrlHandlerMapping exposes "path within mapping" attribute through an i
nterceptor (for proper include cleanup)
* AbstractWizardFormController's "showForm" method is not final anymore (can be
overridden e.g. for exception handling)
* added "transformerFactoryClass" property and "newTransformerFactory()" templat
e method to (Abstract)XsltView
* added "accept-charset" support to JSP FormTag
* fixed JSP CheckboxTag to apply the custom PropertyEditor (if any) to rendered
values

--------------------------------------
General
* removed support for Hibernate 2.1; Spring's Hibernate support generally requir
es Hibernate 3.1 or higher now
* spring-context.jar includes JMX support and core remoting support (no spring-j
mx and spring-remoting jars anymore)
* spring-orm.jar combines all ORM support packages (replaces spring-jdo, spring-
jpa, spring-hibernate etc jars)
* spring-web.jar contains web-related remoting and ORM classes (for proper use i
n J2EE EAR deployment structures)
* renamed spring-dao.jar to spring-tx.jar, also containing the JCA support now
* renamed spring-support.jar to spring-context-support.jar
* renamed spring-portlet.jar to spring-webmvc-portlet.jar
* module jar files contain module-specific "spring.handlers" and "spring.schemas
" files now
* added missing websphere_uow_api.jar to -with-dependencies distribution
* ReflectiveMethodInvocation always uses a shared user attribute Map in clones (
for proper binding of multiple advices)
* fixed MethodInvocationProceedingJoinPoint to properly pass modified arguments
(via proceed) to subsequent aspects
* fixed AbstractAspectJAdvisorFactory to ignore 'code-style' aspect classes that
have been compiled by ajc
* "aop:aspectj-autoproxy" XML configuration tag detects all aspect beans in case
of empty XML body content as well
* moved "aop:spring-configured" to context namespace ("context:spring-configured
") in the 2.1 versions of the XSDs
* CustomBooleanEditor trims text before comparing against true/false Strings
* added temporary ClassLoader support to ConfigurableBeanFactory / AbstractBeanF
actory
* mirrored FactoryBean's "getObjectType()" as abstract method in AbstractFactory
Bean again, for @Override compatibility
* reworked SmartInstantiationAwareBeanPostProcessor's "determineConstructor" hoo
k into "determineCandidateConstructors"
* added "resolveAliases" method to ConfigurableBeanFactory, applying a given Str
ingValueResolver
* PropertyPlaceholderConfigurer applies its placeholder parsing to alias target
names and aliases as well
* PropertyResourceConfigurer (and in particular PropertyPlaceholderConfigurer) i
s marked as PriorityOrdered
* BeanWiringInfo and ClassName/AnnotationBeanWiringInfoResolver support the noti
on of a 'default' bean name
* @Configurable applies factory callbacks (BeanFactoryAware, InitializingBean et
c) and post-processors as well
* @Configurable applies factory callbacks and post-processors if no bean definit
ion found for default bean name
* DefaultListableBeanFactory clears a cached merged bean definition in case of r
e-registering a bean definition
* AbstractBeanDefinition declares a public "clone()" method as well as "Abstract
BeanDefinition cloneBeanDefinition()"
* AbstractBeanDefinition excludes purely descriptive metadata from its equals ch
eck (for more lenient equality)
* fixed BeanDefinitionParserDelegate to avoid NPE in case of a custom namespace
without a NamespaceHandler registered
* fixed BeanDefinitionParserDelegate to extract correct source element for "key-
ref"/"value-ref" attributes
* added 'required' attribute to @Autowired annotation (configurable for a custom
autowire annotation as well)
* avoid double invocation of @Autowired/@Resource setter method in case of expli
citly specified property value
* InitDestroy/Common/AutowiredAnnotationBeanPostProcessor use ConcurrentHashMaps
for minimal locking
* introduced AnnotatedBeanDefinition interface and AnnotatedRootBeanDefinition i
mplementation class
* added support for the JDK 1.6 ServiceLoader facility (package "beans.factory.s
erviceloader")
* EhCacheFactoryBean applies a specified CacheEntryFactory to an existing cache
region as well
* AbstractApplicationContext instantiates and applies priority-ordered Bean(Fact
ory)PostProcessors first
* AbstractApplicationContext creates all non-ordered BeanPostProcessors first be
fore registering them with the factory
* AbstractApplicationContext sets a temporary ClassLoader for type matching if a
bean named "loadTimeWeaver" is defined
* added LoadTimeWeaverFactoryBean, building a default LoadTimeWeaver (autodetect
ing the runtime environment)
* added LoadTimeWeaverAware interface, automatically supported if a default Load
TimeWeaver is available
* added AspectJWeavingEnabler, registering AspectJ's class transformer for stand
ard AspectJ load-time weaving
* added "context:load-time-weaver" XML tag, building a default LoadTimeWeaver an
d enabling AspectJ load-time weaving
* introduced ScannedRootBeanDefinition class for autodetected components
* added @Scope annotation for autodetected components, indicating the target bea
n scope in the Spring context
* reworked ClassPathBeanDefinitionScanner into subclass of ClasspathScanningCand
idateComponentProvider
* ClassPathBeanDefinitionScanner provides "addIncludeFilter" etc config methods
instead of overloaded "scan" methods
* reworked ComponentBeanNameGenerator into AnnotationBeanNameGenerator, handling
@Repository name values as well
* explicit bean names indicated by autodetected components are enforced, only to
be overridden by explicit definitions
* updated NestedXxxException to build on JDK 1.4 exception chaining, adding exte
nded messages and convenience accessors
* introduced PriorityOrdered marker interface, with order values automatically a
pplied before any plain Ordered values
* fixed BridgeMethodResolver to properly detect a method that substitutes a type
parameter with an array type
* fixed BridgeMethodResolver to detect type variables in interface hierarchies w
ith different type variable names
* added "getClassLoader()" method to ClassPathResource, exposing the ClassLoader
used for resource loading
* PathMatchingResourcePatternResolver avoids full subtree scan through skipping
non-matching directory paths early
* PathMatchingResourcePatternResolver explicitly closes freshly created JarFile
handles, to allow for hot redeployment
* introduced ClassMetadata/AnnotationMetadata abstraction in "core.type" package
* refactored "core.typefilter" package into "core.type.asm" and "core.type.filte
r"
* introduced ClassReaderFactory abstraction, with SimpleClassReaderFactory and C
achingClassReaderFactory implementations
* introduced ClassReaderFactory as TypeFilter match argument, for resolving cach
ed ClassReaders for the type hierarchy
* moved FilterType enum to "context.annotation" package, since it is closely rel
ated to component scanning
* introduced AnnotatedBeanDefinition interface and AnnotatedRootBeanDefinition i
mplementation class
* introduced ScannedRootBeanDefinition class for autodetected components
* StringCodedLabeledEnum accepts empty codes (that purely consist of whitespace)
as well
* added named parameter support to SimpleJdbcTemplate
* added ParameterizedBeanPropertyRowMapper, providing automatic mapping between
columns and bean properties
* added new SqlReturnUpdateCount parameter to provide name for update counts fro
m stored procedures
* added stored procedure support for retrieving update counts and storing the re
trieved int in the output map
* added automatic processing of stored proc returned resultsets (will create def
ault one if declared parameter missing)
* added automatic processing of stored proc update counts (will create default o
ne if declared parameter missing)
* MBeanExporter does not insist of a minimum of 1 bean exposed anymore, also acc
epting no beans to export in the context
* JavaMailSenderImpl sets the original message id (if specified in the given Mim
eMessage) after "message.saveChanges()"
* added MockJspWriter and MockBodyContent classes for testing content-emitting J
SP tags
* MockPageContext supports the "getOut()" method, exposing a MockJspWriter
* LocalContainerEntityManagerFactoryBean and DefaultPersistenceUnitManager autod
etect a context's default LoadTimeWeaver
* avoid double invocation of @PersistenceContext/Unit setter method in case of e
xplicitly specified property value
* marked DelegatingTransactionAttribute as Serializable
* added mode="proxy"/"aspectj" flag to "tx:annotation-driven" config tag, for ch
oosing the AspectJ transaction aspect
* WebSphereUowTransactionManager does not enforce the presence of a JTA UserTran
saction anymore
* WebSphereTransactionManagerFactoryBean uses the context class loader for compa
tibility with the WSAD 5.1 test server
* added "makeAccessible(Method)" and "makeAccessible(Constructor)" convenience m
ethods to ReflectionUtils
* added "matchStart" method to PathMatcher interface and AntPathMatch implementa
tion, for checking the start of a match
* added "getDescription" method to WebRequest interface
* ServletWebRequest and PortletWebRequest expose a descriptive "toString()" resu
lt (including URI, session id, user id)
* added "includeClientInfo" flag to AbstractRequestLoggingFilter, for including
client address and session id in the log
* added Log4jNestedDiagnosticContextInterceptor for use with Servlet and Portlet
MVC
* CookieLocaleResolver checks specified "defaultLocale" in case of a setLocale c
all with null argument
* RequestContext uses a shared default Theme instance as fallback, avoiding the
recreating of empty Theme instances
* MultiActionController explicitly disallows direct invocation of exception hand
ler methods (as handler methods)
* CancellableFormController suppresses validation for a cancel request
* AbstractView and AbstractTemplateView pass an explicit ServletContext referenc
e to a created RequestContext instance
* changed AbstractTemplateView(Resolver)'s "exposeSpringMacroHelpers" default to
"true"
* JSP FormTag exposes full nested path for compatibility with Spring's standard
BindTag
* JSP TransformTag is able to work within JSP SelectTag etc as well, not just wi
thin BindTag

--------------------------------------
General
* Spring is built on JDK 1.6 now, with support for common Java 6 APIs / Java EE
5 APIs
* Spring requires JDK 1.4 or higher now, not supporting JDK 1.3 anymore (JDK 1.3
has reached its official end-of-life)
* Spring's Hibernate3 support generally requires Hibernate 3.1 or higher (note:
there's separate Hibernate 2.1 support)
* fixed contents of spring-remoting.jar: does not include RemoteInvocationUtilsT
ests anymore
* removed Perl5RegexpMethodPoint and RegexpMethodPointcutAdvisor's "perl5" flag
(always using java.util.regex now)
* introduced InitDestroyAnnotationBeanPostProcessor, processing configurable ini
t and destroy annotations
* introduced CommonAnnotationBeanPostProcessor, processing JSR-250's @PostConstr
uct, @PreDestroy and @Resource
* introduced @Autowired annotation, indicating that a field, config method or co
nstructor is supposed to be autowired
* introduced AutowiredAnnotationBeanPostProcessor, processing the new @Autowired
annotation
* fixed AbstractAutowireCapableBeanFactory to allow for changing the Instantiant
ionStrategy (again)
* deprecated BeanDefinitionReader's "BeanDefinitionRegistry getBeanFactory()" me
thod in favor of "getRegistry()"
* exposed "getBeanNameGenerator()" method in BeanDefinitionReader interface
* changed XmlReaderContext's "getReader()" method to expose the plain BeanDefini
tionReader interface
* added "getResourceLoader()" convenience method to XmlReaderContext, exposing t
he context's ResourceLoader (if any)
* added "getBeanClassLoader()" convenience method to XmlReaderContext
* introduced CandidateComponentProvider mechnism, for finding annotated componen
t classes through scanning the classpath
* introduced "context" XML schema namespace, providing a "property-placeholder"
convenience tag
* introduced convenient tags for annotation-based configuration as part of the "
context" namespace
* removed deprecated ConsoleListener class
* introduced the "core.typefilter" package, for ASM-based scanning of class file
s
* introduced GenericMessageEndpointManager for JCA 1.5 message endpoint manageme
nt, plus supporting infrastructure
* introduced SpringContextResourceAdapter, for deploying a Spring application co
ntext as JCA 1.5 RAR file
* added BootstrapContextAware interface, as a callback in a JCA 1.5 resource ada
pter environment
* AbstractDataSource and DelegatingDataSource support the JDBC 4.0 Wrapper inter
face
* added Jdbc4NativeJdbcExtractor, delegating to JDBC 4.0's "unwrap" method (defi
ned by java.sql.Wrapper)
* added "streamAsLob" flag to DefaultLobHandler, allowing for explicit usage of
the JDBC 4.0 setBlob/setClob variants
* fixed SQLErrorCodeSQLExceptionTranslator to avoid potential NPE in debug log m
essage
* added BeanPropertyRowMapper, providing automatic mapping between columns and b
ean properties
* moved "isInputValueProvided" method from SqlOutParameter up to the SqlParamete
r root class
* fixed RdbmsOperation's "validateParameters" to properly detect and count input
-providing SqlOutParameters
* added JmsMessageEndpointManager, extending GenericMessageEndpointManager with
the JmsActivationSpecFactory mechanism
* added StandardJmsActivationSpecFactory, supporting all standard JMS propertied
as defined by the JCA 1.5 specification
* added DefaultJmsActivationSpecFactory, autodetecting ActiveMQ and JORAM's Acti
vationSpecs and extended properties
* introduced "jms" XML schema namespace, providing convenient tags for listener
container configuration
* default MBean checks in JmxUtils and MBeanExporter automatically detect a Java
6 MXBean as well
* added SimpleJndiBeanFactory to "jndi.support" package, providing a JNDI-based
BeanFactory implementation
* removed CosMailSenderImpl (as part of generally removing COS support from the
Spring codebase)
* added support for Servlet 2.5's "getContextPath()" method to MockServletContex
t
* Hibernate LocalSessionFactoryBean prefers a Hibernate 3.1 CurrentSessionContex
t now, instead of a SessionFactory proxy
* Hibernate3 AbstractSessionFactoryBean's "exposeTransactionAwareSessionFactory"
to refer to a SpringSessionContext now
* added TransactionFactory interface to "jta" subpackage, abstracting the creati
on of specific JTA Transaction objects
* JtaTransactionManager and WebLogic/OC4JJtaTransactionManager implement the Tra
nsactionFactory interface accordingly
* JtaTransactionManager autodetects and uses JTA 1.1's TransactionSynchronizatio
nRegistry (e.g. on Java EE 5)
* added WebSphereUowTransactionManager, supporting full transaction management v
ia IBM's UOWManager API on WAS 6.0/6.1
* removed WAS 4.0/5.0 support from WebSphereTransactionManagerFactoryBean, keepi
ng it for WAS 5.1 support only
* removed outdated WebLogicServerTransactionManagerFactoryBean (for WebLogic 7.0
)
* removed deprecated BindInitializer and BindUtils from the "bind" package
* removed deprecated "setFilterConfig" method from GenericFilterBean (no WebLogi
c 6.1 compatibility necessary anymore)
* removed CosMultipartResolver (as part of generally removing COS support from t
he Spring codebase)
* introduced explicit JSF 1.2 support (web.jsf.el): DelegatingFacesELResolver an
d WebApplicationContextFacesELResolver
* JSP InputTag, SelectTag etc support expressions as "disabled" and "readonly" a
ttribute values

-------------------------------------
* DelegatingIntroductionInterceptor only replaces a return value with the proxy
if the proxy is actually assignable
* JdkDynamic/Cglib2AopProxy only replaces return value with proxy if declaring c
lass is not marked for raw target access
* AbstractRefreshableTargetSource's "getTargetClass()" method is properly synchr
onized
* ScopedObject's "getTargetObject()" method returns the actual target object now
(instead of the proxy object)
* fixed "aop:scoped-proxy" tag to properly apply to defined alias names as well
* BeanWrapper doesn't iterate over Collection/Map if no generic type declared an
d no property-specific editor registered
* BeanWrapper converts an empty String to null in case of a Java 5 enum as targe
t type
* default editor settings get copied to nested beans even if no default editors
have been used yet
* revised MethodInvokingFactoryBean's "getObjectType()" implementation to gracef
ully return null if not prepared already
* added "determineConstructor(beanClass, beanName)" method to SmartInstantiation
AwareBeanPostProcessor
* AbstractBeanFactory's "containsBean"/"isSingleton"/"isTypeMatch"/etc behave co
rrectly for "&" FactoryBean dereferences
* AbstractBeanFactory uses concurrent Maps for singletons, aliases and bean defi
nitions (for better concurrency)
* DefaultListableBeanFactory finds initialized FactoryBeans / factory-bean refer
ences in case of allowEagerInit=false
* fixed ConstructorResolver to correctly convert prepared collection arguments t
o arrays if necessary (for prototypes)
* added overloaded "rootBeanDefinition" factory methods with bean class name (in
stead of Class) to BeanDefinitionBuilder
* an (undefined) null value returned from a NamespaceHandler's "decorate" method
is treated as 'no decoration required'
* XmlBeanDefinitionReader caches the DefaultNamespaceHandlerResolver instance, s
haring it across multiple files
* added "getBeanClassName" template method to AbstractSingleBeanDefinitionParser
, as alternative to "getBeanClass"
* added "scope" attribute to "util:list", "util:set", "util:map" and "util:prope
rties", allowing for scoped collections
* factored out fine-grained protected template methods from AbstractApplicationC
ontext's "refresh()" implementation
* AbstractRefreshableApplicationContext actually calls the 2.0.3-introduced "cus
tomizeBeanFactory" template method
* BridgeMethodResolver is able to match open type variables in complex overloadi
ng scenarios as well
* BridgeMethodResolver caches based on TypeVariable references, handling overlap
ping type variable names appropriately
* added "createConcurrentMap" method to CollectionFactory, creating a JDK 1.5+ o
r backport-concurrent ConcurrentHashMap
* Constants class always uses upper-case transformation according to English not
ation
* added "toCodeForSuffix" operation to Constants class
* ShadowingClassLoader explicitly defines a package for all classes that it load
s, for "Class.getPackage()" to work
* fixed GeneratedKeyHolder to avoid NPE in exception message in case of a null k
ey returned by the JDBC driver
* fixed JdbcTemplate's fallback support for batch updates to properly handle Int
erruptibleBatchPreparedStatementSetters
* added scale support to SqlParameter, for declaring numeric RdbmsOperation para
meters with a specific scale
* added SqlParameterValue class, holding a value including SQL type and scale, a
ccepted by JdbcTemplate argument arrays
* optimized SQL parsing in NamedParameterUtils, NamedParameterJdbcTemplate and S
qlOperation through the use of caching
* added "execute" operation with PreparedStatementCallback argument to NamedPara
meterJdbcOperations/Template
* added overloaded "query" operations with ResultSetExtractor argument to NamedP
arameterJdbcOperations/Template
* SqlQuery and SqlUpdate accept named parameter declarations in arbitrary order
(not requiring positional declaration)
* SqlQuery and SqlUpdate accept unparameter declarations for named parameter usa
ge (assuming positional declaration)
* JndiDestinationResolver prefers a concurrent Map for caching purposes (for bet
ter concurrency)
* changed visibility of various AbstractMessageListenerContainer property access
ors from protected to public
* JmsInvokerClientInterceptor/ProxyFactoryBean and JmsInvokerServiceExporter sup
port a configurable MessageConverter
* TypeMismatchNamingException carries required type and actual type as explicit
attributes
* ExtendedEntityManagerCreator efficiently detects JTA through PersistenceUnitIn
fo's "transactionType" (if possible)
* PersistenceAnnotationBeanPostProcessor is able to resolve a lazy EntityManager
Factory via its unit name as well
* factored out "findEntityManagerFactory(ListableBeanFactory, unitName)" method
into EntityManagerFactoryUtils
* RemoteExporter shows "use reference, not value" error message in case of the s
pecified service object being a String
* added "replaceExistingBinding" property to RmiServiceExporter, allowing to tur
n off the automatic replacement strategy
* JndiRmiClientInterceptor/ProxyFactoryBean detects CORBA SystemExceptions and c
onverts them to RemoteAccessExceptions
* JndiRmiClientInterceptor/ProxyFactoryBean detects CORBA OBJECT_NOT_FOUND conne
ct failures and recovers accordingly
* MethodInvokingJobDetailFactoryBean avoids obtaining the target bean twice in c
ase of "targetBeanName" specified
* revised MethodInvokingJobDetailFactoryBean's error message to include the targ
et class instead of the target object
* DelegatingTimerTask catches any exception or error thrown from its delegate Ru
nnable, to make the Timer proceed
* added "continueScheduledExecutionAfterException" flag to ScheduledExecutorFact
oryBean, overriding the default behavior
* added "init-method" and "destroy-method" attributes on "lang:groovy/bsh/jruby"
, for init/destroy methods in scripts
* ScriptFactoryPostProcessor generates config interface methods for init/destroy
methods as well, if demanded
* AbstractTransactionalSpringContextTests' "onSetUp()"/"onTearDown()" are non-fi
nal, allowing for flexible overriding
* AbstractPlatformTransactionManager properly resumes 'foreign' existing synchro
nization even in case of begin failure
* revised OC4JJtaTransactionManager to support the "oracle.j2ee.transaction" pac
kage on OC4J later than 10.1.3.2
* ResourceBundleThemeSource will always return the same Theme instance for a giv
en theme name
* PathMatcher's javadoc defines the semantics of the "extractPathWithinPattern"
method in more detail
* AntPathMatcher's "extractPathWithinPattern" preserved a path's leading separat
or in case of a "*.html" pattern match
* ContextLoader loads parent context based on "parentContextKey" parameter, not
requiring "locatorFactorySelector" param
* DispatcherServlet/Portlet only refresh their strategies if their own Applicati
onContext refreshes
* made AbstractHandlerMapping's "setInterceptors" method non-final
* added "extendInterceptors" template method to AbstractHandlerMapping, for regi
stering additional interceptors
* UrlFilenameViewController and InternalPathMethodNameResolver prefer a concurre
nt Map for caching purposes
* added "mappedHandlerClasses" property to Servlet/Portlet SimpleMappingExceptio
nResolver, for mapping specific types
* factored out protected "shouldApplyTo" and "doResolveException" template metho
ds in SimpleMappingExceptionResolver
* added "localesToInitialize" property to ResourceBundleViewResolver, for initia
lizing common locales eagerly
* XmlViewResolver (and similar strategies) work again in combination with the im
plicit default BeanNameUrlHandlerMapping
* JSP FormTag escapes the entire query string, including the parameter separator
s
* JSP SelectTag always renders a full closing tag (i.e. never renders a short-ci
rcuited opening tag with "/>" ending)
* JSP SelectTag accepts null values for its attributes (doesn't strictly enforce
non-null values anymore)
* JSP OptionTag properly detects a Java 5 Enum as selected even in case of an ov
erridden "toString()" implementation
* FreeMarkerView exposes a ServletConfig object to FreeMarker, for use with Serv
letConfig-accessing JSP tags
* fixed AbstractXsltView to correctly apply a specified custom "contentType", ev
en in case of a stylesheet specified
* revised XsltView for Servlet 2.3 compatibility, avoiding the "HttpServletRespo
nse.setCharacterEncoding" method
* revised XsltView to respect a specified "contentType" property, using it if no
XSLT media type has been specified
* fixed XsltViewResolver to properly apply the "cacheTemplates" flag to created
XsltView instances
* revised AbstractJasperReportsView to accept a model without explicit data sour
ce as well (for Hibernate/JPA queries)
* PortletUtils' "getParametersStartingWith" method checks for an empty value arr
ay (WebSphere Portal 6.0 peculiarity)

-------------------------------------
* AbstractAutoProxyCreator caches advice information per bean, for efficient pro
totype creation with auto-proxying
* fixed AspectJAfterReturningAdvice to avoid NPE within returning type check in
case of the return value being null
* fixed AspectJAwareAdvisorAutoProxyCreator's "toString()" implementation to be
compatible with JDK 1.3/1.4
* AnnotationAwareAspectJAutoProxyCreator caches Advisors for singleton @Aspect a
spects, increasing performance
* introduced Simple(MetadataAware)AspectInstanceFactory, creating an independent
aspect instance on every invocation
* revised AspectJProxyFactory to avoid "spring-beans" dependencies, using Simple
MetadataAwareAspectInstanceFactory now
* AbstractAspectJAdvice lazily calculates argument bindings, avoiding a "spring-
beans" dependency (InitializingBean)
* "this" pointcut in AspectJ pointcut expressions is matched against the proxy o
bject rather than the target object
* PropertyEditorRegistrySupport/BeanWrapperImpl lazily registers default editors
when needed (to avoid init overhead)
* PropertyEditorRegistrySupport supports registration of shared editors, to allo
w for specific synchronization
* BeanWrapperImpl mimimizes bean name parsing overhead and caches parsed propert
y path tokens
* PatternEditor allows for customization through specifying "java.util.regex.Pat
tern" flags
* fixed PropertyPlaceholderConfigurer/BeanDefinitionVisitor to correctly handle
TypedStringValue objects with null value
* AbstractFactoryBean offers a protected "getBeanFactory()" method for accessing
its BeanFactory reference
* BeanReferenceFactoryBean returns null from "getObjectType()" if the BeanFactor
y has not been injected yet
* AbstractAutowireCapableBeanFactory uses "filteredPropertyDescriptorsCache" for
the PropertyDescriptor array per class
* DefaultListableBeanFactory is able to invoke public init and destroy methods o
n package-protected classes
* DefaultListableBeanFactory caches pre-converted property values as far as poss
ible
* DefaultListableBeanFactory allows placeholders in class names even for non-laz
y-init beans
* ConstructorResolver caches the resolved constructor or factory method, for fas
ter re-creation of prototype instances
* ConstructorResolver caches converted argument values, to avoid conversion over
head for re-created prototype instances
* DefaultNamespaceHandlerResolver logs linkage error at warn level, in case of a
handler class found but not loadable
* added "addApplicationListener" method to ConfigurableApplicationContext interf
ace, for statically registered listeners
* added "getNames", "getNamesForProperty", "getNamesForSuffix" and "getValuesFor
Suffix" methods to Constants
* fixed GenericCollectionTypeResolver to correctly navigate Map-List-List struct
ures with a nesting level of 3 or more
* BridgeMethodResolver performs multi-step resolution of type variables, for com
plex multi-type inheritance scenarios
* PersistenceExceptionTranslationInterceptor supports PersistenceExceptionTransl
ator autodetection in standalone mode
* added "setConnectionSpec" method and corresponding constructor to CciTemplate,
for specifying a spec at template level
* added "getDerivedTemplate(ConnectionSpec) method to CciTemplate, for obtaining
a template with just different con spec
* added "getCciTemplate(ConnectionSpec) method to CciDaoSupport, for obtaining a
template with just different con spec
* SqlOperation and its subclasses do not pre-parse for named parameters anymore,
accepting ":" in plain SQL strings
* added "isSessionTransactional" method to ConnectionFactoryUtils
* introduced SessionProxy interface for target Session access, exposed by Transa
ctionAwareConnectionFactoryProxy
* DefaultMessageListenerContainer switches "sessionTransacted" to "true" in case
of a non-JTA ResourceTransactionManager
* DefaultMessageListenerContainer rolls back an external transaction in case of
a message rejected while stopping
* DefaultMessageListenerContainer does not eagerly commit/rollback a in case of
a synchronized transacted Session
* DefaultMessageListenerContainer obtains a shared Connection lazily in case of
autoStartup="true"
* DefaultMessageListenerContainer recovers a shared Connection lazily if it is n
ot currently running (has been stopped)
* DefaultMessageListenerContainer allows for specifying the listener object lazi
ly, and for replacing it at runtime
* fixed JmsInvokerClientInterceptor/ProxyFactoryBean's "queue" property to decla
re type Queue now
* added "proxyInterfaces" property to JndiObjectFactoryBean, for specifying mult
iple interfaces
* JndiObjectFactoryBean autodetects proxy interfaces from a specified "expectedT
ype", if necessary
* JndiObjectTargetSource returns the specified "expectedType" as target class if
no JNDI object has been obtained yet
* added "setPriority" method to MimeMessageHelper, for populating the "X-Priorit
y" mail header
* MockHttpServletResponse automatically marks the response as committed once the
buffer size has been exceeded
* MockHttpServletResponse marks the response as committed in case of a "OutputSt
ream.flush()" / "Writer.flush()" call
* SharedEntityManagerCreator's proxies deliver a "toString()" result without tou
ching a target EntityManager
* added protected "getPersistenceUnitInfo" method to DefaultPersistenceUnitManag
er, to allow for better subclassing
* DefaultPersistenceUnitManager clears the default PersistenceUnitInfo once it h
as been obtained
* added "defaultPersistenceUnitName" property to PersistenceAnnotationBeanPostPr
ocessor
* PersistenceAnnotationBeanPostProcessor only sets fields/methods accessible whe
n actually necessary
* RemoteInvocationUtils detects cycles in exception causes when updating the sta
ck trace (avoiding an infinite loop)
* added default Hibernate EntityManager and Apache OpenJPA configurations to Pet
Clinic's WAR file and integration tests
* PetClinic's JPA variant explicitly specifies "META-INF/orm.xml" as mapping fil
e (for Hibernate EntityManager 3.3.0)
* PetPortal's build script properly includes the Log4J jar in the WAR file
* added "targetBeanName" property to MethodInvokingJobDetailFactoryBean for Quar
tz, allowing for non-singleton targets
* ThreadPoolTaskExecutor/ScheduledExecutorFactoryBean includes the corresponding
bean name in startup/shutdown logging
* LangNamespaceHandler references ScriptFactory classes by name, to avoid NoClas
sDefFoundErrors in all scenarios
* added "scope" attribute to all script tags in the "lang" namespace, allowing f
or non-singleton script objects
* updated JRuby support for JRuby 0.9.8 (requiring this version now due to incom
patible JRuby API changes)
* added "getActualException()" method to AssertThrows, for introspecting the act
ual exception instance after throwing
* factored out TransactionOperations interface from TransactionTemplate, definin
g the central "execute" operation
* introduced ResourceTransactionManager (i.e. non-JTA) interface, indicating the
resource factory that it operates on
* "tx:advice" expects that the XML parser might not expose the defaults defined
in "spring-tx-2.0.xsd" (e.g. on Resin)
* ObjectUtils's "nullSafeToString"/"getDisplayValue" returns an empty String if
"Object.toString()" returned null
* ClassUtils's "classPackageAsResourcePath" parses the class name in order to de
tect the package name in all cases
* fixed CustomizableThreadCreator to properly apply its "daemon" flag (inherited
by SimpleAsyncTaskExecutor)
* added "getContextPath", "getRemoteUser", "getUserPrincipal", "isUserInRole", "
isSecure" to WebRequest abstraction
* changed visibility of "getRequest" accessor on ServletWebRequest and PortletWe
bRequest to public
* CharacterEncodingFilter sets the encoding as default response encoding on Serv
let 2.4+ (if "forceEncoding"="true")
* Servlet/PortletContextAware and Servlet/PortletConfigAware are simply skipped
if they cannot be satisfied
* added public "refresh()" operation with protected "onRefresh()" template metho
d to DispatcherServlet/Portlet
* reworked DispatcherServlet/Portlet to automatically refresh internal state if
its ApplicationContext refreshes
* DispatcherPortlet logs startup logging at debug level instead of info level, a
nalogous to DispatcherServlet
* factored out protected "getHandlerExecutionChain" template method in Servlet/P
ortlet AbstractHandlerMapping
* added "getRootHandler()" method to AbstractUrlHandlerMapping, called on each a
ccess to the root handler
* added overloaded "suppressValidation(request, command, errors)" variant to Bas
eCommandController
* deprecated "suppressValidation(request)" in BaseCommandController, in favor of
the "(request, command)" variant
* revised AbstractXsltView for transformer customization options ("buildTransfor
mer" and "getTemplates" methods)
* added "getParameters(model, request") variant to AbstractXsltView, deprecating
the old "getParameters()" variant
* "spring.tld" and "spring-form.tld" declare the Spring major version number (2.
0) as taglib version number
* fixed JSP BindTag to correctly save and re-expose a page-scoped "status" attri
bute (not just a request-scoped one)
* JSP FormTag escapes the "action" attribute as well if HTML escaping has been r
equested
* JSP InputTag supports the common "autocomplete" HTML extension attribute (as s
upported by IE and Firefox)
* JSP InputTag and TextareaTag support the HTML "readonly" element correctly now
, only rendering it if specified
* JSP CheckboxTag applies custom editors for the element type when comparing col
lection elements
* added missing "readonly" attribute to JSP TextareaTag
* checkbox and radiobutton macros in "spring.vm" for Velocity do not render an i
d anymore (because it isn't unique)
* checkbox macro in "spring.vm" for Velocity and "spring.ftl" for FreeMarker ren
ders the default field marker
* added theme macros to "spring.vm" for Velocity and "spring.ftl" for FreeMarker
, providing access to theme messages

-------------------------------------
General
* basic scheduling support is included in "spring-context.jar", with only Quartz
support added in "spring-support.jar"
* all checks for library presence are explicitly performed with Spring's own Cla
ssLoader (not the application's)
* overall startup/shutdown logging at info level is less verbose (activate debug
log level for more config details)
* included the "petportal" sample application in the "-with-dependencies" distri
bution
* introduced AfterAdvice marker, as super-interface of AfterReturningAdvice and
ThrowsAdvice, for reduced coupling
* exposed "invocableClone()" and "setUserAttribute"/"getUserAttribute" on ProxyM
ethodInvocation, for reduced coupling
* introduced TargetClassAware interface, extended by Advised, and framework-deco
upled "AopUtils.getTargetClass" method
* fixed ClassFilters to provide JDK-1.3/1.4-compatible "hashCode()" implementati
ons for unions and intersections
* MethodMatchers and Pointcuts support IntroductionAwareMethodMatcher for unions
and intersections
* added pointcut union operation to ComposablePointcut, reused by the "Pointcuts
.union" convenience operation
* RegexpMethodPointcutAdvisor references ORO classes indirectly, to avoid eager
loading of ORO on Solaris JDK 1.6
* AnnotationMethodMatcher and AnnotationMatchingPointcut check for an annotation
on the target method as well
* added "forClassAnnotation" and "forMethodAnnotation" factory methods to Annota
tionMatchingPointcut
* redefined target-class proxying to create a JDK proxy in case of the target cl
ass being an interface
* CGLIB proxies handle "hashCode" calls according to their "equals" behavior, an
alogous to JDK dynamic proxies
* introduced stricter null checks for Advised/AdvisedSupport
* exposed "indexOf(Advice)" method on Advised interface
* revised ProxyConfig/AdvisedSupport's "toString()" output
* added "setTargetClass" method to AdvisedSupport, building an EmptyTargetSource
for the specified class
* moved "aopProxyFactory" bean property and AdvisedSupportListener management do
wn to new ProxyCreatorSupport base class
* AdvisorChainFactory is not forced to implement the AdvisedSupportListener inte
rface anymore
* deprecated AdvisorChainFactoryUtils and HashMapCachingAdvisorChainFactory in f
avor of SimpleAdvisorChainFactory
* added overloaded ProxyFactory constructors for single-interceptor and TargetSo
urce-only proxies
* ProxyFactoryBean exposes a composite interface as object type in case of multi
ple proxy interfaces specified
* AbstractSingletonProxyFactoryBean and AbstractAutoProxyCreator use the bean Cl
assLoader for generating proxies
* reworked AdvisorAdapter and AdvisorAdapterRegistry to expose a MethodIntercept
or right away
* AspectJExpressionPointcut ignores target classes not accepted by PointcutExpre
ssion matching (such as arrays)
* AspectJExpressionPointcut falls back to the proxy method if the ShadowMatch fa
iled for the target method
* revised AspectJPointcutAdvisor to never apply AspectJ advice methods to themse
lves (avoiding a stack overflow)
* AbstractAspectJAdvice calls "setAccessible" on an advice method right before i
nvocation and only if actually necessary
* AspectJAdviceParameterNameDiscoverer properly considers reference pointcuts as
potential source of parameter binding
* AbstractAspectJAdvisorFactory detects @AspectJ aspects through the presence of
the @Aspect annotation
* MethodInvocationProceedingJoinPoint allows for multiple "proceed(arguments)" c
alls, cloning the underlying invocation
* PrototypeAspectInstanceFactory enforces that the target bean is a prototype; i
t does not accept scoped objects
* PrototypeTargetSource enforces that the target bean is a prototype; it does no
t accept scoped objects
* PrototypeTargetSource destroys bean instances on release (honors DisposableBea
n and/or destroy-method)
* ThreadLocalTargetSource destroys bean instances via ConfigurableBeanFactory's
"destroyBean" (if possible)
* added "forClass" factory method to EmptyTargetSource, allowing to indicate a s
pecific target class
* added "equals"/"hashCode" implementation to AbstractBeanFactoryBasedTargetSour
ce
* HotSwappableTargetSource's "hashCode" implementation returns a constant value
even if the target object changes
* added SimpleBeanTargetSource, performing a fresh getBean lookup on every reque
st, for any kind of bean
* ScopedProxyFactoryBean uses the BeanFactory's bean ClassLoader for generating
scoped proxies
* auto-proxying ignores objects exposed by ScopedProxyFactoryBeans; only their t
arget beans are eligible
* fixed "scoped-proxy" bean definition decorator to properly parse an inner bean
with scoped-proxy marker
* added "proxy-target-class" attribute to "scoped-proxy" XML tag, allowing to tu
rn target class proxying off
* reworked "scoped-proxy" XML tag to enforce a target class proxy selectively, f
or its specific target bean
* "scoped-proxy" marks its targets as autowireCandidate=false, to make autowirin
g by type only hit the scoped proxy
* @Configurable works for deserialized objects as well
* CachedIntrospectionResults's "acceptedClassLoaders" facility uses thread-safe
iteration
* fixed BeanWrapperImpl's "toString()" output in case of no wrapped object set
* BeanWrapperImpl supports nested generic collections as map keys and as indexed
map values
* added "getTypeConverter()" method to ConfigurableBeanFactory interface
* MethodInvokingFactoryBean obtains the TypeConverter from the BeanFactory that
it runs in
* List/Set/MapFactoryBean convert elements to the generic type expressed in a su
perclass/interface of the target class
* added SmartInstantiationAwareBeanPostProcessor interface, supporting type pred
iction (for scripted object types)
* PropertyPlaceholderConfigurer detects and processes placeholders in scope name
s as well
* PropertyPlaceholderConfigurer does not log resolved (potentially decrypted) pl
aceholder values at debug level anymore
* PreferencesPlaceholderConfigurer resolves paths in placeholders ("myPath/myPla
ceholderKey") as preference nodes
* added "isPrototype(beanName)" method to BeanFactory interface, explicitly chec
king for an independent instance
* added extended SmartFactoryBean interface, including an "isPrototype()" method
that checks for an independent instance
* AbstractBeanFactory throws BeanCreationException will full context info if "po
stProcessObjectFromFactoryBean" fails
* DisposableBeanAdapter (as passed into "Scope.registerDestructionCallback") is
serializable, even for post-processors
* AbstractAutowireCapableBeanFactory does not trigger "toString()" call on argum
ent for UnsatisfiedDependencyException
* turned visibility of AbstractAutowireCapableBeanFactory's "applyPropertyValues
" method from private to protected
* DefaultListableBeanFactory's "getBeansOfType" only ignores currently-in-creati
on for beans which are still in creation
* added copy constructor to ChildBeanDefinition, for custom use in programmatic
bean registration code
* TypedStringValue overrides "equals", "hashCode" and "toString"
* TypedStringValue implements the BeanMetadataElement interface and provides a "
setSource" method
* introduced BeanNameGenerator strategy interface, to be configured on an Abstra
ctBeanDefinitionReader
* added "generateBeanName/registerWithGeneratedName(BeanDefinition)" methods to
XmlReaderContext
* BeanDefinitionParseDelegate always builds TypedStringValue for "value" and "nu
ll" XML elements, preserving the source
* BeanDefinitionParseDelegate builds TypedStringValue for "entry" and "prop" key
s and values, preserving the source
* BeanDefinitionParseDelegate trims whitespace from "class" attributes in XML be
an definitions
* collection merging accepts a null parent value as well, simply using the child
collection as-is in this case
* indexed constructor arguments support collection merging (driven by merge="tru
e", analogous to property values)
* BeanDefinitions returned by nested custom XML elements receive a generated id,
to avoid FactoryBean cache conflicts
* added deprecated "findXxx" signatures back to NamespaceHandlerSupport, for ful
l compatibility with Spring 2.0 final
* added protected "shouldGenerateIdAsFallback()" template method to AbstractBean
DefinitionParser
* AbstractSingleBeanDefinitionParser applies a document's default-lazy-init="tru
e" to its generated bean definitions
* added "isEligibleAttribute" template method to AbstractSimpleBeanDefinitionPar
ser, for excluding specific attributes
* "util:properties" tag supports nested "prop" elements for local entries, analo
gous to the standard "props" tag
* AbstractApplicationContext instantiates BeanPostProcessors which implemented O
rdered before non-Ordered ones
* AbstractApplicationContext applies start/stop callbacks to existing Lifecycle
instances only, particularly on shutdown
* AbstractApplicationContext correctly detects listener creation failure (in cas
e of currently-in-creation exception)
* factored out protected "destroyBeans()" template method in AbstractApplication
Context, for custom bean destruction
* AbstractRefreshableApplicationContext allows BeanFactory access during the des
truction phase of a "refresh()" call
* added "customizeBeanFactory(DefaultListableBeanFactory)" template method to Ab
stractRefreshableApplicationContext
* (Reloadable)ResourceBundleMessageSource trims whitespace from specified bundle
basenames
* ResourceBundleMessageSource by default uses the bean ClassLoader for loading b
undles
* added "getMostSpecificCause()" method to NestedRuntime/CheckedException, retri
eving the root cause or this exception
* fixed BridgeMethodResolver's "populateTypeMapFromParameterizedType" to properl
y handle nested generics
* fixed BridgeMethodResolver to properly detect a generic interface even in a cl
ass hierarchy
* fixed BridgeMethodResolver to properly detect a generic array type as exposed
by a vararg signature
* introduced AsyncTaskExecutor extension interface, defining an "execute" varian
t with start timeout
* refactored SimpleAsyncTaskExecutor to allow for reuse of the CustomizableThrea
dCreator class
* SimpleAsyncTaskExecutor executes tasks with timeout='immediate' directly, bypa
ssing the concurrency throttle
* introduced TaskTimeoutException, thrown by an AsyncTaskExecutor in case of a t
ask rejected because of a timeout
* PersistenceExceptionTranslationPostProcessor uses the bean ClassLoader for gen
erating translation proxies
* AbstractEnterpriseBean uses the EJB instance as WeakReferenceMonitor handle, i
nstead of a BeanFactoryReference proxy
* all "jee:*" tags support an "environment-ref" attribute, pointing to a shared
bean of type "java.util.Properties"
* OC4J's "com.evermind.server.rmi.RMIConnectionException" gets detected as Remot
e EJB (RMI) connect failure as well
* ShadowingClassLoader excludes "com.sun." package by default (for using Sun's X
erces version through JAXP)
* TransactionAwareConnectionFactoryProxy throws JCA IllegalStateException in cas
e of "getLocalTransaction()" access
* CciLocalTransactionManager unwraps given TransactionAwareConnectionFactoryProx
y to obtain its target ConnectionFactory
* added ResourceAdapterFactoryBean to "jca.support" package, for bootstrapping a
JCA 1.5 ResourceAdapter locally
* introduced "jca.work" package, containing a JCA 1.5 WorkManagerTaskExecutor an
d a SimpleTaskWorkManager implementation
* added overloaded ConnectionHolder constructor with a given Connection plus "tr
ansactionActive" flag as arguments
* UserCredentialDataSourceAdapter delegates "getConnection(String, String)" to "
doGetConnection", for unified handling
* introduced IsolationLevelDataSourceAdapter, preparing Connections with isolati
on level (transaction's or fixed)
* introduced WebSphereDataSourceAdapter, obtaining Connections through WebSphere
's JDBCConnectionSpec facility
* re-added Spring 1.2's "JdbcUtils.isNumeric" convenience method, for use by app
lications (upgrading from Spring 1.2)
* revised JdbcTemplate's prepared statement logging
* marked JmsDestinationAccessor as abstract
* moved protected "createConnection" and "createSession" methods from JmsTemplat
e up to JmsAccessor
* TransactionAwareConnectionFactoryProxy throws TransactionInProgressException i
n case of manual commit/rollback calls
* JmsTransactionManager unwraps given TransactionAwareConnectionFactoryProxy to
obtain its target ConnectionFactory
* ConnectionFactoryUtils's JmsResourceHolder only stops Connections if a SmartCo
nnectionFactory explicitly asks for it
* factored out AbstractJmsListeningContainer base class from AbstractMessageList
enerContainer
* AbstractMessageListenerContainer's "refreshSharedConnection" properly resets s
hared Connection in refresh failure case
* AbstractMessageListenerContainer explicitly aborts messages which have been de
livered after initiated shutdown
* added "acceptMessagesWhileStopping" flag to AbstractMessageListenerContainer,
for processing all delivered messages
* factored out AbstractPollingMessageListenerContainer base class from DefaultMe
ssageListenerContainer
* added dynamic scaling up/down to DefaultMessageListenerContainer, configured t
hrough "maxConcurrentConsumers" property
* DefaultMessageListenerContainer's Connection recovery loop catches any Excepti
on thrown from "createConnection"
* MessageListenerAdapter can delegate to native target (SessionAware)MessageList
ener if no listener method specified
* MBeanExporter and MBeanServerConnectionFactoryBean use the bean ClassLoader fo
r generating lazy-init proxies
* MBeanExporter supports lazy-init standard MBeans analogously to lazy-init Spri
ng beans with ModelMBean wrapping
* factored out protected "isMBean(Class") method in MBeanExporter, to allow for
extending the default MBean check
* MBeanServerFactoryBean only tries to obtain the JDK 1.5 platform MBeanServer i
n case of no agent id specified
* MBeanServerFactoryBean tries to create a new MBeanServer if not allowed to acc
ess the JDK 1.5 platform MBeanServer
* added WebSphereMBeanServerFactoryBean, using WebSphere's proprietary AdminServ
iceFactory API for MBeanServer access
* added "agentId" property to MBeanClientInterceptor/MBeanProxyFactoryBean, for
locating a specific MBeanServer
* JndiObjectFactoryBean uses the bean ClassLoader for generating lazy-init proxi
es
* JndiObjectTargetSource (as used by JndiObjectFactoryBean's "proxyInterface" su
pport) throws JndiLookupException
* added "clearAttributes()" method to MockHttpServletRequest and MockHttpSession
* added "serializeState" and "deserializeState" methods to MockHttpSession, for
testing attribute serialization
* introduced MockFilterChain (recording the call) and PassThroughFilterChain (pa
ssing the call on to a Filter/Servlet)
* added "flushMode" init parameter to Hibernate3 OpenSessionInViewFilter (suppor
ting "AUTO" etc as value)
* Hibernate3 SessionFactoryUtils translates SQLGrammar/DataException into Invali
dDataAccessResourceUsageException
* Hibernate3 HibernateAccessor/TransactionManager translates GenericJDBCExceptio
n using a default SQLExceptionTranslator
* TopLink LocalSessionFactory provides "loginProperties"/"loginPropertyMap" bean
properties, for applying login settings
* TopLink LocalSessionFactoryBean uses the bean ClassLoader as TopLink Session C
lassLoader
* all remoting ProxyFactoryBeans use the bean ClassLoader for generating service
proxies
* RemoteExporter uses the bean ClassLoader for generating service proxies
* added public "getHost()" and "getPort()" accessors to RmiRegistryFactoryBean
* added "alwaysCreate" flag to RmiRegistryFactoryBean, for avoiding the overhead
of locating an existing registry
* added "alwaysCreateRegistry" flag to RmiServiceExporter, for avoiding the over
head of locating an existing registry
* added "rebind()" method to JndiRmiServiceExporter, for recovering in case of t
he target registry having been restarted
* CodebaseAwareObjectInputStream uses "Class.forName", to be able to resolve arr
ay classes with any ClassLoader
* added "getTargetInterfaceName()" method to RmiInvocationHandler, for client-si
de introspection
* HttpInvokerClientInterceptor does not require an "afterPropertiesSet()" call f
or initializing the request executor
* added "serviceFactory" property to LocalJaxRpcServiceFactory, for passing in a
pre-initialized ServiceFactory instance
* fixed JaxRpcPortClientInterceptor to properly recover in case of a failed lazy
"prepare()" attempt
* JaxRpcPortClientInterceptor consistently throws RemoteLookupFailureException i
f a lazy "prepare()" attempt failed
* added "refreshServiceAfterConnectFailure" bean property to JaxRpcPortClientInt
erceptor, allowing for service recovery
* added "workListener" bean property to the CommonJ WorkManagerTaskExecutor
* introduced the CustomizableThreadFactory class, implementing JDK 1.5's ThreadF
actory SPI with bean-style configuration
* ThreadPoolTaskExecutor's "corePoolSize" and "maxPoolSize" properties allow for
runtime changes (e.g. through JMX)
* added "getPoolSize()" and "getActiveCount()" methods to ThreadPoolTaskExecutor
(intended for JMX exposure)
* added "getThreadPoolExecutor()" accessor to ThreadPoolTaskExecutor, for native
access to the underlying executor
* added "exposeUnconfigurableExecutor" bean property to ScheduledExecutorFactory
Bean
* added support for the JSR-166 (java.util.concurrent) backport project, in the
"scheduling.backportconcurrent" package
* added "getScriptedObjectType" method to ScriptFactory interface
* Bsh/Groovy/JRubyScriptFactory uses the bean ClassLoader for generating script
objects
* BshObjectInvocationHandler/JRubyObjectInvocationHandler implement "equals"/"ha
shCode/"toString" based on script object
* BshScriptUtils and BshScriptFactory support BeanShell scripts that declare an
actual class or instance
* GroovyScriptFactory supports Groovy scripts that create an actual instance or
explicitly return an object
* Bsh/GroovyScriptFactory caches the script class as far as possible, building p
rototypes from the same class
* JRubyScriptUtils passes the declared return type to JRuby, for proper conversi
on of number types
* JRubyScriptUtils converts Ruby arrays back to declared Java arrays
* ScriptFactoryPostProcessor uses the bean ClassLoader for generating refreshabl
e script proxies
* ScriptFactoryPostProcessor applies a config interface to the scripted target o
bject only, not to a refreshable proxy
* revised ScriptFactoryPostProcessor to support AOP auto-proxying for scripted o
bjects
* revised ScriptFactoryPostProcessor to support type determination for scripted
objects
* LangNamespaceHandler always registers all BeanDefinitionParsers, failing with
NoClassDefFoundError for actual script
* AbstractSingleSpringContextTests uses GenericApplicationContext by default, cr
eated through "createApplicationContext"
* added "customizeBeanFactory(DefaultListableBeanFactory)" template method to Ab
stractSingleSpringContextTests
* AbstractSingleSpringContextTests supports "getConfigPaths()" method, specifyin
g config files relative to test class
* AbstractSingleSpringContextTests supports "getConfigPath()" method, specifying
a single file relative to test class
* changed the visibility of AbstractDependencyInjectionSpringContextTests's "inj
ectDependencies" method to protected
* changed the visibility of AbstractTransactionalSpringContextTests's "transacti
onDefinition" field to protected
* AssertThrows preserves an unexpected exception as root cause in the "wrong exc
eption thrown" AssertionFailedError
* AbstractPlatformTransactionManager exposes "actualTransactionActive" flag for
a newly synchronized existing tx as well
* AbstractPlatformTransactionManager marks an existing transaction as rollback-o
nly even in case of a commit exception
* turned various AbstractPlatformTransactionManager methods from private to prot
ected, for reuse in specific subclasses
* JtaTransactionManager does not fail if default UserTransaction lookup fails: f
alls back on TransactionManager instead
* SpringJtaSynchronizationAdapter does not explicitly call "setRollbackOnly" on
WebLogic, to preserve the root cause
* added OC4JJtaTransactionManager for Oracle OC4J 10.1.3(.2), with support for t
ransaction names and isolation levels
* fixed AbstractFallbackTransactionAttributeSource to synchronize access to its
attribute cache
* added "order" attribute to "tx:annotation-driven" tag, determining the order o
f the tx advisor in the advice chain
* ResourceUtils's "extractJarFileURL" only prepends a slash in front of a file p
ath if it doesn't already have a slash
* added CustomizableThreadCreator class, serving as base class for ThreadFactory
adapters
* CharacterEncodingFilter only applies its encoding if actually specified (non-n
ull)
* ConfigurableWebApplicationContext and ConfigurablePortletApplicationContext ex
pose config state through getters
* RequestContextListener works correctly even in case of the "requestDestroyed"
callback coming from a different thread
* ServletRequestAttributes's DestructionCallbackBindingListener is serializable,
surviving web app restarts
* added "warnLogCategory" property to SimpleMappingExceptionResolver, allowing t
o log the exception to warn level
* added protected "determineStatusCode" method to Servlet SimpleMappingException
Resolver, for custom status codes
* added "rootHandler" bean property to AbstractUrlHandlerMapping, kicking in for
the "/" path
* added "detectHandlersInAncestorContexts" to BeanNameUrlHandlerMapping, for det
ecting handler beans in the root context
* added "excludedPackages" and "excludedClasses" bean properties to ControllerCl
assNameHandlerMapping
* ControllerClassNameHandlerMapping excludes all classes in the "org.springframe
work.web.servlet.mvc" package by default
* revised FormTag to be more extensible (through less assertions and consistent
use of protected template methods)
* OptionsTag accepts no or empty items specified, simply not rendering any optio
n tags in such a case
* ErrorsTag properly supports HTML escaping (participates in default HTML escapi
ng and respects the "htmlEscape" flag)
* ErrorsTag simply renders empty if neither a BindingResult nor a target object
for its bind path is present
* revised VelocityToolboxView to support Velocity Tools 1.3's init methods (View
Tool callbacks are now deprecated)
* FreeMarker "formTextarea" macro does not re-escape its value (escaping is up t
o "htmlEscape"/"defaultHtmlEscape")
* added "messageArgs" and "messageArgsText" macros to the "spring.ftl" FreeMarke
r macro template library

-------------------------------------
General
* fixed spring-beans.jar to not include "META-INF/aop.xml", "META-INF/spring.tld
" and "META-INF/spring-form.tld" anymore
* leverage the "trace" log level in the Spring core, to make activating the "deb
ug" log level more bearable
* AbstractRegexpMethodPointcut trims whitespace from passed-in "patterns" and "e
xcludedPatterns"
* fixed AbstractAutoProxyCreator to allow for proxying the same bean with multip
le auto proxy creators (again)
* BeanNameAutoProxyCreator trims whitespace from passed-in "beanNames"
* ScopedProxyFactoryBean throws IllegalStateException if it couldn't determine t
he type of the target bean (avoid NPE)
* "scoped-proxy" tag works for non-singleton FactoryBeans as well, leveraging th
e BeanFactory's improved type check
* factored out BeanFactoryAdvisorRetrievalHelper from AbstractAdvisorAutoProxyCr
eator
* factored out BeanFactoryAspectJAdvisorsBuilder from AnnotationAwareAspectJAuto
ProxyCreator
* added AbstractBeanFactoryPointcutAdvisor and DefaultBeanFactoryPointcutAdvisor
* each "aop:advisor" entry lazily initializes its Advice bean, to let all target
beans be exposed to all Advisors
* CachedIntrospectionResults allows for caching for specific ClassLoaders even i
f their classes are not cache-safe
* BeanWrapper interface extends TypeConverter interface, instead of just BeanWra
pperImpl implementing TypeConverter
* BeanWrapperImpl converts nested collection value (e.g. List within Map) to dec
lared generic type, if applicable
* BeanWrapperImpl's TypeMismatchException mentions the specific element that fai
led in case of a (generic) collection
* BeanWrapperImpl assigns a given array directly if component type matches and n
o matching custom editors registered
* added default editor for JDK 1.4's "java.net.URI" class, supporting "classpath
:" pseudo URLs as well as general URIs
* ResourceEditorRegistrar always registers ClassEditor for given ResourceLoader'
s ClassLoader
* added "originalBeanName(String)" method to BeanFactoryUtils, allowing to cut o
ff a generated "#..." suffix
* FieldRetrievingFactoryBean and PropertyPathFactoryBean extract the original be
an name for their beanName-based syntax
* added support for 'early access singletons' to AbstractFactoryBean, exposing a
proxy in case of a circular reference
* ListFactoryBean, SetFactoryBean and MapFactoryBean support exposure of a proxy
in case of a circular reference
* refined currently-in-creation check for lazy-init singletons, to avoid uninten
ded BeanCurrentlyInCreationException
* DefaultSingletonBeanRegistry and subclasses use unified mutex for singleton ac
cess, to avoid potential for deadlocks
* AbstractBeanFactory caches merged bean definitions with bean definition identi
ty as key (to avoid bean name conflicts)
* AbstractAutowireCapableBeanFactory caches "isExcludedFromDependencyCheck" resu
lts for affected PropertyDescriptors
* AbstractAutowireCapableBeanFactory provides two-step FactoryBean type check fo
r non-singleton FactoryBeans as well
* fixed AbstractAutowireCapableBeanFactory to only apply injection-before-wrappi
ng check for singletons
* DefaultListableBeanFactory avoids expensive dependency check preparations unle
ss an actual dependency check is needed
* ResourceEntityResolver catches any kind of Exception in system root URL check
(in particular AccessControlException)
* introduced XmlBeanDefinitionStoreException, with special support for SAXParseE
xception and its location information
* XmlBeanDefinitionReader chooses XSD validation if XmlValidationModeDetector in
dicates AUTO (= no clear indication)
* XML bean "id" and "name" (aliases) are allowed to define the same name (for ba
ckwards compatibility with Spring 1.2.8)
* BeanDefinitionDecorators are applied to inner beans as well (in particular: "p
:" namespace works for inner beans now)
* fixed AbstractBeanDefinitionParser and UtilNamespaceHandler to consistently us
e ProblemReporter instead of exceptions
* added "fatal" method to ProblemReporter, used by NamespaceHandlerSupport to re
port a missing parser or decorator
* added "defaultsRegistered" notification to ReaderEventListener, with DefaultsD
efinition marker interface as argument
* reworked BeanDefinitionParserDelegate to build and hold a DocumentDefaultsDefi
nition instance, also firing an event
* BeanDefinitionParserDelegate/AbstractBeanDefinitionParser report bean name gen
eration failure through ProblemReporter
* DefaultBeanDefinitioDocumentReader reports alias registration failure through
ProblemReporter
* AbstractApplicationContext explicitly stops all Lifecycle Beans before destroy
ing them one-by-one (to avoid delays)
* Conventions (as used by ModelMap) extracts inner class name for inner classes
* Conventions (as used by ModelMap) extracts primary interface name for JDK prox
ies
* reworked CollectionFactory's "createApproximateCollection/Map" to preserve ori
ginal Comparator for TreeSet/TreeMap
* LocalVariableTableParameterNameDiscoverer uses current ClassLoader for ASM ana
lysis (not the system ClassLoader)
* PathMatchingResourcePatternResolver properly handles jar file roots returned b
y the ClassLoader (e.g. on Resin)
* added "singleResult" and "requiredSingleResult" methods to DataAccessUtils, di
stinct from "uniqueResult"'s contract
* RowMapperResultSetExtractor always uses ArrayList, even in case of unknown num
ber of rows expected
* JdbcTemplate by default uses "PreparedStatement.setString" for any CharSequenc
e (including String and StringBuilder)
* JdbcTemplate logs SQLWarnings at debug instead of warn level, to avoid repeate
d warn logs for acceptable conditions
* JdbcTemplate's "queryForObject" uses "requiredSingleResult" to never accept mo
re than 1 row in result (as per its c.)
* SqlQuery's "findObject" explicitly uses "singleResult" to never accept more th
an 1 row in result (as per its contract)
* introduced SmartConnectionFactory interface and "ConnectionFactoryUtils.releas
eConnection" method
* introduced DelegatingConnectionFactory, configuring whether a Connection shoul
d be stopped before closing it
* JmsTemplate/DefaultMessageListenerContainer do *not* explicitly stop their Con
nections by default anymore (see above)
* added "transactionName" property to DefaultMessageListenerContainer (in partic
ular for WebLogic's tx monitoring)
* fixed JmsInvokerClientInterceptor to always explicitly start its Connection (n
ot rely on pre-started Connections)
* reworked MBeanProxyFactoryBean's and ConnectorServerFactoryBean's "setObjectNa
me" to also accept ObjectName reference
* SqlMapClientFactoryBean uses SqlMapClientBuilder with InputStream if possible
(on iBATIS 2.3, to avoid encoding issue)
* Hibernate3 LocalSessionFactoryBean automatically sets JTATransactionFactory if
given a "jtaTransactionManager"
* Hibernate3 LocalSessionFactoryBean only sets connection release mode "on_close
" if not given a "jtaTransactionManager"
* Hibernate3 LocalSessionFactoryBean exposes configured DataSource for schema up
date (required on Hibernate 3.2.1+)
* fixed Hibernate JTA transaction synchronization to properly mark a rollback on
WebSphereExtendedJTATransactionLookup
* HibernateJpaDialect switches FlushMode to MANUAL in case of read-only, and enf
orces COMMIT or AUTO for read-write tx
* fixed "hashCode()" handling in extended JPA EntityManager proxy, avoiding an e
ternal recursion
* extended JPA EntityManagers that join a synchronized transaction propagate a c
ommit exception to the (commit) caller
* PersistenceUnitReader determines URI-conforming persistence unit root (for Hib
ernate EntityManager's archive browsing)
* JpaTransactionManager and EntityManagerFactoryUtils's JTA synchronization clea
r a pre-bound EntityManager on rollback
* PersistenceAnnotationBeanPostProcessor allows for specifying JNDI names for pe
rsistence units and persistence contexts
* OpenXxxInViewFilters reobtain thread-bound holder for closing it, to allow for
replacing the holder during a request
* RmiServiceExporter logs description of actual registry instead of port (to pro
perly handle passed-in "registry")
* HttpInvokerClientInterceptor/ProxyFactoryBean uses the ClassLoader of the cont
aining BeanFactory for deserialization
* cleaned up platform/login configuration in PetClinic's TopLink variant
* fixed MethodInvokingJobDetailFactoryBean to be compatible with Quartz 1.6 as w
ell as Quartz 1.5.2 (again)
* reworked Quartz SpringBeanJobFactory's "ignoredUnknownProperties" into a Strin
g array of unknown properties to ignore
* CommonJ TimerManagerFactoryBean supports Lifecycle interface, suspending/resum
ing its TimerManager accordingly
* CommonJ TimerManagerFactoryBean explicitly stops its TimerManager on destroy,
not relying on J2EE application shutdown
* added "shared" flag to CommonJ TimerManagerFactoryBean, to suppress suspend/re
sume/stop calls in case of a shared TM
* updated Groovy support to Groovy 1.0 final
* added optional GroovyObjectCustomizer constructor arg to GroovyScriptFactory,
to allow for setting a custom MetaClass
* updated JRuby support to JRuby 0.9.2 (not compatible with previous JRuby versi
ons anymore!)
* fixed JRubyScriptFactory to correctly wrap Java objects that get passed into a
JRuby script proxy
* fixed JRubyScriptFactory's "findClassNode" to always cast the correct object
* added public "getApplicationContext()" method to AbstractSingleSpringContextTe
sts
* added public "getJdbcTemplate()" method to AbstractTransactionalDataSourceSpri
ngContextTests
* AbstractPlatformTransactionManager logs full transaction definition when creat
ing a new transaction
* added "defaultTimeout" property to AbstractPlatformTransactionManager
* VelocityEngineFactory/SpringResourceLoader supports Velocity-style comma-separ
ated paths as "resourceLoaderPath" value
* added overloaded no-arg "start()" method to StopWatch
* added "hasConstructor" and "getConstructorIfAvailable" methods to ClassUtils
* ClassUtils's "getAllInterfaces"/"getAllInterfacesForClass" preserves interface
definition order in the result array
* fixed AntPathMatcher's "extractPathWithinPattern" to correctly extract paths t
hat have fewer parts than the pattern
* XmlValidationModeDetector returns VALIDATION_AUTO if it encounters a CharConve
rsionException
* added "prefix" property and "postProcessMessageCode" template method to Defaul
tMessageCodesResolver
* IntrospectorCleanupListener explicitly exposes the web app ClassLoader as cach
eable for CachedIntrospectionResults
* introduced MissingServlet/PortletRequestParameterException subclasses of Servl
et/PortletRequestBindingException
* reworked the 'default value for missing parameter' check in Servlet/PortletReq
uestUtils to be as efficient as possible
* AbstractUrlHandlerMapping exposes PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for de
fault handler as well
* extracted "getViewNameForUrlPath(String)" in UrlFilenameViewController, for fu
ll compatibility with Spring 1.2.8
* added "alwaysInclude" bean property to InternalResourceView, for enforcing the
use of an include (never a forward)
* AbstractJasperReportsView automatically converts exporter parameter Strings th
at start with a digit into Integers
* added "getCompletePath()" method to AbstractDataBoundFormElementTag, esposing
nested path concatenated with path
* fixed ErrorsTag to use complete path as id, including the nested path
* removed unnecessary setter assertions for optional properties in FormTag and I
nputTag
Changes in version 2.0.1 (23.11.2006)

-------------------------------------
General
* included classes in the "test.annotation" and "test.jpa" packages (tiger mock
directory) in the Spring API javadoc
* HashMapCachingAdvisorChainFactory uses synchronized access to its method cache
Map
* AbstractAutoProxyCreator considers all Advices (not just MethodInterceptors) a
s infrastructure classes to ignore
* fixed AbstractAutoProxyCreator to only obtain beans for "interceptorNames" tha
t have been fully initialized already
* reworked AbstractAdvisorAutoProxyCreator's "extendCandidateAdvisors" into "ext
endAdvisors", operating on sorted list
* renamed AspectJInvocationContextExposingAdvisorAutoProxyCreator to AspectJAwar
eAdvisorAutoProxyCreator
* removed unintended JDK 1.5 dependency in AspectJExpressionPointcut ("equals"/"
hashCode" implementation)
* added "order" attribute to "aspect" tag in AOP schema, allowing to declarative
ly specify ordering for aspect instances
* reworked aspect ordering to allow aspect instances to depend on beans that in
turn get advised by the same aspect
* added @Order annotation support for @AspectJ style aspects, as alternative to
implementing the Ordered interface
* redesigned AspectJ support SPI: AspectInstanceFactory, AspectJPointcutAdvisor,
AspectJAwareAdvisorAutoProxyCreator
* renamed DelegatePerTargetObjectDelegatingIntroductionInterceptor to DelegatePe
rTargetObjectIntroductionInterceptor
* fixed BeanWrapperImpl to correctly determine generic type for each key in a ch
ain (e.g. "myMap[myKey][myInnerKey]")
* introduced PatternEditor for "java.util.regex.Pattern", automatically register
ed when running on JDK 1.4 or higher
* Number objects (as property or argument values) are automatically coerced into
the target Number type (if necessary)
* added CustomMapEditor for Map-to-Map conversion, with a default instance regis
tered for SortedMap
* added "equals" and "hashCode" implementations to BeanDefinitionHolder
* PropertyValue's copy constructor copies source object as well
* ConstructorArgumentValues copies ValueHolder content when merging, and enforce
s uniqueness of merged ValueHolders
* reworked BeanComponentDefinition into subclass of BeanDefinitionHolder, exposi
ng aliases on the bean definition
* re-added BeanReferenceFactoryBean, to allow for substituting the target bean n
ame with a placeholder
* UnsatisfiedDependencyException message for multiple matches mentions the names
of all matching beans
* improved "scope is not active" error message to explicitly hint at the singlet
on-refers-to-scoped-bean problem
* factory methods are allowed to return null, with the null value exposed as bea
n reference
* introduced "isTypeMatch" method on BeanFactory interface, allowing for type ch
ecks without actually loading the Class
* AbstractBeanFactory supports alias chaining, with an alias registered for a be
an name that is itself an alias
* AbstractBeanFactory uses bean name as cache key for merged bean definitions, t
o avoid equality matching overhead
* AbstractBeanFactory detects circular references between non-singletons and thr
ows a corresponding exception
* AbstractBeanFactory overrides an inner bean's singleton status from the merged
outer bean (potentially a child def)
* removed default for "abstract"/"singleton" attributes in "spring-beans.dtd", f
or 2.0-style inheritance for inner beans
* added "findAutowireCandidates" template method to AbstractAutowireCapableBeanF
actory, superseding "findMatchingBeans"
* DefaultListableBeanFactory excludes beans which are not autowire candidates ev
en before it obtains the instances
* fixed PropertyPlaceholderConfigurer to throw a BeanDefinitionStoreException in
case of any circular reference
* fixed PluggableSchemaResolver to accept a null ClassLoader argument (falling b
ack to the default ClassLoader)
* introduced CompositeComponentDefinition for holding nested components (applied
e.g. for "aop:config" element)
* introduced "registerComponent" method on ParserContext, for transparent regist
ration of top-level or nested components
* reworked AbstractBeanDefinitionParser to only determine id and build holder fo
r top-level bean definition
* "util:list/set/map" are now allowed as nested elements as well and do not requ
ire an id anymore
* reworked EhCacheFactoryBean to be based on EHCache 1.2's Ehcache interface rat
her than the concrete Cache class
* added "blocking" flag to EhCacheFactoryBean, for decorating the cache with EHC
ache 1.2's BlockingCache
* added "cacheEntryFactory" flag to EhCacheFactoryBean, for decorating with EHCa
che 1.2's (Updating)SelfPopulatingCache
* added serialVersionUID to ApplicationEvent, for serialization compatibility wi
th Spring 1.2
* LocaleContextHolder supports standard ThreadLocal as well as InheritableThread
Local
* EventPublicationInterceptor caches the application event constructor
* GenericCollectionTypeResolver correctly detects an array type as element type
of a generic collection type
* fixed BridgeMethodResolver to always identify an appropriate bridge method (av
oid IllegalStateException)
* introduced TaskRejectedException, thrown from a TaskExecutor if it does not ac
cept a given task
* added GlassFishLoadTimeWeaver for GlassFish / Sun Application Server
* refactored Java-5-only AbstractOverridingClassLoader into JDK-1.3-compatible O
verridingClassLoader in "core" package
* introduced AbstractRoutingDataSource and IsolationLevelDataSourceRouter
* JdbcTemplate logs all warnings in case of "ignoreWarnings"=true, not just the
first warning in the chain
* added "setQueryTimeout" method to JdbcTemplate and RdbmsOperation, for specify
ing a timeout outside of a transaction
* removed bind parameter check from SqlOperation, not parsing the SQL anymore at
all (relying on JDBC driver instead)
* reimplemented JMSException translation to handle subclasses of standard JMSExc
eptions in a specific fashion as well
* refined AbstractMessageListenerContainer's autodetection of "pubSubDomain" fla
g to handle WebLogic Topic correctly
* DefaultMessageListenerContainer uses its bean name (if specified) as thread na
me prefix for its default TaskExecutor
* MBeanExporter uses ObjectName as exposed by returned ObjectInstance after regi
stration (which differs on WebSphere)
* MethodExclusionMBeanInfoAssembler operates correctly in case of no "ignoredMet
hods" specified
* added "isActive()" and "close()" methods to MockHttpServletRequest and MockPor
tletRequest
* MockHttpServletResponse handles HTTP header names as case-insensitive (analogo
us to MockHttpServletRequest)
* added "setOutputStreamAccessAllowed" and "setWriterAccessAllowed" methods to M
ockHttpServletResponse
* unified mock object constructors that take ServletContext/PortletContext/Porta
lContext arguments
* added all of MockPortletRequest's overloaded constructors to MockActionRequest
and MockRenderRequest
* turned AbstractSingleSpringContextTests's "contextKey" and "loadContext" metho
ds non-final again
* AbstractSingleSpringContextTests provides empty default implementation of "get
ConfigLocations" (not abstract anymore)
* reworked Hibernate session synchronization to properly work with WebSphereExte
ndedJTATransactionLookup on WAS 6.0/6.1
* fixed Hibernate3 LocalSessionFactoryBean's "schemaUpdate" behavior to not run
into an IllegalStateException
* LocalContainerEntityManagerFactoryBean detects jar file URL in WebLogic jar en
try URLs correctly
* PersistenceAnnotationBeanPostProcessor always injects transactional EntityMana
ger with extended interfaces (if any)
* included OpenJPA support classes (OpenJpaDialect, OpenJpaVendorAdapter), teste
d against OpenJPA 0.9.6
* TimerFactoryBean uses its bean name as Timer thread name (on JDK 1.5, falling
back to a default Timer on JDK 1.3/1.4)
* deprecated TimerFactoryBean's "createTimer(daemon)" method in favor of "create
Timer(name, daemon)"
* ScheduledExecutorFactoryBean does not insist on statically specified Scheduled
ExecutorTasks anymore
* DelegatingWork/Job/TimerTask exposes the wrapped Runnable implementation throu
gh a "getDelegate()" method
* Concurrent/ThreadPoolTaskExecutor and WorkManagerTaskExecutor throw Spring's T
askRejectedException (when appropriate)
* CommonJ TimerManagerFactoryBean cancels all statically registered Timers on sh
utdown
* updated LocalTaskExecutorThreadPool to be compatible with Quartz 1.6
* AbstractTransactionalSpringContextTests invokes "onTearDownAfterTransaction" e
ven for a manually completed transaction
* fixed AbstractJpaTests to not keep context reference in cache if context refre
sh failed
* AbstractPlatformTransactionManager exposes current transaction isolation level
via TransactionSynchronizationManager
* AbstractPlatformTransactionManager properly resumes all synchronizations even
after suspend or inner begin failure
* active transaction synchronization gets suspended when going from SUPPORTS/NOT
_SUPPORTED into REQUIRED/REQUIRES_NEW
* JtaTransactionManager's "doRegisterAfterCompletionWithJtaTransaction" avoids N
PE if no current JTA transaction active
* TransactionAttributeEditor does not accept transaction attributes with invalid
whitespace anymore
* fixed AnnotationTransactionAspect to not throw a NoTransactionException in cas
e of transaction begin failure
* AnnotationTransactionAspect supports protected and private methods that carry
Spring's @Transactional annotation
* deprecated FreeMarkerConfigurationFactory's "templateLoaders" property in favo
r of "pre/postTemplateLoaders"
* "ObjectUtils.toObjectArray(Object)" returns a given Object[] as-is instead of
throwing an IllegalArgumentException
* added "containsWhitespace" method to StringUtils
* ExpressionEvaluationUtils catches any linkage error for the JSP 2.0 API, alway
s falling back to the Jakarta JSTL
* WebDataBinder explicitly suppresses field marker prefix values in case of "ign
oreUnknownFields" switched off
* Servlet/PortletRequestAttributes allow for accessing the session even after th
e request has been completed
* RequestContextHolder supports standard ThreadLocal as well as InheritableThrea
dLocal
* DispatcherServlet/Portlet do not expose LocaleContext/RequestAttributes as inh
eritable for child threads anymore
* added "threadContextInheritable" property to DispatcherServlet and DispatcherP
ortlet, for explicit choice
* factored out protected "buildLocaleContext" and "cleanupMultipart" methods in
DispatcherServlet
* made AbstractHandlerMapping's "getDefaultHandler()" method public
* added public "getHandlerMap()" method to AbstractUrlHandlerMapping, exposing a
read-only map of registered handlers
* added public "getUrlMap()" method to SimpleUrlHandlerMapping, to allow for add
ing or overriding individual entries
* added overloaded "suppressValidation" version with command object argument to
BaseCommandController
* added overloaded "isFormChangeRequest" version with command object argument to
SimpleFormController
* "spring:message" tag detects single expression argument that resolves to an ar
ray and processes it as arguments array
* "form:errors" tag can now be used in a nested JSP outside the scope of a "form
:form" tag
* FreeMarkerView exposes all standard FreeMarker hash models now (including sess
ion and request parameters)
* FreeMarkerView uses the ObjectWrapper as specified in the FreeMarker configura
tion, rather than always the default
* FreeMarkerConfigurer always registers ClassTemplateLoader for its own package
(rather than the package of a subclass)
* AbstractJasperReportsSingleFormatView only sets parameter Map on JRExporter in
stance in case of actual parameters
* added "boolean useWriter()" method to AbstractXsltView, allowing to prefer Wri
ter access over OutputStream access
* DispatcherPortlet exposes thread-bound request attributes for render requests
as well (not just action requests)
* DispatcherPortlet restores LocaleContextHolder/RequestContextHolder state (e.g
. from surrounding DispatcherServlet)
Changes in version 2.0 final (3.10.2006)

----------------------------------------
* dropped InvocationContextExposingAdvisorAutoProxyCreator base class
* default property editors for primitive wrapper types (Boolean, Integer, etc) t
urn empty Strings into null values now
* ConstructorArgumentValues supports configuration source objects per argument (
e.g. keep track of original XML element)
* ConfigurableBeanFactory's "setParentBeanFactory" throws IllegalStateException
if already associated with a parent
* added "getRegisteredScopeNames" and "getRegisteredScope" accessors to Configur
ableBeanFactory interface
* added "getConversationId" method to Scope interface (exposing session id for s
ession scope, null for request scope)
* introduced BeanMetadataElement interface, giving access to config source objec
t (implemented by BeanDefinition etc)
* introduced BeanReference interface, implemented by RuntimeBeanReference as wel
l as RuntimeBeanNameReference
* dropped BeanReferenceFactoryBean; use the available alias mechanisms instead
* reworked CustomScopeConfigurer to only support Scope instances as values for t
he "scopes" map
* DefaultSingletonBeanRegistry keeps singleton beans in registration order (requ
ires JDK 1.4 or Commons Collections)
* AbstractBeanFactory does not explicitly register a given alias that is equal t
o the canonical bean name
* dropped BeanDefinitionRegistryBuilder in favor of refined BeanDefinitionReader
Utils convenience methods
* added "getInnerBeanDefinitions()" accessor to ComponentDefinition interface, e
xposing all relevant inner beans
* added Resource argument to SourceExtractor interface, exposing the defining re
source for the given source candidate
* reworked type matching for FactoryBeans, avoiding repeated recreation/destruct
ion through early "getObjectType" checks
* "lookup-method" overrides no-arg method only, to let overloaded variants be im
plemented in a traditional fashion
* added "setAllowRawInjectionDespiteWrapping" config method to DefaultListableBe
anFactory, to enable Spring 1.2 behavior
* added overloaded AbstractSingleBeanDefinitionParser's "doParse" template metho
d with a ParserContext argument
* moved ComponentDefinition, ReaderContext and support classes from "beans.facto
ry.support" to "beans.factory.parsing"
* reworked ReaderEventListener to take AliasDefinition/ImportDefinition argument
for alias/import callback, respectively
* revised BeanDefinitionParsingException to take a single Problem argument
* EhCacheFactoryBean uses EHCache 1.2's extended Cache constructor to avoid EHCa
che warning (requires EHCache 1.2 now)
* AbstractLabeledEnum uses label as "toString()" representation, analogous to JD
K 1.5 enums
* StaticLabeledEnum and AbstractGenericLabeledEnum use the code as default label
* JdbcTemplate uses "PreparedStatement.setObject(index, null)" for null values w
ith unknown SQL type on Informix
* turned visibility of "org.springframework.jdbc.core.StatementCreatorUtils" to
public (again)
* factored out protected "prepareSharedConnection" template method in AbstractMe
ssageListenerContainer
* AbstractMessageListenerContainer's "durableSubscriptionName" property defaults
to the message listener class name
* added "subscriptionDurable" flag to AbstractMessageListenerContainer (set this
to "true" to for actual durability!)
* added "defaultResponseQueueName" and "defaultResponseTopicName" properties to
MessageListenerAdapter
* added JMS invoker strategy for service-based remoting via JMS: JmsInvokerServi
ceExporter, JmsInvokerProxyFactoryBean
* MBeanExporter's MBean autodetection properly registers multiple beans even if
their instances as equal
* MBeanExporter's "registerManagedResource" registers a given MBean as-is (only
wrapping a plain object as ModelMBean)
* AbstractSingleSpringContextTest's "loadContextLocations()" declares Exception,
to allow subclasses to throw exceptions
* added MockMultipartFile, MockMultipartHttpServletRequest and MockMultipartActi
onRequest for testing multipart access
* added overloaded query/insert/update/delete operations without parameter objec
t to SqlMapClientOperations/Template
* refined Hibernate3 support to detect Hibernate 3.2's FlushMode.MANUAL as well,
while remaining compatible with 3.0/3.1
* factored out AbstractSessionFactoryBean base class from Hibernate3 LocalSessio
nFactoryBean
* Hibernate3 LocalSessionFactoryBean registers filter definitions before loading
any mapping files
* ScopedBeanInterceptor for Hibernate3 exposes target class name as Hibernate en
tity name in case of a CGLIB proxy
* changed the semantics of AbstractJpaVendorAdapter's "generateDdl" flag to crea
te/update (instead of drop-and-recreate)
* clarified @Transactional semantics for JDK/CGLIB proxies as well as for Aspect
J
* AbstractPlatformTransactionManager properly propagates an "afterCommit" synchr
onization exception to the caller
* JtaTransactionManager executes "afterCommit" callbacks even when synchronizing
with an existing JTA transaction
* factored out TransactionSynchronizationUtils and JtaAfterCompletionSynchroniza
tion helper classes
* introduced CallbackPreferringPlatformTransactionManager interface, to be imple
mented by callback-loving PTM impls
* TransactionTemplate/TransactionInterceptor automatically detect and use Callba
ckPreferringPlatformTransactionManager
* fixed MethodMapTransactionAttributeSource to avoid unnecessary reinitializatio
n of method map
* ClassUtils falls back to the system class loader if the thread context class l
oader is inaccessible
* all class loading is done via "ClassLoader.loadClass(name)" rather than "Class
.forName(name, true, ClassLoader)"
* DataBinder matches all field names using their canonical name (for required, a
llowed and disallowed checks)
* clarified MultipartFile constract details
* InternalResourceView correctly exports forward attributes on Servlet 2.3- (and
preserves existing attributes on 2.4+)
* OptionTag and ErrorsTag implement BodyTag interface directly to work around a
bug in WebLogic Server 8.1's JSP engine
* added "renderPhaseOnly" flag to Portlet WebRequestHandlerInterceptorAdapter, a
llowing to intercept action phase too
* added "applyWebRequestInterceptorsToRenderPhaseOnly" flag to Portlet AbstractH
andlerMapping
* factored out AbstractMapBasedHandlerMapping base class from Parameter/PortletM
ode/PortletModeParameterHandlerMapping
* renamed PortletModeParameterHandlerMapping's "allowDupParameters" property to
"allowDuplicateParameters"
Changes in version 2.0 RC4 (17.9.2006)
--------------------------------------
General
* renamed Spring 2.0 DTD to spring-beans-2.0.dtd, while keeping the Spring 1.2.x
DTD as compatible spring-beans.dtd
* renamed Spring 2.0 XSDs to spring-beans-2.0.xsd etc, to allow for proper versi
oning of future additions and changes
* spring-beans-2.0.dtd/xsd does not support singleton="true"/"false" anymore. Us
e scope="singleton/"prototype" instead!
* added "spring-agent.jar" to "dist/weavers" directory, containing the agent for
Spring's InstrumentationLoadTimeWeaver
* JPA support is fully tested against Oracle TopLink Essentials v2 b16 as well a
s Hibernate EntityManager 3.2.0 CR4
* removed ORM support for Apache OJB from the Spring core distribution. OJB supp
ort has been moved to Spring Modules.
* declared all internal ThreadLocal variables as final (to avoid potential class
reloading issues)
* replaced all use of AOP Alliance AspectException with AopInvocationException/A
opConfigException/IllegalStateException
* Cglib2AopProxy exposes additional interfaces of a CGLIB-enhanced target bean o
n a CGLIB AOP proxy as well
* fixed PointcutAdvisor support classes to avoid eager access to Advice and Poin
tcut from "hashCode()"/"toString()"
* added "getTargetObject" method to ScopedObject interface, allowing for access
to the raw object in the target scope
* fixed AnnotationAwareAspectJAutoProxyCreator to lazily retrieve aspect singlet
ons (only once a pointcut matches)
* fixed @Configurable support to correctly identify the class name even for a CG
LIB proxy
* fixed BeanWrapperImpl to return a Collection/Map as-is if it is not accessible
(e.g. because it is a scoped proxy)
* fixed BeanWrapperImpl to always use a valid read-write type for a converted co
llection/map (never use original class)
* fixed BeanWrapperImpl to properly resolve even nested generic Collections and
Maps (List of Map, Map of List, etc)
* renamed PropertyAccessExceptionsException to PropertyBatchUpdateException and
explicitly declared when it is thrown
* added "destroyBean" method to ConfigurableBeanFactory interface, for destroyin
g a given instance based on a bean def
* added support for destruction callbacks to Scope abstraction, driven by a Bean
Factory's definition for a scoped bean
* PropertyResourceConfigurer, CustomEditorConfigurer and CustomScopeConfigurer u
se highest Ordered precendence now
* fixed FieldRetrievingFactoryBean to return "false" from "isSingleton()", since
it reobtains the field value every time
* FieldRetrievingFactoryBean and PropertyPathFactoryBean trim whitespace in all
given names (even within the String)
* fixed AbstractBeanFactory to accept re-registration of alias for same bean nam
e (-> bean definition overriding)
* reworked AbstractBeanFactory's alias handling to support local alias definitio
ns for a bean in the parent BeanFactory
* AbstractAutowireCapableBeanFactory only logs name and class of eagerly cached
bean (does not trigger toString anymore)
* AbstractAutowireCapableBeanFactory catches any exception from BeanPostProcesso
r and wraps it in BeanCreationException
* DefaultListableBeanFactory's "preInstantiateSingletons" only fetches the Facto
ryBean instance (instead of its object)
* reworked DefaultListableBeanFactory's beans-by-type lookup to ignore beans tha
t have been overridden by an alias
* inner bean definitions inherit the singleton status of their containing bean e
ven if generated by namespace handler
* fixed method overrides check to accept methods declared on interfaces as well
* removed deprecated BeanFactoryBootstrap class
* EhCacheManagerFactoryBean creates an independent CacheManager instance by defa
ult now (requires EHCache 1.2)
* added "shared" flag to EhCacheManagerFactoryBean, allowing to explicitly ask f
or a shared CacheManager instance
* refined EhCacheManagerFactoryBean to use pass in an InputStream instead of a U
RL for CacheManager initialization
* exposed AbstractApplicationContext's "registerShutdownHook()" method in Config
urableApplicationContext interface
* reverted AbstractApplicationContext to not inherit ClassLoader from parent con
text by default (as up until 2.0 RC1)
* added appropriate "equals"/"hashCode" implementations to DefaultMessageSourceR
esolvable
* fixed SpringVersion to return null if the package is not determinable because
of ClassLoader restrictions
* ResourceArrayPropertyEditor always preserves order of resource entries, even o
n JDK 1.3 without Commons Collections
* PathMatchingResourcePatternResolver ignores classpath roots that cannot be res
olved as jar or in file system
* introduced EjbAccessException as replacement of AOP Alliance AspectException i
n local/remote SLSB invoker interceptors
* removed unused AbstractLoadTimeWeaver and AspectJWeavingTransformer classes
* reworked ReflectiveLoadTimeWeaver to cache Method references and consider "get
ThrowawayClassLoader" as optional
* fixed AbstractOverridingClassLoader to override "loadClass(name, resolve)" and
correctly synchronize its variables
* fixed and reworked AbstractOverridingClassLoader's facility for excluding clas
s names
* added OC4JLoadTimeWeaver for Oracle OC4J 10.1.3.1+
* SingleConnectionFactory's Connection proxy implements "equals" and "hashCode"
based on proxy equality
* factored out "resetConnection", "prepareConnection" and "closeConnection" meth
ods in SingleConnectionFactory
* refined DataSourceUtils to catch Throwable on "Connection.close()"
* DataSourceUtils uses lower synchronization order for delegating handles (such
as from TransactionAwareDataSourceProxy)
* SingleConnectionDataSource's Connection proxy implements "equals" and "hashCod
e" based on proxy equality
ods in SingleConnectionDataSource
* CommonsDbcpNativeJdbcExtractor supports original Commons DBCP as well as Tomca
t 5.5's relocated version
* revised JBossNativeJdbcExtractor to unwrap ResultSet even for WrappedResultSet
subclasses (requires JBoss 3.2.4+ now)
* DataSourceLookup throws DataSourceLookupFailureException instead of DataAccess
ResourceFailureException
* added SingleDataSourceLookup, exposing a single given DataSource for any data
source name
* added AbstractInterruptibleBatchPreparedStatementSetter base class, with singl
e "setValuesIfAvailable" callback method
* added default SQL error codes for the Apache Derby database
* SingleConnectionFactory's Connection proxy implements "equals" and "hashCode"
based on proxy equality
* SingleConnectionFactory's Connection proxy ignores "stop()" calls as well (not
just "close()" calls)
ods in SingleConnectionFactory
* added "exceptionListener" and "reconnectOnException" properties to SingleConne
ctionFactory
* JmsTemplate and AbstractMessageListenerContainer call "stop()" on a Connection
before closing it (if started before)
* DefaultMessageListenerContainer does not block on startup until it can establi
sh a shared Connection (if necessary)
* added support for synchronized local JMS transactions (alongside some other ma
in transaction) to JmsTemplate
* added TransactionAwareConnectionFactoryProxy, including support for synchroniz
ed local JMS transactions
* iBATIS support works correctly with "useTransactionAwareDataSource" and JTA tr
ansaction resume with subsequent access
* reintroduced default SQLExceptionTranslator in JdoAccessor/JdoTransactionManag
er/LocalPersistenceManagerFactoryBean
* HibernateTemplate exposes Session proxies that implement the SessionImplemento
r interface as well now (if possible)
* exception translation for Hibernate3 turns PropertyValueException into Spring'
s DataIntegrityViolationException
* exception translation for Hibernate3 keeps original JDBCException as root caus
e of Spring's HibernateJdbcException
* added ScopedBeanInterceptor for Hibernate3, exposing the raw target class as e
ntity name in case of a scoped proxy
* LocalPersistenceManagerFactoryBean and JdoTemplate perform full exception tran
slation even for reflective calls
* expose underlying PersistenceProvider instance in EntityManagerFactoryInfo (if
available)
* added "persistenceProvider" property to AbstractEntityManagerFactoryBean, for
using a shared PersistenceProvider
* JpaVendorAdapter exposes a shared PersistenceProvider instance rather than jus
t the PersistenceProvider class
* added PersistenceUnitManager interface and DefaultPersistenceUnitManager imple
mentation (in "jpa.persistenceunit")
* added "persistenceUnitManager" bean property to LocalContainerEntityManagerFac
toryBean (default is internal manager)
* "dataSourceLookup"/"dataSources" configuration is now available on DefaultPers
istenceUnitManager instead of LCEMFB
* "postProcessPersistenceUnitInfo" hook method is now available on DefaultPersis
tenceUnitManager instead of LCEMFB
* introduced PersistenceUnitPostProcessor interface, to be registered on Default
PersistenceUnitManager or LCEMFB
* introduced MutablePersistenceUnitInfo base class, to turn SpringPersistenceUni
tInfo to package-protected again
* PersistenceUnitReader searches for "classpath*:**/SCHEMA_NAME" last, and catch
es and logs any IOException thrown
* added support for custom JPA properties to SharedEntityManagerBean/JpaTransact
ionManager/JpaInterceptor/JpaTemplate
* added support for custom JPA properties to OpenEntityManagerInViewInterceptor
* PersistenceAnnotationBeanPostProcessor supports @PersistenceContext's "propert
ies", passed into "createEntityManager"
* PersistenceAnnotationBeanPostProcessor does not cache EntityManagerFactory ins
tances anymore, to allow for new EMFs
* PersistenceAnnotationBeanPostProcessor throws IllegalStateException instead of
NoSuchBeanDefinitionException
* added support for attributes which implement the Servlet 2.3 HttpSessionBindin
gListener interface to MockHttpSession
* added service URL check to UrlBasedRemoteAccessor, in the form of an Initializ
ingBean implementation
* refined cache synchronization in (Jndi)RmiClientInterceptor and JaxRpcPortClie
ntInterceptor
* reworked RmiClientInterceptor to throw RemoteLookupFailureException instead of
MalformedURLException/RemoteException
* reworked Hessian/BurlapClientInterceptor to throw RemoteLookupFailureException
instead of MalformedURLException
* Hessian/BurlapClientInterceptor configure a Hessian/BurlapProxyFactory directl
y (dropped CauchoRemoteAccessor)
* added "serializerFactory" and "sendCollectionType" properties to HessianClient
Interceptor/ProxyFactoryBean
* added "serializerFactory" property to HessianServiceExporter, applied to Hessi
anInput/Output objects
* HessianServiceExporter is compatible with the Hessian 2 protocol (Hessian vers
ion 3.0.20+) as well as classic Hessian
* Spring's Quartz support requires Quartz 1.5 or higher now
* added support for Quartz 1.5 JobFactory to SchedulerFactoryBean, through "jobF
actory" bean property
* SchedulerFactoryBean uses AdaptableJobFactory as default, which also supports
Runnables as job class
* added SpringBeanJobFactory as subclass of AdaptableJobFactory, as JobFactory r
eplacement for QuartzJobBean
* JobDetailBean allows any job class to be specified, to allow a JobFactory to a
dapt any class to the Job interface
* added "jobDataAsMap" property to Simple/CronTriggerBean, supporting the Quartz
1.5 notion of trigger-specific job data
* MethodInvokingJobDetailFactoryBean always creates durable JobDetails (just lik
e it also sets the volatile flag)
* fixed BshScriptFactory to correctly handle void, null, and primitive return va
lues
* fixed JRubyScriptFactory to handle "toString()" invocations locally on the JRu
by object proxy
* AbstractSpringContextTests calls ConfigurableApplicationContext's "registerShu
tdownHook()" for each context instance
* factored out concrete loading of a single context from specified config locati
ons to AbstractSingleSpringContextTests
* restricted visibilities and stronger use of final in AbstractDependencyInjecti
onSpringContextTests
* added "afterCommit" callback to TransactionSynchronization interface
* fixed TransactionAttributeSourceAdvisor to avoid potential NPE in TransactionA
ttributeSourcePointcut's "hashCode"
* added "getPropertyEditorRegistry" method to BindingResult interface, for re-re
gistering custom editors
* AbstractBindingResult's "addAllErrors" only accepts Errors instance with same
object name
* added appropriate "toString" implementation to AbstractBindingResult
* added appropriate "equals"/"hashCode" implementations to AbstractBindingResult
and BindException
* added appropriate "equals"/"hashCode" implementations to ObjectError and Field
Error
* ExpressionEvaluationUtils falls back to Jakarta JSTL if JSP 2.0 ExpressionEval
uator API present but not implemented
* added support for attribute destruction callbacks to RequestAttributes abstrac
tion + Servlet/PortletRequestAttributes
* introduced "requestCompleted()" method in AbstractRequestAttributes base class
for Servlet/PortletRequestAttributes
* adapted TagUtils to accept subclassed parent tag as expected ancestor too (e.g
. OptionTag within subclassed SelectTag)
* AbstractJasperReportsView converts exporter parameter values "true"/"false" to
Boolean.TRUE/FALSE
* removed deprecated FormatHelper from XSLT view package
* fixed various JSP form tag issues

--------------------------------------
General
* spring.jar does not include Portlet support anymore (add spring-portlet.jar to
your classpath if needed)
* factored out AbstractGenericPointcutAdvisor (with a configurable Advice) as su
bclass of AbstractPointcutAdvisor
* fixed AbstractAdvisorAutoProxyCreator to ignore Advisors for which "getBean" t
hrows a BeanCurrentlyInCreationException
* fixed AnnotationAwareAspectJAutoProxyCreator to explicitly ignore FactoryBeans
when looking for aspect beans
* reworked AspectJ auto-proxy creation to avoid the creation of unnecessary prox
ies
* renamed ScopedObject's "remove" method to "removeFromScope", to avoid conflict
s with methods on the target class
* added overloaded "setPropertyValues" variant with additional "ignoreInvalidFie
lds" flag to PropertyAccessor
* fixed BeanWrapperImpl to properly catch and wrap conversion failures for map k
eys/values in TypeMismatchExceptions
* introduced TypeConverter interface, implemented by BeanWrapperImpl, plus separ
ate SimpleTypeConverter implementation
* refined PropertyAccessExceptionsException to show nested details even when wra
pped in a standard JDK exception
* reworked ArgumentConvertingMethodInvoker to use a TypeConverter and allow the
converter to be accessed/overridden
* BeanFactoryUtils returns bean names in order of definition even for merged nam
e arrays (in case of ancestor factories)
* redefined BeanFactoryUtils' "countBeans/beanNamesIncludingAncestors" to build
on "getBeanNamesOfType(Object.class)"
* reworked InstantiationAwareBeanPostProcessor's "postProcessPropertyValues" met
hod to take a PropertyDescriptor array
* RequiredAnnotationBeanPostProcessor explicitly ignores special setter methods
(such as "setBeanName"/"setBeanFactory")
* added "copyConfigurationFrom" method to ConfigurableBeanFactory, allowing to c
reate a factory with same configuration
* exposed "getScope" and "setScope" methods on BeanDefinition interface, allowin
g a post-processor to override the scope
* DefaultSingletonBeanRegistry disallows the creation (or recreation) of singlet
ons during "destroySingletons()" phase
* fixed AbstractBeanFactory to only invoke BeanPostProcessor for objects returne
d from FactoryBeans if non-null
* fixed AbstractBeanFactory to throw BeanCurrentlyInCreationException on null fr
om non-fully-initialized FactoryBean
* AbstractBeanFactory's "getType" catches BeanCreationExceptions for a FactoryBe
an, treating it as "type unknown"
* AbstractBeanFactory catches an exception thrown from a FactoryBean's "getObjec
tType", treating it as "type unknown"
* AbstractAutowireCapableBeanFactory detects whether it injected raw instances o
f beans that eventually got wrapped
* refined AbstractAutowireCapableBeanFactory to only adapt inner bean names for
uniqueness in case of a singleton
* refined AbstractAutowireCapableBeanFactory to reject an inner bean marked as s
ingleton contained in a non-singleton
* DefaultListableBeanFactory's non-eager lookup by type finds matches for lazy-i
nit beans as long as class is loadable
* added "setAllowEagerClassLoading" method to DefaultListableBeanFactory, to all
ow for turning off eager class loading
* restored Spring 1.2 compatibility for default-lazy-init="true", with respect t
o detection of special beans by type
* "idref" tag in XML bean definitions gets turned into a RuntimeBeanNameReferenc
e, which gets validated on bean creation
* XML definitions for inner beans receive a default scope based on their contain
ing bean (prototype for a non-singleton)
* DefaultBeanDefinitionDocumentReader does not accept bean definitions with both
"scope" and "singleton" values anymore
* added "isActive()" method to the ConfigurableApplicationContext interface
* AbstractRefreshableApplicationContext disallows access to underlying BeanFacto
ry after a "close()" call
* avoid AbstractRefreshableApplicationContext deadlock in case of BeanFactory ac
cess in a multi-threaded destroy method
* fixed PathMatchingResourcePatternResolver to prevent eternal recursion in case
of invalid prefix with pattern symbols
* factored out reusable PersistenceExceptionTranslationInterceptor from Persiste
nceExceptionTranslationAdvisor
* worked around "oracle.sql.DATE" problem on certain Oracle driver versions, ext
racting it as timestamp when appropriate
* check for ResultSetSupportingSqlParameter superclass instead of SqlOutParamete
r and SqlReturnResultSet subclasses
* factored out Spring/JtaLobCreatorSynchronization classes from Hibernate Abstra
ctLobType to "jdbc.support.lob" package
* introduced CachingDestinationResolver interface, implemented by JndiDestinatio
nResolver (allowing to clear the cache)
* JmsTransactionManager starts the transactional Session's Connection early (at
transaction begin) rather than on demand
* optimized JmsTemplate's resource handling to reuse the obtained JMS Connection
/Session within a JTA transaction
* added "clientId" property to SingleConnectionFactory(102), for assigning a cli
ent id to the underlying Connection
* added "clientId" property to AbstractMessageListenerContainer, for assigning a
client id to the underlying Connection
* AbstractMessageListenerContainer supports individual Connections per listener
as alternative to a shared Connection
* DefaultMessageListenerContainer obtains all JMS resources fresh by default in
case of "transactionManager" specified
* added "cacheLevel"/"cacheLevelName" property to DefaultMessageListenerContaine
r, for overriding the default caching
* DefaultMessageListenerContainer is able to recover from a broken Connection (b
oth with and without cached Connection)
* DefaultMessageListenerContainer is able to recover from a broken Destination i
f obtained via JndiDestinationResolver
* DefaultMessageListenerContainer waits until all listener tasks have completed
before returning from "destroy"
* added "taskExecutor" property to SimpleMessageListenerContainer, allowing to e
xecute listener in different thread
* added protected "buildListenerArguments" template method to MessageListenerAda
pter, allowing for multiple arguments
* refined iBATIS SqlMapClientTemplate to allow for nested calls to same SqlMapSe
ssion (checking "getCurrentConnection")
* reworked Hibernate JTA synch to expose beforeCompletion exceptions to the call
er (via SpringJtaSynchronizationAdapter)
* updated TopLink API jar to be fully compatible with the official TopLink 10.1.
3 release jar (can be replaced with it)
* Hibernate3 and TopLink LocalSessionFactoryBeans implement the PersistenceExcep
tionTranslator interface now
* reworked Hibernate3 and TopLink exception translation to only apply a SQLExcep
tionTranslator if explicitly specified
* JDO LocalPersistenceManagerFactoryBean implements the PersistenceExceptionTran
slator interface now
* DefaultJdoDialect only applies a SQLExceptionTranslator if explicitly specifie
d (rely on default JDO translation else)
* removed warning for read-only from JdoTransactionManager/JpaTransactionManager
, since a vendor dialect may support it
* factored out overridable "createEntityManager" template methods in OpenEntityM
anagerInViewFilter/Interceptor
* EntityManagerFactoryInfo interface does not extend PersistenceExceptionTransla
tor anymore (only JpaDialect does)
* SpringPersistenceUnitInfo is public to allow for post-processing in LocalConta
inerEntityManagerFactoryBean subclass
* added "determinePersistenceUnitInfo/postProcessPersistenceUnitInfo" methods to
LocalContainerEntityManagerFactoryBean
* reworked OpenSession/PersistenceManager/EntityManagerInViewInterceptor to buil
d on WebRequestInterceptor abstraction
* dropped PortletOpenSession/PersistenceManager/EntityManagerInViewInterceptor i
n favor of WebRequestInterceptor model
* MockHttpServletRequest handles HTTP header names as case-insensitive
* added "registryClientSocketFactory" bean property to RmiClientInterceptor/RmiP
roxyFactoryBean
* added dedicated "prepare()" method to JndiRmiServiceExporter
* renamed SchedulingTaskExecutor's "isShortLivedPreferred" method to "prefersSho
rtLivedTasks"
* ScriptFactoryPostProcessor supports all callbacks that containing BeanFactory
supports (e.g. ApplicationContextAware)
* AbstractTransactionalSpringContextTests only tries to end transaction on "tear
Down" if the transaction is still active
* fixed AbstractPlatformTransactionManager to not invoke commit synchronization
in case of propagated rollback-only flag
* added SpringJtaSynchronizationAdapter, exposing JTA Synchronization ifc on top
of a Spring TransactionSynchronization
* added "timeout" attribute to Transactional annotation, allowing to specify a t
imeout in seconds within the annotation
* optimized "ObjectUtils.nullSafeToString" implementation to return a given Stri
ng right away
* added "ignoreInvalidFields" flag to DataBinder, allowing to ignore inaccessibl
e fields (null value in nested path)
* redefined Servlet/PortletRequestUtils to treat empty parameter values as valid
for Strings ("") and booleans (false)
* moved RequestScope/SessionScope and RequestContextListener from "web.context.s
cope" to "web.context.request"
* added WebRequest abstraction, with ServletWebRequest and PortletWebRequest imp
lementations
* added WebRequestInterceptor interface, for generic request interceptors (indep
endent of Servlet/Portlet)
* added support for WebRequestInterceptors to Servlet/Portlet MVC HandlerMapping
s (through "interceptors" property)
* renamed PortletBean to GenericPortletBean
* HttpServletBean/GenericPortletBean override "getXXXXletName"/"getXXXXletContex
t" to return null when no config set yet
* added "defaultLocale" property to CookieLocaleResolver and SessionLocaleResolv
er, for fallback to an explicit locale

-------------------------------------
General
* added showcases to "samples" directory
* various documentation clarifications
* restored compatibility with IBM JDK 1.3 (with respect to referring to constant
s defined in implemented interfaces)
* JdkDynamicAopProxy delegates "equals"/"hashCode" calls to target if "equals"/"
hashCode" is defined on proxy interface
* Advisors used in combination with an advisor auto-proxy creator can now use be
ans which get adviced themselves
* moved AbstractAutoProxyCreator's "shouldSkip" check from "isInfrastructureClas
s" to "postProcessAfterInitialization"
* reworked AbstractAdvisorAutoProxyCreator to avoid fetching of all candidate Ad
visors on startup
* AbstractAdvisorAutoProxyCreator performs BeanFactory-based prototype cycle che
ck instead of control flow check
* factored out SingletonBeanRegistry interface from ConfigurableBeanFactory inte
rface
* factored out DefaultSingletonBeanRegistry base class from AbstractBeanFactory
* added "isCurrentlyInCreation" method to ConfigurableBeanFactory interface
* reworked AbstractBeanFactory to allow for prototype cycle check for current th
read
* fixed AbstractBeanFactory's "isBeanNameUsed" to correctly synchronize access t
o "dependentBeanMap"
* AbstractAutowireCapableBeanFactory creates "depends-on" beans even before reso
lving a bean's class
* AbstractAutowireCapableBeanFactory does not apply bean post-processors to "syn
thetic" beans
* AbstractAutowireCapableBeanFactory accepts null values returned from BeanPostP
rocessors
* added "synthetic" flag to AbstractBeanDefinition, for marking beans as interna
l infrastructure beans
* XmlBeanDefinitionReader uses given ResourceLoader/ApplicationContext's ClassLo
ader for schema resolution
* MethodInvokingFactoryBean returns "void.class" instead of "VoidType.class" for
void methods
* AbstractApplicationContext uses the ClassLoader of its parent ApplicationConte
xt (if any) as default
* turned ApplicationObjectSupport's "getApplicationContext()" method from public
to protected (for consistency)
* NestedXxxException classes build nicer messages in case of root cause with no
base exception message
* added "getClassLoader()" method to ResourceLoader, exposing the ClassLoader fo
r direct access
* adapted PathMatchingResourcePatternResolver to always use the ResourceLoader's
ClassLoader
* added "getResourcePatternResolver(ResourceLoader)" utility method to ResourceP
atternUtils
* reworked JDBC 3.0 savepoint support to use self-generated savepoint names (to
avoid unnamed savepoints on IBM DB2)
* removed "S0" from default SQL state list in SQLStateSQLExceptionTranslator: it
does not mean bad SQL on MS SQL Server
* SqlQuery and SqlUpdate correctly handle a named parameter with a list of value
s now
* added support for durable subscriptions to message listener containers, driven
by "durableSubscriptionName" property
* MBeanRegistrationSupport only logs a warning (no error) when an MBean does not
exist anymore when trying to unregister
* LocalContainerEntityManagerFactoryBean detects and reads all "META-INF/persist
ence.xml" files on the class path
* LocalContainerEntityManagerFactoryBean determines persistence unit root URL ba
sed on each "persistence.xml" location
* JdoTransactionManager uses JDO 2.0's rollback-only facility if available
* JpaTransactionManager uses JPA's rollback-only facility now, for better integr
ation with the persistence provider
* JpaTransactionManager throws UnexpectedRollbackException in case of JPA Rollba
ckException thrown from commit
* refined JPA exception translation to throw EmptyResultDataAccessException in c
ase of JPA NoResultException
* refined JPA exception translation to throw IncorrectResultSizeDataAccessExcept
ion in case of JPA NonUniqueResult
* refined JPA exception translation to throw DataIntegrityViolationException in
case of JPA EntityExistsException
* refined JPA exception translation to throw InvalidDataAccessResourceUsageExcep
tion in case of JPA TransactionRequired
* refined Hib exception translation to throw InvalidDataAccessApiUsageException
in case of Hibernate ObjectDeleted
* refined Hib exception translation to throw IncorrectResultSizeDataAccessExcept
ion in case of Hibernate NonUniqueResult
* JaxRpcPortClientInterceptor/JaxRpcPortProxyFactoryBean allow for direct "custo
mPropertyMap[myKey]" access
* Quartz SchedulerFactoryBean uses given "nonTransactionalDataSource" as default
DataSource if no "dataSource" specified
* AbstractTransactionalSpringContextTests properly ends a started transaction ea
rly if "onSetupInTransaction" fails
* JtaTransactionManager explicitly only calls "UserTransaction.setRollbackOnly()
" if the transaction is still active
* clarified that "Errors.reject" always registers a global error for the entire
target object
* "Errors.rejectValue" now accepts an empty field name to indicate the current o
bject itself rather than a field of it
* added/moved constants for all Servlet spec include/forward request attributes
to WebUtils
* added "getWebApplicationContext"/"getAutowireMode"/"getDependencyCheck" method
s to Autowiring(Tiles)RequestProcessor
* DispatcherServlet logs its page-not-found warnings with the actual lookup URL
even for import requests
* InternalResourceView exposes all forward request attributes (delegating to "We
bUtils.exposeForwardRequestAttributes")
* RequestContext's "getContextPath()" always exposes the context path for the or
iginating request now
* added "getQueryString" method to RequestContext, exposing query string for ori
ginating request (even after forward)

--------------------------------------
General
* completed reference documentation
* fixed various documentation issues
* spring.jar includes all standard modules except for the Hibernate2 support (wh
ich has been superseded by Hibernate3)
* basic download only contains reference PDF: no HTML variant and API docs anymo
re (only in -with-dependencies now!)
* fixed AspectJAutoProxyCreator to avoid NPE in case of abstract beans without b
ean class specified
* FactoryBeans are allowed to return null values now, with FactoryBeanNotInitial
izedException to be thrown by themselves
* fixed AbstractBeanFactory's "getType" to avoid NPE in case of a bean definitio
n without bean class
* AbstractBeanFactory uses inverse order of bean instantiation for shutdown even
without dependency relationships
* fixed DefaultListableBeanFactory to not call "FactoryBean.getObject()" for pro
totype if bean class not resolved yet
* avoid ClassNotFoundException in case of explicit type specified on "value" tag
* resolve target type of a TypedStringValue lazily, consistent with the handling
of bean classes
* moved parsing-related support classes from "beans.factory"/"beans.factory.supp
ort" to "beans.factory.parsing"
* StaticLabeledEnum offers its "readResolve" method with protected visibility, t
o kick in for subclasses as well
* fixed AbstractSlsbInvokerInterceptor to reobtain createMethod in case of cache
Home="false"/lookupHomeOnStartup="true"
* added "cacheSessions" flag to DefaultMessageListenerContainer, to be turned of
f for reobtaining Sessions per receive
* added "handleListenerSetupFailure" callback to DefaultMessageListenerContainer
, a sibling of "handleListenerException"
* DefaultMessageListenerContainer invokes a specified JMS ExceptionListener for
listener setup failures as well
* removed LocalSessionFactoryBean's early "buildMappings" call to avoid side eff
ects with AnnotationSessionFactoryBean
* HibernateTransactionManager explicitly disconnects a pre-bound Session after a
transaction (on Hibernate 3.1+)
* Hibernate Open-Session-In-View's deferred close mode always switches its Sessi
ons to FlushMode.NEVER until closing
* refined HibernateTemplate to never register a Session for deferred close in ca
se of "alwaysUseNewSession"=true
* removed special Session reconnection check for Hibernate 3.1 RC1
* renamed ContainerEntityManagerFactoryBean to "LocalContainerEntityManagerFacto
ryBean"
* fixed LocalContainerEntityManagerFactoryBean to always look for "META-INF/pers
istence.xml" in class path by default
* JpaTransactionManager autodetects the JDBC DataSource of the target EntityMana
gerFactory
* added JPA support to PetClinic: EntityManagerClinic and JpaTemplateClinic, wit
h TopLink Essentials as default provider
* added "jobListenerNames" bean property to MethodInvokingJobDetailFactoryBean
* fixed "spring-lang.xsd" to allow for multiple nested property elements
* fixed (the deprecated) BindUtils to not call "ValidatorUtils.invokeValidator"
if no Validator given
* fixed Servlet/PortletRequestAttributes to correctly update accessed attributes
* turned WebContentGenerator's method constants public again, for calling "setSu
pportedMethods" in subclasses
* FrameworkPortlet now catches all RuntimeException/Errors and rethrows them as
PortletException
* PortletContentGenerator response preparation operates on RenderRequest and Ren
derResponse only
* changed Portlet HandlerInterceptor interface to have explicit callback methods
for action/render requests
* Portlet HandlerInterceptorAdapter allows to adapt the specific action/render c
allback methods to general callbacks
* Portlet OpenXxxInViewInterceptors just wrap the render request, not the action
request anymore
* VelocityView and FreeMarkerView do not override content type previously set on
HTTP response anymore (on Servlet 2.4+)
* moved content type handling from VelocityView and FreeMarkerView up to Abstrac
tTemplateView
Changes in version 2.0 M5 (1.6.2006)

------------------------------------
General
* spring.jar is now all-encompassing, including all modules (with the exception
of mock and aspects)
* spring-aop.jar does not contain AOP Alliance interfaces (in contrast to spring
.jar); explicitly add aopalliance.jar
* reworked support for scoped proxies to build on scoping support in core BeanFa
ctory
* removed incomplete support for ScopedObject handles and persistent scopes
* removed deprecated AttributesPooling/Prototype/ThreadLocalTargetSourceCreator
* removed unused Class argument from ParameterNameDiscoverer's "getParameterName
s(Method)"
* reworked ProxyFactoryBean's "setProxyInterfaces" method from String array to C
lass array
* reworked ProxyFactoryBean to use the ClassLoader passed in through BeanClassLo
aderAware
* factored out AbstractSingletonProxyFactoryBean from TransactionProxyFactoryBea
n
* introduced lazy loading (and lazy validation) of bean classes in standard bean
factories and bean definition readers
* redefined ListableBeanFactory's "includeFactoryBeans" flag for "getBean(Name)s
OfType" into "allowEagerInit"
* introduced BeanClassLoaderAware interface, for passing the factory's class loa
der to beans that resolve class names
* reworked all FactoryBeans that resolve class names to leverage the BeanClassLo
aderAware mechanism
* PropertyPlaceholderConfigurer is able to resolve placeholders in lazily loaded
bean class names
* added support for PropertyEditorRegistrars to ConfigurableBeanFactory, for non
-synchronized usage of custom editors
* CustomEditorConfigurer supports PropertyEditorRegistrars, to be applied to its
containing BeanFactory
* reworked ConfigurableBeanFactoryUtils into ResourceEditorRegistrar
* added "postProcessPropertyValues" callback method to InstantiationAwareBeanPos
tProcessor interface
* reworked RequiredBeanFactoryPostProcessor into RequiredAnnotationBeanPostProce
ssor, properly handling bean inheritance
* added scoping support to core BeanFactory, for creating raw target beans in ar
bitrary scopes
* added "scope" attribute at bean level to XML bean definition format, supersedi
ng singleton="true"/"false"
* renamed XmlBeanDefinitionReader's (Default)XmlBeanDefinitionParser SPI to (Def
ault)BeanDefinitionDocumentReader
* renamed XmlBeanDefinitionParserHelper to BeanDefinitionParserDelegate
* re-introduced Spring 1.2 XmlBeanDefinitionParser SPI for backwards compatibili
ty in case of "parserClass" specified
* synchronized AbstractApplicationContext's "refresh()" method, for hot refreshi
ng in concurrent environments
* renamed GenericsHelper to GenericCollectionTypeResolver, more clearly reflecti
ng its actual role
* AnnotationUtils discovers annotations inherited via bridge methods now, throug
h the new BridgeMethodResolver
* added generic PersistenceExceptionTranslator mechanism, supported by the JpaDi
alect abstraction for JPA providers
* added PersistenceExceptionTranslationPostProcessor, for automatic translation
to DataAccessExceptions
* introduced class instrumentation support based on standard ClassFileTransforme
rs (used by JPA SPI support)
* introduced LoadTimeWeaver abstraction for instrumentation-aware ClassLoaders p
lus throwaway ClassLoader support
* refined default SQL error codes for DB2 and HSQLDB
* removed deprecated special check for DB2 error codes - always use "DB2*" as da
tabase product name for DB2
* reworked SimpleJdbcDaoSupport/NamedParameterJdbcDaoSupport initialization to w
ork without afterPropertiesSet as well
* Hibernate3 LocalSessionFactoryBean explicitly calls "buildMappings()" to prepa
re Configuration metadata for subclasses
* fixed JpaTransactionManager to not cause an NPE when the creation of a transac
tional EntityManager raises an exception
* fixed JpaInterceptor to actually bind a new EntityManager to the thread again
(worked in M3, didn't work in M4)
* fixed EntityManagerFactoryUtils's "convertJpaAccessException" to always return
rather than throw DataAccessExceptions
* added full support for JPA SPI, in the form of a ContainerEntityManagerFactory
Bean with LoadTimeWeaver support
* added JpaVendorAdapter abstraction, with out-of-the-box TopLinkJpaVendorAdapte
r and HibernateJpaVendorAdapter
* added PersistenceAnnotationPostProcessor, processing EJB3-style @PersistenceUn
it and @PersistenceContext annotations
* added support classes for annotation-based tests in general and for JPA-based
tests in particular
* added "failEarlyOnGlobalRollbackOnly" flag to AbstractPlatformTransactionManag
er, for consistent fail-early behavior
* "ClassUtils.isPresent" logs exception message only instead of full stacktrace
for classes that haven't been found
* introduced PatternMatchUtils, for unified matching of Spring's typical "xxx*",
"*xxx" and "*xxx*" pattern styles
* reworked ValidationUtils to not accept a null Validator for "invokeValidator"
anymore
* added "setDisallowedFields" method to DataBinder, for specifying disallowed fi
elds instead of allowed fields
* reworked mvc RequestHandler interface into HttpRequestHandler in root web pack
age, to minimize module dependencies
* reworked RequestMethodNotSupportedException into HttpRequestMethodNotSupported
Exception in root web package
* reworked SessionRequiredException into HttpSessionRequiredException and Portle
tSessionRequiredException
* added HttpRequestHandlerServlet to "web.context.support" package, for exposing
a single HttpRequestHandler bean
* dropped "getCause()" method from NestedServletException, to avoid conflicts wi
th JDK-1.4-based ServletException class
* added support for request and session scopes to all WebApplicationContexts
* moved StaticPortletApplicationContext from test tree over to main source tree
* fixed SimpleMappingExceptionResolver to use local "exceptionMappings" referenc
e
* factored out reusable "prepareBinder" method in BaseCommandController, for eas
ier overriding of "createBinder"
* InternalResourceView exposes Servlet 2.4 forward request attributes even for S
ervlet 2.3-
* added "getOriginatingRequestUri" method to UrlPathHelper, detecting the Servle
t 2.4 request URI attribute in a forward
* refined JSP form tag library

-------------------------------------
General
* included "tiger" and "aspectj" source trees in source build (spring-src.zip)
* included spring-src.zip in both release distributions as a convenience
* basic distribution doesn't include build script and exploded source trees anym
ore
* fixed Cglib2AopProxy to register an explicitly given ClassLoader with the CGLI
B Enhancer
* deprecated Commons Attributes based TargetSourceCreators (PoolingAttribute, Pr
ototypeAttribute, ThreadLocalAttribute)
* fixed CustomizableTraceInterceptor to expose the actual invocation time for ex
ception messages
* added "trackAllInvocations" flag to JamonPerformanceMonitorInterceptor, for ga
thering statistics without logging
* auto-proxying works for objects created by FactoryBeans as well (rather than j
ust on FactoryBean instances themselves)
* BeanNameAutoProxyCreator always proxies exposed objects, with "&beanName" synt
ax for proxying FactoryBean instances
* renamed "aspectj.autoproxy.AspectJAutoProxyCreator" to "aspectj.annotation.Ann
otationAwareAspectJAutoProxyCreator"
* BeanUtils throws explicit BeanInstantiationException in case of bean instantia
tion failure
* deprecated BeanUtils's "isAssignable" methods in favor of new "isAssignable"/"
isAssignableValue" methods on ClassUtils
* fixed BeanWrapperImpl to convert a null input for an array type to a null valu
e rather than an array with null element
* fixed BeanWrapperImpl to apply property-specific editors to elements even for
collections without generic type
* refined BeanWrapperImpl to apply map key conversion on property access as well
, not just on property setting
* refined BeanWrapperImpl to inject original collections as far as possible (i.e
. unless element conversion necessary)
* refined BeanWrapperImpl to correctly detect element type of collections with p
arameterization in superclass/interface
* BeanWrapperImpl does not register a StringArrayPropertyEditor by default anymo
re
* fixed BeanWrapperImpl to convert a ManagedProperties instance into a plain Pro
perties instance before applying it
* fixed BeanWrapperImpl to fall back to approximate collection/map type if it ca
nnot reinstantiate given collection/map
* fixed BeanArrayPropertyEditor to translate null value to null byte array
* added CharArrayPropertyEditor to translate String value into char array
* CharacterEditor supports unicode specification passed in as literal String, fo
r example "\u00F6"
* refined FileEditor to treat absolute file paths as straight files (no Resource
Loader), for Spring 1.2 compatibility
* PropertyPlaceholderConfigurer catches and logs SecurityException on system pro
perty access, continuing resolution
* FieldRetrievingFactoryBean is able to access non-public fields as well
* added "propertiesArray" bean property to PropertiesFactoryBean, for merging mu
ltiple local Properties instances
* fixed AbstractBeanFactory to avoid potential deadlock on singleton destruction
with concurrent singleton creation
* AbstractBeanFactory always registers inner beans with a unique name, adapting
overlapping names accordingly
* AbstractBeanFactory caches objects returned from "FactoryBean.getObject()" now
, in case of a singleton object
* BeanPostProcessor's "postProcessAfterInitialization" gets applied to objects c
reated by FactoryBeans as well
* BeanPostProcessor's "postProcessAfterInitialization" gets applied after "postP
rocessBeforeInstantiation" as well
* fixed DefaultListableBeanFactory to not preinstantiate bean definition if expl
icit singleton object already registered
* added "loadBeanDefinitions(String[] locations)" method to BeanDefinitionReader
and AbstractBeanDefinitionReader
* added Requiered annotation and RequiredBeanFactoryPostProcessor, allowing to e
nforce required bean properties
* refined AbstractMessageSource to resolve arguments eagerly, for message define
d in parent and msg arg defined in child
* added (String[], Class) constructors to ClassPathXmlApplicationContext, allowi
ng to load relative to a specified class
* refined NestedXxxException to be serialization-compatible with Spring 1.2
* refined NestedXxxException to properly handle null message in root cause, thro
ugh using the cause's "toString()"
* fixed FileSystemResource/UrlResource to retain leading "../" parts in paths, b
uilding correct relative paths for them
* ResourceEditor resolves placeholders in resource locations against system envi
ronment variables as well
* introduced PermissionDeniedDataAccessException, thrown for valid operation tha
t was rejected due to lack of permission
* added "permissionDeniedCodes" category to SQLErrorCodes, with default code 229
for MS SQL Server in sql-error-codes
* JdbcTemplate's "queryForString"/"queryForInt"/etc methods correctly detect inc
orrect result sizes even for null values
* turned JdbcTemplate's "query(PreparedStatementCreator,PreparedStatementSetter,
ResultSetExtractor rse)" method public
* JdbcTemplate does not check static SQL for bind parameters anymore, to avoid o
verhead of double parsing
* improved JdbcTemplate's logging of ignored SQLWarnings, including SQL state an
d error code in the log output
* refined NativeJdbcExtractorAdapter to retry with DatabaseMetaData Connection i
f extraction failed (for Hibernate 3.1)
* added NamedParameterJdbcTemplate which provides named parameters support for q
uery and update functionality
* added "allowsUnusedParameters()" and "checkCompiled()" methods to RdbmsOperati
on, for better customizing in subclasses
* refined StoredProcedure to accept unused entries in given parameter Maps by de
fault
* added named parameters support to SqlQuery/SqlUpdate hierarchy of classes
* AbstractMessageListenerContainer prefers SessionAwareMessageListener over Mess
ageListener (if both are implemented)
* added "exceptionListener" property to AbstractMessageListenerContainer, accept
ing a standard JMS ExceptionListener
* added "handleListenerException" template method to AbstractMessageListenerCont
ainer, by default logging at error level
* fixed DefaultMessageListenerContainer to properly use separate invokers per th
read, for actually concurrent Sessions
* fixed ServerSessionMessageListenerContainer(102) to use "createSession(Connect
ion)" method to avoid JMS 1.1 dependency
* added MessageListenerAdapter(102), delegating to listener methods that operate
on content types (String, byte array)
* reworked NotificationListenerBean to avoid overloaded bean property setters fo
r "mappedObjectNames"
* refined JavaMailSenderImpl to use "Session.getInstance(properties, null)", for
compatibility with (old) JavaMail 1.1
* added overloaded constructors to MockFilterConfig, using a MockServletContext
instead of a ServletContext argument
* updated JDO API 2.0 jar to 2.0 RC1 from the Apache JDO project
* updated JPA API 1.0 jar to build 40 from the GlassFish project
* fixed LocalSessionFactoryBean's "updateDatabaseSchema" to declare the correct
exception (DataAccessException)
* fixed BlobStringType for Hibernate2/3 to correctly handle SQL NULL
* refined JDO PersistenceManagerFactoryUtils to explicitly suspend pre-bound PM
in the course of transaction suspension
* refined JPA EntityManagerFactoryUtils to explicitly suspend pre-bound EM in th
e course of transaction suspension
* removed support for obsolete "EntityManagerFactory.getEntityManager()" method
from LocalEntityManagerFactoryBean
* added "entityManagerInterface" property to SharedEntityManagerAdapter, for exp
osing a vendor-extended interface
* adapted OpenEntityManagerInViewFilter/Interceptor to not specify obsolete Pers
istenceContextType.EXTENDED anymore
* fixed JpaDaoSupport's "setEntityManager" method to accept an EntityManager ins
tead of an EntityManagerFactory
* removed "getEntityManager()"/"getEntityManagerFactory()" accessor methods from
JpaDaoSupport
* removed "allowCreate" flag from JpaTemplate, always allowing creation (analogo
us to shared EntityManager)
* added "exceptionConversionEnabled" flag to HibernateInterceptor, TopLinkInterc
eptor, JdoInterceptor, JpaInterceptor
* HTTP invoker and RMI invoker fill the client-side portion of the stack trace i
nto transferred exceptions now
* RmiClientInterceptorUtils throws clearer exception message in case of proxy mi
smatch (for underlying RMI stubs)
* added "setContentType" configuration method to HttpInvokerServiceExporter and
AbstractHttpInvokerRequestExecutor
* built client-side HTTP GZIP response support into SimpleHttpInvokerRequestExec
utor/CommonsHttpInvokerRequestExecutor
* JaxRpcPortClientInterceptor synchronizes creation of JAX-RPC Calls, to make dy
namic invocations with Axis thread-safe
* refined JaxRpcPortClientInterceptor to only use JAX-RPC port if "portInterface
" specified (prefer dynamic invocations)
* added "setCustomPropertyMap" method to JaxRpcPortClientInterceptor/ProxyFactor
yBean, accepting String-Object pairs
* added AxisBeanMappingServicePostProcessor to "jaxrpc.support" package, for dec
larative registration of bean mappings
* refined Quartz SchedulerFactoryBean to re-register the associated JobDetail wh
en overwriting a JobDetailAwareTrigger
* fixed Quartz SchedulerFactoryBean to handle potential cluster race condition o
n trigger registration
* AOP-based auto-proxying works for scripted objects as well now
* added "lang" namespace for XML schema definitions, providing configuration for
beans written in dynamic languages
* AbstractPlatformTransactionManager logs "Should roll back transaction but cann
ot" message at debug level (not warn)
* TransactionInterceptor logs application exception at error level if commit thr
ows an exception
* added null-safe hashCode and toString methods to ObjectUtils (analogous to JDK
1.5), moved over from Spring Modules
* fixed StringUtils's "endsWithIgnoreCase" to correctly handle any String length
* fixed CollectionsUtils's "hasUniqueObject" to correctly handle null values
* refined NumberUtils to perform a value-in-range check for any Number returned
from a NumberFormat
* reworked MethodInvoker to match arguments against parameter types when searchi
ng for a matching method
* renamed SimpleMapBindingResult to MapBindingResult
* DataBinder does not use a default StringArrayPropertyEditor anymore, to nicely
handle select list entries with commas
* fixed ValidationUtils's "invokeValidator" to work correctly even in case of a
null reference as object to be validated
* added BindingResultUtils, providing convenience methods for looking up Binding
Results in a model Map
* refined GenericFilterBean to fully support initialization as bean in a Spring
bean factory (without FilterConfig)
* refined OncePerRequestFilter to fall back to bean name or fully qualified clas
s name if no filter name is available
* refined FrameworkServlet to log a request handling failure at debug level rath
er than error level
* refined AbstractRefreshablePortletApplicationContext to take PortletContext fr
om PortletConfig if not explicitly set
* factored out "handleNoSuchRequestHandlingMethod" method in MultiActionControll
er, to be overridden in subclasses
* fixed SimpleMappingExceptionResolver to correctly check the depth of all excep
tion mappings before choosing a view
* refined SimpleMappingExceptionResolver to only apply a "defaultStatusCode" to
a top-level request (not to an include)
* added "clearCache()" method to AbstractCachingViewResolver, for removing all c
ached view objects
* optimized BeanNameViewResolver to avoid internal throwing and catching of NoSu
chBeanDefinitionExceptions
* ExpressionEvaluationManager supports concatenated expressions (e.g. "${var1}te
xt${var2}") on all JSP 2.0 engines
* added optional caching of JSP 2.0 Expressions, driven by "cacheJspExpressions"
context-param in web.xml (true/false)
* "javaScriptEscape" feature of Spring tags correctly escapes "</script>" inside
a literal value
* fixed JSP SelectTag to correctly handle null values
* AbstractJasperReportsView and subclasses require JasperReports 1.0.1 or higher
(removed backwards compatibility check)
* fixed AbstractJasperReportsView and subclasses to be compatible with J2EE <1.4
(avoid response.setCharacterEncoding)
* AbstractJasperReportsView autodetects a JDBC DataSource in the model, as alter
native to specifying it in configuration
* Struts ContextLoaderPlugIn ignores "Action.setServlet(ActionServlet)" method w
hen performing a dependency check
* optimized Struts Delegating(Tiles)RequestProcessor to avoid unnecessary NoSuch
BeanDefinitionException throw+catch
* added Autowiring(Tiles)RequestProcessor, autowiring created Actions (configura
ble through ActionServlet init-params)

------------------------------------
* AbstractBeanFactoryBasedTargetSource offers explicit "setTargetClass" method,
else determines target class on demand
* renamed AbstractLazyInitTargetSource to AbstractLazyCreationTargetSource
* renamed AbstractPerformanceMonitorInterceptor to AbstractMonitoringInterceptor
* refined DebugInterceptor to keep its count in a field of type long instead of
int, with "long getCount()" accessor
* fixed DebugInterceptor to properly synchronize access to its count field in a
multithreading environment
* factored out extended PropertyAccessor and ConfigurablePropertyAccessor interf
aces from BeanWrapper/BeanWrapperImpl
* BeanWrapperImpl supports PropertyEditors exposed by PropertyDescriptors (typic
ally from BeanInfo classes)
* BeanWrapperImpl passes a null value to a PropertyEditor's "setValue" method, a
llowing for conversion of null values
* changed MutablePropertyValues's "addPropertyValue" signature back to void, to
remain binary compatible with Spring 1.2
* fixed PropertyTypeConverter to never build "null[...]" property paths that lea
d to exceptions in "findCustomEditor"
* fixed ArgumentConvertingMethodInvoker to perform conversion attempts on a copy
of the argument array (not the source)
* added "nullAsEmptyCollection" flag to CustomCollectionEditor, allowing to conv
ert a null value to an empty Collection
* added "containsLocalBean" method to HierarchicalBeanFactory interface, refacto
red from AbstractApplicationContext
* fixed AbstractBeanFactory to use canonical bean name (id) for prototype creati
on, exposing it to BeanPostProcessors
* fixed AbstractBeanFactory to destroy a failed bean completely, including depen
dent beans (in case of eager references)
* fixed AbstractBeanFactory's definition caching to allow for proper placeholder
substitution even with parent/child
* added "configureBean" method to AutowireCapableBeanFactory, fully configuring
an instance based on a bean definition
* DefaultListableBeanFactory does not instantiate "factory-bean" references anym
ore, not even for eager-init singletons
* re-added support for deprecated "class" property to PropertiesBeanDefinitionRe
ader, alongside "(class)"
* DefaultXmlBeanDefinitionParser considers "" as default namespace as well, for
compatibility with the Oracle XML parser
* AbstractApplicationContext discovers its context MessageSource as "messageSour
ce" bean even through an alias
* added "getRootCause()" method to NestedRuntime/CheckedException, for retrievin
g the innermost exception
* refined PropertiesLoaderUtils to use a URLConnection with "setUseCaches(false)
", to avoid jar file locking on Windows
* added further default SQL error codes for MS SQL, MySQL, and Oracle
* refined DataSourceUtils to expect an "afterCompletion" callback from a differe
nt thread (in case of JTA transaction)
* reworked DefaultMessageListenerContainer to allow for breaking the receive loo
p into smaller, schedulable tasks
* DefaultMessageListenerContainer defaults "maxMessagesPerTask" to 1 for short-l
ived-preferring SchedulingTaskExecutor
* renamed ServerSessionMessageListenerContainer's "maxMessages" to "maxMessagesP
erTask", for consistency
* fixed MBeanServerConnectionFactoryBean to avoid potential initialization of un
used JMX Connector on shutdown
* added "defaultObject" property to JndiObjectFactoryBean, allowing to fall back
to default object if JNDI lookup fails
* MockServletContext's "getResourcePaths" correctly resolves directories as path
s that end with a slash
* MockHttpServletResponse detects charset specification in "setContentType" and
sets character encoding accordingly
* fixed AbstractTransactionalSpringContextTests's "startNewTransaction" to initi
alize "complete" to "!defaultRollback"
* Hibernate LocalSessionFactoryBean offers protected "executeSchemaStatement" me
thod for overriding the failure handling
* fixed JpaTemplate's "findByNamedQuery" to correctly apply parameter indexes st
arting from 1
* added SchedulingTaskExecutor interface, letting an executor declare a preferen
ce for short-lived tasks
* all thread-pool-backed executors implement SchedulingTaskExecutor to expose a
preference for short-lived tasks
* added SchedulingAwareRunnable interface, exposing an "isLongLived" flag (analo
gous to CommonJ's "isDaemon")
* CommonJ WorkManagerTaskExecutor/DelegatingWork exposes SchedulingAwareRunnable
's "isLongLived" flag appropriately
* fixed TimerFactoryBean to properly initialize even without "scheduledTimerTask
s" configured
* fixed ScriptFactoryPostProcessor to let scripts receive bean references up the
entire container hierarchy
* added CompositeTransactionAttributeSource and "setTransactionAttributeSources(
[])" method for TransactionInterceptor
* JtaTransactionManager autodetects JNDI location "java:pm/TransactionManager" o
n Borland and Sun application servers
* fixed ResponseTimeMonitorImpl to properly synchronize access to its instance v
ariables in a multithreading environment
* added further accessors to Errors interface: hasFieldErrors(), getFieldErrorCo
unt(), getFieldErrors(), getFieldError()
* introduced BindingResult interface, as extension of the Errors interface
* reworked BindException to implement the BindingResult interface, wrapping an e
xisting BindingResult
* added BeanPropertyBindingResult and SimpleMapBindingResult implementations, ba
sed on a refactoring of BindException
* added "BindingResult getBindingResult()" method to DataBinder, deprecating the
"BindException getErrors()" method
* adapted BindingErrorProcessor interface to operate on a BindingResult instead
of a BindException
* added support for direct field access in the form of DirectFieldBindingResult
and DataBinder's "initDirectFieldAccess"
* changed WebApplicationContext's "ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE" to ac
tually start with the package name
* ContextLoader throws IllegalStateException if there is already a root applicat
ion context present
* fixed DispatcherServlet to keep and restore previous thread-bound LocaleContex
t and RequestAttributes
* added overloaded "getModelAndView" method with HttpServletRequest argument to
SimpleMappingExceptionResolver
* added "cookieSecure" property to CookieGenerator, indicating that cookies shou
ld only be sent using HTTPS connections
* added schema support for configuring a SimpleUrlHandlerMapping using spring-we
b.xsd
* renamed "Handler" interface to "RequestHandler", to differentiate it from the
dispatcher's generic "handler" concept
* moved ControllerClassNameHandlerMapping from package "web.servlet.mvc.mapping"
to "web.servlet.mvc"
* added "useDirectFieldAccess()" template method to BaseCommandController, for i
nitializing the DataBinder accordingly
* added overloaded "onFormChange" method with BindException argument to SimpleFo
rmController
* MultiActionController does not consider "handleRequest" itself as handler meth
od (to avoid potential stack overflow)
* added full JSP 1.2 form tag library in package "web.servlet.tags", complementi
ng the existing base tag library
* upgraded VelocityToolboxView to use Velocity Tools 1.2+ API and avoid using de
precated earlier API
* added VelocityLayoutViewResolver, a convenience subclass of VelocityViewResolv
er with support for VelocityLayoutView
* added protected "callNextHandlerInChain" method to DecoratingNavigationHandler
, to be called by subclasses

------------------------------------
Overall
* all of Spring must be built on JDK 1.5 now; the test suite is still able to ru
n on JDK 1.4 and 1.3
* added equals/hashCode implementations to all pointcuts and advisors
* removed restriction on proxying protected methods from Cglib2AopProxy
* allowed AopUtils's "invokeJoinpointUsingReflection" to invoke protected method
s
* added "autodetectInterfaces" to ProxyFactoryBean, for TransactionProxyFactoryB
ean style behavior (is the default now!)
* refined ProxyFactoryBean to lazily initialize a singleton proxy, to let "getOb
jectType()" expose the type beforehand
* improved performance of IntroductionInfoSupport by faster determination of whe
ther method is on introduced interface
* refined ThreadLocalTargetSource's synchronization to guarantee thread-safe des
truction on shutdown
* added "hideProxyClassNames" property to AbstractTraceInterceptor, to log with
target class instead of proxy class
* added "target.dynamic" package to support dynamic refresh of object instances
* added BeanFactoryRefreshableTargetSource to allow object instances to be refre
shed with new instances from BeanFactory
* AspectJ binding from pointcut expressions to arbitrary advice method arguments
now working
* support for introductions using AspectJ @DeclareParents
* support for new AspectJ 5 "pertypewithin" aspect instantiation model
* completed implementation of @AspectJ integration class MethodInvocationProceed
ingJoinPoint
* fixed PropertyAccessorUtils's "getLastNestedPropertySeparatorIndex" to correct
ly handle property paths without dot
* added overloaded constructor to StringArrayPropertyEditor, allowing to specify
a custom separator for String splitting
* BeanWrapperImpl keeps registered editors in a linked Map: the first registered
editor that matches will be used
* BeanWrapperImpl caches registered editors that match superclass or interface,
to avoid repeated assignable-from checks
* added support for bean properties with generic Collections/Maps, auto-converti
ng to their element/key/value type
* added support for constructor arguments with generic Collections/Maps, auto-co
nverting to their element/key/value type
* added "merge" attribute to "list"/"set/"map"/"props", for merging of collectio
n values across parent/child definitions
* added "default-merge" attribute to "beans" element to allow control of collect
ion merging at the file level
* changed FileEditor's behavior to consider input text as standard Spring resour
ce location (instead of plain filename)
* added "postProcessAfterInstantiation" method to InstantiationAwareBeanPostProc
essor
* fixed AbstractBeanFactory to correctly delegate to parent BeanFactory from "is
FactoryBean"
* optimized AbstractBeanFactory to avoid internal NoSuchBeanDefinitionException
throw+catch as far as possible
* AbstractBeanFactory caches merged bean definitions, for efficient prototype ch
ild creation and CGLIB class reuse
* reworked AbstractBeanFactory's currently-in-creation check to log debug messag
e when unfinished singleton is returned
* added "allowCircularReferences" flag to AbstractAutowireCapableBeanFactory, to
disallow circular references completely
* DefaultListableBeanFactory's "getBeansOfType" logs BeanCurrentlyInCreationExce
ption message instead of stacktrace
* refined DefaultXmlBeanDefinitionParser to explicity check for empty ref name a
nd throw meaningful exception
* DefaultXmlBeanDefinitionParser wraps unexpected exceptions in BeanDefinitionSt
oreException with context info
* inner bean parsing/instantiation exceptions get wrapped in outer exceptions wi
th appropriate context information
* moved general bean wiring support from "beans.factory.aspectj" to "beans.facto
ry.wiring"/"beans.factory.annotation"
* renamed AspectJ AnnotationBeanConfigurer to AnnotationBeanConfigurerAspect
* deprecated BeanFactoryBootstrap in favor of using a BeanFactoryLocator or a cu
stom bootstrap class
* refined AbstractApplicationContext to never register more than one JVM shutdow
n hook
* deprecated ConsoleListener, since it doesn't serve any purpose
* JdkVersion explicitly detects JDK 1.6 and 1.7 as well (does not mis-detect 1.6
as 1.3 anymore)
* refined Jdk13ControlFlow to be compatible with GNU ClassPath (whose stacktrace
has a whitespace after the method name)
* added NestedIOException, deriving from java.io.IOException and adding NestedCh
eckedException-style root cause handling
* refined AbstractResource to work around "FilterInputStream.close()" NPE, simpl
y catching Throwable and ignoring it
* PathMatchingResourcePatternResolver considers URL protocol "wsjar" as jar file
(to load from WebSphere-managed jars)
* ResourceArrayPropertyEditor can translate a set/list of patterns into a Resour
ce array (rather than just one pattern)
* split previous AnnotationUtils delegatetetetete into core.annotation.Annotatio
nUtils and beans.annotation.AnnotationBeanUtils
* DataSourceTransactionManager only attempts to release Connection if not pre-bo
und (to avoid inappropriate log message)
* TransactionAwareDataSourceProxy works correctly in combination with JdbcTempla
te and transaction suspend/resume now
* fixed SingleColumnRowMapper to explicitly check "ResultSet.wasNull()" after "g
etInt"/"getLong"/"getFloat" etc
* turned visibility of "org.springframework.jdbc.core.StatementCreatorUtils" to
package-protected
* removed ResultReader interface (sub-interface of RowCallbackHandler): use RowM
apper instead
* reworked RowMapperResultReader adapter into RowMapperResultSetExtractor
* reworked ResultSetSupportingSqlParameter to expose a RowMapper directly throug
h a "getRowMapper()" method
* reworked SqlQuery and subclasses to work with a RowMapper instead of a ResultR
eader -> "newRowMapper" template method
* fixed BatchSqlUpdate's constructor that takes a "batchSize" argument to correc
tly interpret it as batch size
* added "trackRowsAffected" property to BatchSqlUpdate, allowing to turn off the
row counts list to save memory
* refined JdbcBeanDefinitionReader to offer constructors with BeanDefinitionRegi
stry and PropertiesBeanDefinitionReader
* fixed MBeanExporter to work correctly with an "excludedBeans" list that it not
sorted by bean name ascending
* fixed "persistPeriod" default to be -1 even in ManagedResource attribute (not
just in ManagedResource annotation)
* made "servletContextName" and "portletContextName" configurable in MockServlet
Context respectively MockPortletContext
* added "set/removeParameter" methods to MockHttpServletRequest, allowing to rep
lace/remove existing parameters
* added alternative MockPortalContext constructor that accepts custom PortletMod
e and WindowState lists
* reworked MockActionResponse and MockPortletURL to check against list of suppor
ted PortletModes/WindowStates
* SqlMapClientTemplate always works with SqlMapSession and provided Connection t
o enable proper batching in all cases
* added "configLocations" property to LocalSessionFactoryBean for Hibernate3, al
lowing to load multiple config files
* LocalSessionFactoryBean supports cache regions specified through "entity/colle
ctionCacheStrategies" (on Hibernate 3.1)
* LocalSessionFactoryBean supports multiple event listeners per type through "ev
entListeners" (on Hibernate 3.1)
* added optional SpringSessionContext for Hibernate 3.1, to plug Spring into "ge
tCurrentSession()" without proxying
* added "replicate" convenience methods to HibernateTemplate for both Hibernate2
and Hibernate3
* added BlobStringType with configurable character encoding for both Hibernate2
and Hibernate3
* updated Spring's JDO 2.0 support to JDO API 2.0 beta (as provided by Apache, c
orresponding to JPOX 1.1.0-beta-6)
* added full support for Java Persistence API 1.0 (JPA) Public Final Draft, in p
ackage "org.springframework.orm.jpa"
* updated "views.properties" files in all sample applications to use "(class)" a
nd "(parent)"
* renamed PetClinic's "Entity" base class to "BaseEntity", to avoid name collisi
on with the JPA Entity annotation
* marked JPetStore's OrderForm, AccountForm and UserSession as Serializable
* removed special Quartz 1.3 check from SchedulerFactoryBean: requires Quartz 1.
4 or higher now
* added support for Quartz 1.5's merged JobDataMap to QuartzJobBean, falling bac
k to plain JobDataMap on Quartz 1.4
* introduced scripting package based on ScriptFactory and ScriptSource abstracti
ons
* added support for BeanShell, Groovy and JRuby scripted objects
* fixed AbstractDependencyInjectionSpringContextTests's "populateProtectedVariab
les" to avoid incorrect warnings
* added "startNewTransaction()" method to AbstractTransactionalSpringContextTest
s
* refined AbstractPlatformTransactionManager to suspend synchronizations before
the actual transaction (not after)
* fixed AbstractPlatformTransactionManager to serialize all relevant state
* fixed TransactionInterceptor to correctly serialize TransactionAspectSupport s
tate
* marked AnnotationTransactionAttributeSource as Serializable
* added ModelMap, providing "addObject" methods that auto-generate model attribu
te names according to conventions
* added "defaultEncoding" bean property to FreeMarkerConfigurationFactory(Bean),
inherited by FreeMarkerConfigurer
* added overloaded methods to JasperReportsUtils to allow exporter parameter to
be specified for specific formats
* ClassUtils's "forName(String)" method uses "getDefaultClassLoader()" instead o
f thread context ClassLoader only
* fixed "StringUtils.delimitedListToStringArray" to properly handle an empty Str
ing as delimiter
* refined StopWatch to not add new lines for "shortSummary()" but rather only fo
r "prettyPrint()"
* fixed ConcurrencyThrottleSupport to serialize all relevant state
* DataBinder registers suppressed fields in BindException, which offers a "getSu
ppressedFields()" accessor now
* "contextConfigLocation" params in "web.xml" support "${...}" style placeholder
s for system properties
* deprecated BindUtils and BindInitializer in package "web.bind" in favor of dir
ect ServletRequestDataBinder usage
* deprecated RequestUtils in package "web.bind" in favor of ServletRequestUtils
* renamed RequestUtils in package "web.portlet.bind" to PortletRequestUtils
* reworked MultipartException to derive from NestedIOException instead of Nested
ServletException, for Portlet reuse
* upgraded CommonsMultipartResolver to Commons FileUpload 1.1 (not using depreca
ted FileUpload 1.0 API anymore)
* added PortletMultipartResolver abstraction, with CommonsPortletMultipartResolv
er implementation as default
* added multipart support to PortletRequestDataBinder, with factored-out common
functionality in WebDataBinder
* reworked RequestContextHolder to hold a RequestAttributes facade instead of a
full HttpServletRequest
* added RequestContextHolder support to DispatcherPortlet, to enable Request/Ses
sionScopeMap with portlets
* refactored RequestHandledEvent into RequestHandledEvent base class and Servlet
RequestHandledEvent subclass
* renamed FrameworkPortlet's RequestHandledEvent to PortletRequestHandledEvent,
a subclass of RequestHandledEvent
* PortletBean ignores init-params that do not match bean properties, analogous t
o HttpServletBean
* DispatcherServlet does not log handler exceptions at warn level anymore but ra
ther only at debug level
* fixed DispatcherPortlet to properly support an exposed View object in a given
ModelAndView
* reworked Servlet ModelAndView and Portlet ModelAndView to fully support ModelM
ap's conventional attribute names
* added HttpSessionMutexListener and "WebUtils.getSessionMutex", used by Abstrac
tController's "synchronizeOnSession"
* added "PortletUtils.getSessionMutex", used by the Portlet AbstractController's
"synchronizeOnSession"
* added "FacesContextUtils.getSessionMutex", to make HttpSessionMutexListener's
session mutex available to JSF code
* turned AbstractController's "passAllParametersToRenderPhase"/"clearAllRenderPa
rameters" into PortletUtils methods
* added "propertyEditorRegistrars" property to BaseCommandController, for applyi
ng PropertyEditorRegistrars
* added "propertyEditorRegistrars" property to Portlet BaseCommandController, fo
r applying PropertyEditorRegistrars
* added "bindingErrorProcessor" property to Portlet BaseCommandController, for c
onfigurable BindingErrorProcessor
* turned AbstractCommandController's and AbstractFormController's "handleRequest
Internal" methods non-final
* refactored AbstractFormController's session form check into one single place,
throwing SessionRequiredException
* reworked MultiActionController's "bind" and "createBinder" to work on HttpServ
letRequest instead of ServletRequest
* deprecated MultiActionController's "initBinder(ServletRequest...)" in favor of
"initBinder(HttpServletRequest...)"
* refined ParameterMethodNameResolver to treat an empty method name as no name a
t all, letting the default kick in
* added protected accessors for UrlBasedViewResolver's bean properties, allowing
subclasses to access the settings
* added "argumentSeparator" property to MessageTag, allowing to specify a custom
separator instead of the default comma
* added "useSingleModelNameAsRoot" property to AbstractXlstView, allowing to enf
orce the value of the "root" property
* added RequestToViewNameTranslator strategy to allow DispatcherServlet to auto-
generate view names where necessary
* added DefaultRequestToViewNameTranslator to provide intuitive defaults for aut
omatic view name generation
* refined Struts DelegatingActionProxy and Delegating(Tiles)RequestProcessor to
fall back to root WebApplicationContext
* added DelegatingNavigationHandlerProxy and DelegatingPhaseListenerMulticaster
to JSF support (used by Spring Web Flow)

--------------------------------------
Overall
* removed all deprecated classes and methods
* removed support for iBATIS SQL Maps 1.3 (if you haven't done so already, upgra
de to iBATIS SQL Maps 2.0/2.1!)
* added explicit support for Hibernate 3.1 while remaining compatible with Hiber
nate 3.0 (as far as possible)
* factored out "spring-jdo", "spring-hibernate2/3", "spring-toplink", "spring-oj
b" jars (not in "spring.jar" anymore!)
* distributed first AspectJ aspects (for transaction management and DI of object
s not instantiated by Spring container)
* added support for AspectJ pointcut expressions, specified in AspectJ pointcut
language
* added support for AspectJ aspect implementations, both for classic AspectJ sty
le and the AspectJ 5 annotation style
* added @Configurable annotation plus BeanConfigurer aspect to allow injection o
n any arbitrary object through AspectJ
* added AopNamespaceHandler to support dedicated "aop:*" XML tags
* added intelligent error messages to BeanWrapperImpl when properties are not fo
und
* fixed BeanWrapperImpl to pass its "extractOldValueForEditor" setting on to nes
ted BeanWrappers
* refined BeanWrapperImpl to perform the accessible checking for read/write meth
ods before every invocation
* changed "MutablePropertyValues.addPropertyValue(String, Object)" to return 'th
is'
* removed deprecated "getBeanDefinitionNames(type)" method from ListableBeanFact
ory and BeanFactoryUtils
* added "createBean" and "initializeBean" methods to AutowireCapableBeanFactory
interface
* fixed AbstractBeanFactory to allow child bean definitions to refer to a parent
via its alias name
* DefaultListableBeanFactory is able to call non-public factory methods as well
* PropertiesBeanDefinitionReader trims String values for special keys such as "(
class)", "(parent)", etc
* added "default-init-method" and "default-destroy-method" attributes to the XML
bean definition format
* added support for XSD-driven XML bean definitions, with pluggable namespace ha
ndlers
* added UtilNamespaceHandler to support dedicated "util:*" XML tags
* introduced TaskExecutor abstraction, as strategy interface for the execution o
f Runnables
* added SyncTaskExecutor and SimpleAsyncTaskExecutor as simple default implement
ations of the TaskExecutor interface
* added "getAutowireCapableBeanFactory()" accessor to ApplicationContext interfa
ce, for direct access without casting
* refined AbstractApplicationContext's lifecycle behavior to properly ignore rep
eated "close()" calls
* moved DefaultListableBeanFactory's cleanup on "preInstantiateSingletons()" beh
avior to AbstractApplicationContext
* reworked SimpleApplicationEventMulticaster to delegate to a TaskExecutor, usin
g a SyncTaskExecutor as default
* introduced EmptyResultDataAccessException as specific subclass of IncorrectRes
ultSizeDataAccessException
* added further error codes for Oracle and MySQL to default "sql-error-codes.xml
" file
* OracleLobHandler lazily initializes Oracle driver classes, always loading via
the actual Connection's class loader
* fixed DataSourceUtils to correctly re-suspend a Connection even if the Connect
ion hasn't been used since resume
* fixed JdbcTemplate to extract the JDBC Connection for CallableStatementCreator
s if a NativeJdbcExtractor has been set
* factored out protected "getColumnMapRowMapper" and "getSingleColumnRowMapper"
hooks within JdbcTemplate
* SingleColumnRowMapper throws specific IncorrectResultSetColumnCountException i
n case of invalid column count
* SingleColumnRowMapper explicitly calls "ResultSet.getBigDecimal()" if the requ
ired type is BigDecimal
* added SimpleJdbcTemplate with ParameterizableRowMapper for Java 5, leveraging
varargs and generics
* SimpleMessageConverter accepts a passed-in raw JMS Message and returns a raw J
MS Message if content type is unknown
* added DefaultMessageListenerContainer mechanism for async message reception vi
a the plain JMS MessageConsumer API
* added SimpleMessageListenerContainer mechanism for async message reception via
the plain JMS MessageListener API
* added ServerSessionMessageListenerContainer mechanism for async message recept
ion via the JMS ServerSessionPool API
* introduced MBeanExportOperations interface, providing a programmatic facility
for registering MBeans on MBeanExporter
* introduced MBeanExportException as unified exception hierarchy for MBeanExport
er and MBeanExportOperations
* MBeanExporter no longer ignores autodetected MBeans with invalid object names:
specify appropriate "excludedBeans"
* added support for registering NotificationListeners with the MBeanServer
* added @ManagedNotification(s) annotation (and corresponding Commons attributes
) for describing notification MBeanInfo
* extended static MBeanInfoAssemblers to support configuration of Notification m
etadata
* added NotificationPublisher(Aware) to support publication of JMX Notifications
from Spring-managed beans
* added MBeanExporter option to have Spring extend ObjectNames to ensure they ar
e unique per-instance
* added MBeanExporter option to have Spring expose the ClassLoader of the manage
d resource before MBean invocations
* added JndiNamespaceHandler to support dedicated "jndi:*" XML tags
* JdoTransactionManager does explicit "isActive()" check before attempting a rol
lback, to avoid illegal state exception
* HibernateTransactionManager autodetects Hibernate 3.1 to support its native tr
ansaction timeout
* removed "save" operations with explicit id argument from HibernateTemplate (fo
llowing Hibernate 3.1's removal)
* upgraded FilterDefinitionFactoryBean to Hibernate 3.1 (which changed its Filte
rDefinition in an incompatible fashion)
* upgraded IdTransferringMergeEventListener to Hibernate 3.1 (which changed its
listener API in an incompatible fashion)
* Hibernate LocalSessionFactoryBean exposes its DataSource on "SessionFactory.cl
ose()", for potential schema export
* RmiServiceExporter performs explicit RMI unexport if binding to the registry f
ailed, to avoid dangling exports
* JaxRpcPortClientInterceptor/ProxyFactoryBean apply given JaxRpcServicePostProc
essors to existing JAX-RPC Service too
* HttpInvokerServiceExporter, HessianServiceExporter and BurlapServiceExporter i
mplement Handler instead of Controller
* HttpInvokerRequestExecutor is allowed to throw any Exception, not just IOExcep
tion and ClassNotFoundException
* TimerFactoryBean creates a non-daemon Timer by default, to let running tasks f
inish after Timer was cancelled
* added TimerTaskExecutor adapter for accessing a "java.util.Timer" through the
TaskExecutor interface
* added "taskExecutor" property to Quartz SchedulerFactoryBean, for replacing Qu
artz's default thread pool
* added SimpleThreadPoolTaskExecutor for Quartz, allowing to define Quartz's def
ault thread pool as Spring TaskExecutor
* added scheduling-style support for the JDK 1.5 ThreadPoolExecutor mechanism in
the "java.util.concurrent" package
* added ConcurrentTaskExecutor adapter for accessing a JDK 1.5 Executor through
the TaskExecutor interface
* added scheduling-style support for the CommonJ TimerManager API, as supported
by WebLogic 9 and WebSphere 6
* added WorkManagerTaskExecutor adapter for accessing a CommonJ WorkManager thro
ugh the TaskExecutor interface
* upgraded JPetStore (standard and annotation version) to use the new XML schema
namespaces "aop", "tx" and "jndi"
* added AbstractModelAndViewTests, a convenience super class for testing ModelAn
dView objects
* JtaTransactionManager only invokes rollback if transaction is still active (so
me JTA providers eagerly terminate)
* added TransactionNamespaceHandler to support dedicated "tx:*" XML tags
* added "isNull()" methods to Assert class
* added "setPathSeparator" method to AntPathMatcher, allowing to override the de
fault path separator "/"
* fixed AntPathMatcher to correctly treat "*" right after separator, i.e. to acc
ept path "/test/" for pattern "/test/*"
* WeakReferenceMonitor uses a daemon thread, to avoid a hanging thread even if w
eak references have not been released
* changed ConcurrencyThrottleSupport's default "concurrencyLimit" to -1 (keeping
ConcurrencyThrottleInterceptor at 1)
* use NestedServletException wherever a root cause gets wrapped by a ServletExce
ption (for nicer root cause handling)
* WebApplicationContext interface does not extend ThemeSource anymore; implement
ing ThemeSource is now optional
* introduced ServletConfigAware interface, for getting access to a Framework/Dis
patcherServlet's ServletConfig object
* SimpleServletPostProcessor configures Servlets with DispatcherServlet's Servle
tConfig by default (can be turned off)
* introduced Handler interface as alternative to Controller, with no ModelAndVie
w and only throwing Servlet/IOException
* AbstractCachingViewResolver guarantees at-most-once instantiation of each View
instance (-> extended synchronization)
* added "currentFormObject" template method to AbstractFormController, for post-
processing of a session form object
* "RequestContextUtils.getLocale(request)" falls back to the accept-header Local
e if no LocaleResolver found
* FixedLocaleResolver returns the JVM's default Locale if no explicit default Lo
cale specified
* VelocityView converts Velocity's MethodInvocationException to a Spring NestedS
ervletException with original root cause

Changelog

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Changelog

Hochgeladen von

Copyright:

Verfügbare Formate

SPRING FRAMEWORK CHANGELOG

Changes in version 2.5.6.SEC01 (2009-04-22)

Changes in version 2.5.6 (2008-10-31)

Changes in version 2.5.4 (2008-04-28)

Changes in version 2.5.3 (2008-04-06)

Changes in version 2.5.2 (2008-02-29)

Changes in version 2.5.1 (2008-01-09)

Changes in version 2.5 final (2007-11-19)

Changes in version 2.5 RC2 (2007-11-12)

Changes in version 2.5 RC1 (2007-10-22)

Changes in version 2.1 M4 (2007-09-09)

Changes in version 2.1 M3 (2007-07-31)

Changes in version 2.1 M2 (2007-05-31)

Changes in version 2.1 M1 (2007-05-13)

Changes in version 2.0.5 (2007-05-07)

Changes in version 2.0.4 (2007-04-10)

Changes in version 2.0.3 (2007-03-09)

Changes in version 2.0.2 (2007-01-08)

Changes in version 2.0.1 (23.11.2006)

Changes in version 2.0 final (3.10.2006)

Changes in version 2.0 RC3 (10.8.2006)

Changes in version 2.0 RC2 (6.7.2006)

Changes in version 2.0 RC1 (20.6.2006)

Changes in version 2.0 M5 (1.6.2006)

Changes in version 2.0 M4 (23.4.2006)

Changes in version 2.0 M3 (8.3.2006)

Changes in version 2.0 M2 (1.2.2006)

Changes in version 2.0 M1 (22.12.2005)

Das könnte Ihnen auch gefallen