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)
Package org.springframework.aop
* 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
Package org.springframework.core
* 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
Changes in version 2.5.5 (2008-06-23)
-------------------------------------
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)
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* 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)
Package org.springframework.core
* 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)
Package org.springframework.ejb
* "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"
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* 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
Package org.springframework.jmx
* 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
Package org.springframework.mail
* removed overlapping "application/x-pointplus" MIME type for "css" extension fr
om MimeMessageHelper's default mappings
Package org.springframework.orm
* 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)
Package org.springframework.remoting
* 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)
Package org.springframework.scheduling
* 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
Package org.springframework.test
* 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
Package org.springframework.transaction
* 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
Package org.springframework.util
* 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
Package org.springframework.web
* 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

Changes in version 2.5.4 (2008-04-28)

-------------------------------------
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
Package org.springframework.aop
* fixed various AspectJ expression evaluation bugs through upgrading aspectjweav
er.jar to AspectJ 1.6
Package org.springframework.beans
* 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
Package org.springframework.core
* 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)
Package org.springframework.jdbc
* 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)
Package org.springframework.jms
* fixed CachedMessageProducer to initialize its deliveryMode, priority and timeT
oLive fields with the target's settings
Package org.springframework.orm
* 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
Package org.springframework.remoting
* JndiRmiClientInterceptor/ProxyFactoryBean work for JNDI objects which do not i
mplement the Remote interface as well
Package org.springframework.test
* "executeSqlScript" (as in SimpleJdbcTestUtils) allows for multi-line statement
s, each separated by a semicolon
Package org.springframework.transaction
* TransactionSynchronizationManager automatically unwraps InfrastructureProxy ob
jects for raw key comparisons
* AbstractFallbackTransactionAttributeSource uses concurrent Map for attribute c
ache in order to avoid lock contention
Package org.springframework.validation
* AbstractPropertyBindingResult's "formatFieldValue" finds PropertyEditor accord
ing to "Editor" suffix convention too
* DefaultBindingErrorProcessor registers "missing field" errors within specified
nested path (if any)
Package org.springframework.web
* 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)

Changes in version 2.5.3 (2008-04-06)

-------------------------------------
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
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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)
Package org.springframework.context
* 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
Package org.springframework.core
* 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
Package org.springframework.ejb
* 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)
Package org.springframework.jdbc
* 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)
Package org.springframework.jms
* 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
Package org.springframework.jmx
* MBeanExporter's autodetection does not cause CannotLoadBeanClassException for
lazy-init beans (Spring 2.0 compatible)
Package org.springframework.jndi
* 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)
Package org.springframework.mock
* 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
Package org.springframework.orm
* 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)
Package org.springframework.remoting
* revised (Simple)Hessian/BurlapServiceExporter's handling of non-POST requests
(avoiding unnecessary warnings)
Package org.springframework.scheduling
* 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)
Package org.springframework.scripting
* ResourceScriptSource is able to detect updates for a script file stored in a j
ar/zip as well
Package org.springframework.test
* @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
Package org.springframework.transaction
* JtaTransactionManager" checks JNDI location "java:appserver/TransactionManager
" for GlassFish's primary TM handle
Package org.springframework.util
* "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
Package org.springframework.validation
* 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
Package org.springframework.web
* 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

Changes in version 2.5.2 (2008-02-29)

-------------------------------------
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)
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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"
Package org.springframework.context
* 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"
Package org.springframework.core
* 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
Package org.springframework.ejb
* 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)
Package org.springframework.instrument
* 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)
Package org.springframework.jdbc
* 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)
Package org.springframework.jms
* 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
Package org.springframework.jmx
* 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)
Package org.springframework.mail
* added "text/csv" to ConfigurableMimeFileTypeMap's and thus MimeMessageHelper's
default MIME mappings
Package org.springframework.mock
* added "getServletContext()" method to MockHttpServletRequest (not available in
the HttpServletRequest interface)
Package org.springframework.orm
* 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
Package org.springframework.remoting
* 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
Package org.springframework.scripting
* 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
Package org.springframework.test
* 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)
Package org.springframework.util
* 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
Package org.springframework.validation
* DataBinder's "initDirectFieldAccess()" sets the "extractOldValueForEditor" fla
g by default, analogous to bean access
Package org.springframework.web
* 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

Changes in version 2.5.1 (2008-01-09)

-------------------------------------
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
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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)
Package org.springframework.cache
* added "cacheManagerName" property to EhCacheManagerFactoryBean
Package org.springframework.context
* 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)
Package org.springframework.core
* 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
Package org.springframework.ejb
* "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
Package org.springframework.instrument
* 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)
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* 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
Package org.springframework.jmx
* added "getServer()" method to MBeanRegistrationSupport (MBeanExporter), exposi
ng the underlying JMX MBeanServer
Package org.springframework.jndi
* JndiTemplate prepares a specific Hashtable for the InitialContext, exposing de
fault environment properties as well
Package org.springframework.mail
* fixed potential NPE in MailSendException
Package org.springframework.mock
* MockRequestDispatcher stores forwarded/included URL in MockHttpServletResponse
even in case of wrapped response
Package org.springframework.orm
* 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
Package org.springframework.remoting
* 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
Package org.springframework.scheduling
* ThreadPoolTaskExecutor supports Java 6's "allowCoreThreadTimeOut" feature (for
both native and backport-concurrent)
Package org.springframework.scripting
* 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)
Package org.springframework.test
* 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)
Package org.springframework.transaction
* 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
Package org.springframework.util
* 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
Package org.springframework.validation
* 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
Package org.springframework.web
* 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)
Package org.springframework.aop
* fixed garbage collection problem with CGLIB proxies, using a strong reference
map for the fixed interceptors
Package org.springframework.context
* "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
Package org.springframework.core
* 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)
Package org.springframework.jdbc
* added "registerDatabase" method to SQLErrorCodesFactory, for eager association
of database names with DataSources
Package org.springframework.jms
* DefaultMessageListenerContainer avoids deadlock between Connection and Session
through the use of a shared monitor
Package org.springframework.jndi
* fixed "jee:jndi-lookup" tag to correctly handle "default-value" and "default-r
ef" attributes
Package org.springframework.orm
* Hibernate SpringSessionSynchronization explicitly disconnects on suspend/compl
etion (to make "on_close" work on JBoss)
Package org.springframework.scheduling
* fixed CommonJ TimerManagerFactoryBean to not require the "scheduledTimerListen
ers" property
Package org.springframework.test
* TestContextManager logs TestExecutionListener exceptions at error/warn level i
nstead of info/debug
Package org.springframework.transaction
* JtaTransactionManager swallows IllegalStateException when synchronizing with e
xisting transaction (for JBoss 4.2)
Package org.springframework.web
* 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
Package org.springframework.aop
* fixed garbage collection problem with CGLIB proxies, now holding onto the Advi
sed configuration independent of factory
Package org.springframework.beans
* 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)
Package org.springframework.context
* "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
Package org.springframework.dao
* PersistenceExceptionTranslationAdvisor detects @Repository on interfaces as we
ll
Package org.springframework.jca
* added missing "refresh()" call to SpringContextResourceAdapter's ApplicationCo
ntext
Package org.springframework.jdbc
* 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
Package org.springframework.jndi
* "jee:jndi-lookup" supports "default-value" and "default-ref" attributes, trans
lated to a default object
Package org.springframework.mail
* 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
Package org.springframework.orm
* 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
Package org.springframework.remoting
* 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)
Package org.springframework.test
* 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
Package org.springframework.transaction
* "tx:jta-transaction-manager" autodetects Oracle OC4J as well, in addition to W
ebLogic and WebSphere
Package org.springframework.web
* 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
Package org.springframework.aop
* 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"
Package org.springframework.beans
* 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
Package org.springframework.context
* 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
Package org.springframework.core
* 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
Package org.springframework.ejb
* spring-jee.xsd explicitly declares defaults for its boolean flags
Package org.springframework.instrument
* added WebLogicLoadTimeWeaver for BEA WebLogic version 10 or higher
Package org.springframework.jdbc
* SimpleJdbcTemplate's varargs handling always considers a single array argument
as collection of arguments
Package org.springframework.jms
* 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
Package org.springframework.jmx
* 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)
Package org.springframework.mail
* added "getJavaMailProperties()" method to JavaMailSenderImpl, allowing for con
venient configuration of specific keys
Package org.springframework.mock
* 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
Package org.springframework.orm
* 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)
Package org.springframework.remoting
* 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
Package org.springframework.test
* introduced TestNG support based on the new test context framework
Package org.springframework.transaction
* 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
Package org.springframework.ui
* "ModelMap.addObject(Object)" follows JavaBeans property naming rules in case o
f multiple upper case letters
Package org.springframework.util
* "ClassUtils.getShortNameAsProperty" strips the outer class name in case of an
inner class
Package org.springframework.web
* 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")
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* 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
Package org.springframework.core
* 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
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* 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
Package org.springframework.orm
* 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)
Package org.springframework.remoting
* LocalJaxRpcServiceFactory trims whitespace from "namespaceUri" values
Package org.springframework.scripting
* 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
Package org.springframework.test
* 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
Package org.springframework.transaction
* fixed "tx:annotation-driven" to not activate "aop:config"-style autodetection
of application-defined Advisor beans
Package org.springframework.ui
* ModelMap extends LinkedHashMap, exposing model elements in registration order
Package org.springframework.util
* "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
Package org.springframework.web
* 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

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

--------------------------------------
General
* fixed and updated reference documentation on JMS listener container configurat
ion and transaction participation
Package org.springframework.aop
* 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"
Package org.springframework.beans
* 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
Package org.springframework.context
* 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
* revised reflective class loading to use the correct ClassLoader according to t
he OSGi bundle structure (if any)
Package org.springframework.cache
* added "maxElementsOnDisk" bean property to EhCacheFactoryBean, supporting EHCa
che 1.2.4's extended Cache constructor
Package org.springframework.core
* 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
Package org.springframework.ejb
* turned visibility of AbstractEnterpriseBean and AbstractSessionBean to public
(showing up in the javadoc now)
Package org.springframework.instrument
* added "excludePackage" and "excludeClass" methods to ShadowingClassLoader, ana
logous to OverridingClassLoader
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* 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
Package org.springframework.jmx
* 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)
* revised reflective class loading to use the correct ClassLoader according to t
he OSGi bundle structure (if any)
Package org.springframework.orm
* 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
Package org.springframework.mock
* MockHttpServletResponse automatically flushes the Writer in case of a "write(i
nt)" call too
Package org.springframework.remoting
* 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)
Package org.springframework.scheduling
* added "waitForTasksToCompleteOnShutdown" property to ScheduledExecutorFactoryB
ean
* changed ScheduledExecutorFactoryBean's default behavior to shutdown immediatel
y, not waiting for scheduled tasks
Package org.springframework.scripting
* updated JRuby support for JRuby 1.0 compatibility (still compatible with JRuby
0.9.8 / 0.9.9 as well)
Package org.springframework.test
* AbstractDependencyInjectionSpringContextTests allows for annotation-driven aut
owiring (even in case of AUTOWIRE_NO)
Package org.springframework.scheduling
* Quartz SchedulerFactoryBean does not set default AdaptableJobFactory in case o
f RemoteScheduler (not supported there)
Package org.springframework.scripting
* "lang:*" configuration elements create their implicit ScriptFactoryPostProcess
or under a fully qualified bean name
Package org.springframework.transaction
* 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
Package org.springframework.util
* fixed "StringUtils.parseLocaleString" to parse multiple variants correctly
* DefaultPropertiesPersister detects and uses JDK 1.6's "Properties.load/store"
variants with Reader/Writer argument
Package org.springframework.validation
* added overloaded "rejectIfEmpty(OrWhitespace)" methods with args but without d
efault message to ValidationUtils
Package org.springframework.web
* 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

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

--------------------------------------
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
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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")
Package org.springframework.cache
* EhCacheFactoryBean applies a specified CacheEntryFactory to an existing cache
region as well
Package org.springframework.context
* 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
Package org.springframework.core
* 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
Package org.springframework.jdbc
* 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)
Package org.springframework.jmx
* MBeanExporter does not insist of a minimum of 1 bean exposed anymore, also acc
epting no beans to export in the context
Package org.springframework.mail
* JavaMailSenderImpl sets the original message id (if specified in the given Mim
eMessage) after "message.saveChanges()"
Package org.springframework.mock
* added MockJspWriter and MockBodyContent classes for testing content-emitting J
SP tags
* MockPageContext supports the "getOut()" method, exposing a MockJspWriter
Package org.springframework.orm
* 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
Package org.springframework.transaction
* 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
Package org.springframework.util
* 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
Package org.springframework.web
* 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

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

--------------------------------------
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
Package org.springframework.aop
* removed Perl5RegexpMethodPoint and RegexpMethodPointcutAdvisor's "perl5" flag
(always using java.util.regex now)
Package org.springframework.beans
* 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
Package org.springframework.context
* 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
Package org.springframework.core
* introduced the "core.typefilter" package, for ASM-based scanning of class file
s
Package org.springframework.jca
* 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
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* 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
Package org.springframework.jmx
* default MBean checks in JmxUtils and MBeanExporter automatically detect a Java
6 MXBean as well
Package org.springframework.jndi
* added SimpleJndiBeanFactory to "jndi.support" package, providing a JNDI-based
BeanFactory implementation
Package org.springframework.mail
* removed CosMailSenderImpl (as part of generally removing COS support from the
Spring codebase)
Package org.springframework.mock
* added support for Servlet 2.5's "getContextPath()" method to MockServletContex
t
Package org.springframework.orm
* 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
Package org.springframework.transaction
* 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
)
Package org.springframework.web
* 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

Changes in version 2.0.5 (2007-05-07)

-------------------------------------
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* 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
Package org.springframework.core
* 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
Package org.springframework.instrument
* ShadowingClassLoader explicitly defines a package for all classes that it load
s, for "Class.getPackage()" to work
Package org.springframework.jdbc
* 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)
Package org.springframework.jms
* 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
Package org.springframework.jndi
* TypeMismatchNamingException carries required type and actual type as explicit
attributes
Package org.springframework.orm
* 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
Package org.springframework.remoting
* 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
Package org.springframework.scheduling
* 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
Package org.springframework.scripting
* 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
Package org.springframework.test
* AbstractTransactionalSpringContextTests' "onSetUp()"/"onTearDown()" are non-fi
nal, allowing for flexible overriding
Package org.springframework.transaction
* 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
Package org.springframework.ui
* ResourceBundleThemeSource will always return the same Theme instance for a giv
en theme name
Package org.springframework.util
* 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
Package org.springframework.web
* 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)

Changes in version 2.0.4 (2007-04-10)

-------------------------------------
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* added "addApplicationListener" method to ConfigurableApplicationContext interf
ace, for statically registered listeners
Package org.springframework.core
* 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
Package org.springframework.dao
* PersistenceExceptionTranslationInterceptor supports PersistenceExceptionTransl
ator autodetection in standalone mode
Package org.springframework.jca
* 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
Package org.springframework.jdbc
* SqlOperation and its subclasses do not pre-parse for named parameters anymore,
accepting ":" in plain SQL strings
Package org.springframework.jms
* 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
Package org.springframework.jndi
* 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
Package org.springframework.mail
* added "setPriority" method to MimeMessageHelper, for populating the "X-Priorit
y" mail header
Package org.springframework.mock
* 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
Package org.springframework.orm
* 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
Package org.springframework.remoting
* RemoteInvocationUtils detects cycles in exception causes when updating the sta
ck trace (avoiding an infinite loop)
Package org.springframework.samples
* 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
Package org.springframework.scheduling
* added "targetBeanName" property to MethodInvokingJobDetailFactoryBean for Quar
tz, allowing for non-singleton targets
* ThreadPoolTaskExecutor/ScheduledExecutorFactoryBean includes the corresponding
bean name in startup/shutdown logging
Package org.springframework.scripting
* 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)
Package org.springframework.test
* added "getActualException()" method to AssertThrows, for introspecting the act
ual exception instance after throwing
Package org.springframework.transaction
* 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)
Package org.springframework.util
* 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)
Package org.springframework.web
* 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

Changes in version 2.0.3 (2007-03-09)

-------------------------------------
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
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* 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
Package org.springframework.core
* 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
Package org.springframework.dao
* PersistenceExceptionTranslationPostProcessor uses the bean ClassLoader for gen
erating translation proxies
Package org.springframework.ejb
* 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
Package org.springframework.instrument
* ShadowingClassLoader excludes "com.sun." package by default (for using Sun's X
erces version through JAXP)
Package org.springframework.jca
* 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
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* 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
Package org.springframework.jmx
* 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
Package org.springframework.jndi
* JndiObjectFactoryBean uses the bean ClassLoader for generating lazy-init proxi
es
* JndiObjectTargetSource (as used by JndiObjectFactoryBean's "proxyInterface" su
pport) throws JndiLookupException
Package org.springframework.mock
* 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)
Package org.springframework.orm
* 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
Package org.springframework.remoting
* 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
Package org.springframework.scheduling
* 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
Package org.springframework.scripting
* 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
Package org.springframework.test
* 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
Package org.springframework.transaction
* 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
Package org.springframework.util
* 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
Package org.springframework.web
* 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

Changes in version 2.0.2 (2007-01-08)

-------------------------------------
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
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* AbstractApplicationContext explicitly stops all Lifecycle Beans before destroy
ing them one-by-one (to avoid delays)
Package org.springframework.core
* 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)
Package org.springframework.dao
* added "singleResult" and "requiredSingleResult" methods to DataAccessUtils, di
stinct from "uniqueResult"'s contract
Package org.springframework.jdbc
* 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)
Package org.springframework.jms
* 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)
Package org.springframework.jmx
* reworked MBeanProxyFactoryBean's and ConnectorServerFactoryBean's "setObjectNa
me" to also accept ObjectName reference
Package org.springframework.orm
* 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
Package org.springframework.remoting
* 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
Package org.springframework.samples
* cleaned up platform/login configuration in PetClinic's TopLink variant
Package org.springframework.scheduling
* 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
Package org.springframework.scripting
* 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
Package org.springframework.test
* added public "getApplicationContext()" method to AbstractSingleSpringContextTe
sts
* added public "getJdbcTemplate()" method to AbstractTransactionalDataSourceSpri
ngContextTests
Package org.springframework.transaction
* AbstractPlatformTransactionManager logs full transaction definition when creat
ing a new transaction
* added "defaultTimeout" property to AbstractPlatformTransactionManager
Package org.springframework.ui
* VelocityEngineFactory/SpringResourceLoader supports Velocity-style comma-separ
ated paths as "resourceLoaderPath" value
Package org.springframework.util
* 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
Package org.springframework.validation
* added "prefix" property and "postProcessMessageCode" template method to Defaul
tMessageCodesResolver
Package org.springframework.web
* 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
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.cache
* 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
Package org.springframework.context
* 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
Package org.springframework.core
* 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
Package org.springframework.instrument
* added GlassFishLoadTimeWeaver for GlassFish / Sun Application Server
* refactored Java-5-only AbstractOverridingClassLoader into JDK-1.3-compatible O
verridingClassLoader in "core" package
Package org.springframework.jdbc
* 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)
Package org.springframework.jms
* 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
Package org.springframework.jmx
* 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
Package org.springframework.mock
* 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)
Package org.springframework.orm
* 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
Package org.springframework.scheduling
* 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
Package org.springframework.test
* AbstractTransactionalSpringContextTests invokes "onTearDownAfterTransaction" e
ven for a manually completed transaction
* fixed AbstractJpaTests to not keep context reference in cache if context refre
sh failed
Package org.springframework.transaction
* 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
Package org.springframework.ui
* deprecated FreeMarkerConfigurationFactory's "templateLoaders" property in favo
r of "pre/postTemplateLoaders"
Package org.springframework.util
* "ObjectUtils.toObjectArray(Object)" returns a given Object[] as-is instead of
throwing an IllegalArgumentException
* added "containsWhitespace" method to StringUtils
Package org.springframework.web
* 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)

----------------------------------------
Package org.springframework.aop
* dropped InvocationContextExposingAdvisorAutoProxyCreator base class
Package org.springframework.beans
* 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
Package org.springframework.cache
* EhCacheFactoryBean uses EHCache 1.2's extended Cache constructor to avoid EHCa
che warning (requires EHCache 1.2 now)
Package org.springframework.core
* AbstractLabeledEnum uses label as "toString()" representation, analogous to JD
K 1.5 enums
* StaticLabeledEnum and AbstractGenericLabeledEnum use the code as default label
Package org.springframework.jdbc
* 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)
Package org.springframework.jms
* 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
Package org.springframework.jmx
* 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)
Package org.springframework.mock
* AbstractSingleSpringContextTest's "loadContextLocations()" declares Exception,
to allow subclasses to throw exceptions
* added MockMultipartFile, MockMultipartHttpServletRequest and MockMultipartActi
onRequest for testing multipart access
Package org.springframework.orm
* 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)
Package org.springframework.transaction
* 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
Package org.springframework.util
* 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)"
Package org.springframework.validation
* DataBinder matches all field names using their canonical name (for required, a
llowed and disallowed checks)
Package org.springframework.web
* 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)
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.cache
* 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
Package org.springframework.context
* 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
Package org.springframework.core
* 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
Package org.springframework.ejb
* introduced EjbAccessException as replacement of AOP Alliance AspectException i
n local/remote SLSB invoker interceptors
Package org.springframework.instrument
* 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+
Package org.springframework.jca
* SingleConnectionFactory's Connection proxy implements "equals" and "hashCode"
based on proxy equality
* factored out "resetConnection", "prepareConnection" and "closeConnection" meth
ods in SingleConnectionFactory
Package org.springframework.jdbc
* 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
* factored out "resetConnection", "prepareConnection" and "closeConnection" meth
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
Package org.springframework.jms
* 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)
* factored out "resetConnection", "prepareConnection" and "closeConnection" meth
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
Package org.springframework.orm
* 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
Package org.springframework.mock
* added support for attributes which implement the Servlet 2.3 HttpSessionBindin
gListener interface to MockHttpSession
Package org.springframework.remoting
* 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
Package org.springframework.scheduling
* 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)
Package org.springframework.scripting
* 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
Package org.springframework.test
* 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
Package org.springframework.transaction
* added "afterCommit" callback to TransactionSynchronization interface
* fixed TransactionAttributeSourceAdvisor to avoid potential NPE in TransactionA
ttributeSourcePointcut's "hashCode"
Package org.springframework.validation
* 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
Package org.springframework.web
* 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

Changes in version 2.0 RC3 (10.8.2006)

--------------------------------------
General
* spring.jar does not include Portlet support anymore (add spring-portlet.jar to
your classpath if needed)
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* 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
Package org.springframework.core
* fixed PathMatchingResourcePatternResolver to prevent eternal recursion in case
of invalid prefix with pattern symbols
Package org.springframework.dao
* factored out reusable PersistenceExceptionTranslationInterceptor from Persiste
nceExceptionTranslationAdvisor
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* 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
Package org.springframework.orm
* 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
Package org.springframework.mock
* MockHttpServletRequest handles HTTP header names as case-insensitive
Package org.springframework.remoting
* added "registryClientSocketFactory" bean property to RmiClientInterceptor/RmiP
roxyFactoryBean
* added dedicated "prepare()" method to JndiRmiServiceExporter
Package org.springframework.scheduling
* renamed SchedulingTaskExecutor's "isShortLivedPreferred" method to "prefersSho
rtLivedTasks"
Package org.springframework.scripting
* ScriptFactoryPostProcessor supports all callbacks that containing BeanFactory
supports (e.g. ApplicationContextAware)
Package org.springframework.test
* AbstractTransactionalSpringContextTests only tries to end transaction on "tear
Down" if the transaction is still active
Package org.springframework.transaction
* 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
Package org.springframework.util
* optimized "ObjectUtils.nullSafeToString" implementation to return a given Stri
ng right away
Package org.springframework.validation
* added "ignoreInvalidFields" flag to DataBinder, allowing to ignore inaccessibl
e fields (null value in nested path)
Package org.springframework.web
* 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

Changes in version 2.0 RC2 (6.7.2006)

-------------------------------------
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)
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* AbstractApplicationContext uses the ClassLoader of its parent ApplicationConte
xt (if any) as default
* turned ApplicationObjectSupport's "getApplicationContext()" method from public
to protected (for consistency)
Package org.springframework.core
* 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
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* added support for durable subscriptions to message listener containers, driven
by "durableSubscriptionName" property
Package org.springframework.jmx
* MBeanRegistrationSupport only logs a warning (no error) when an MBean does not
exist anymore when trying to unregister
Package org.springframework.orm
* 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
Package org.springframework.remoting
* JaxRpcPortClientInterceptor/JaxRpcPortProxyFactoryBean allow for direct "custo
mPropertyMap[myKey]" access
Package org.springframework.scheduling
* Quartz SchedulerFactoryBean uses given "nonTransactionalDataSource" as default
DataSource if no "dataSource" specified
Package org.springframework.test
* AbstractTransactionalSpringContextTests properly ends a started transaction ea
rly if "onSetupInTransaction" fails
Package org.springframework.transaction
* JtaTransactionManager explicitly only calls "UserTransaction.setRollbackOnly()
" if the transaction is still active
Package org.springframework.validation
* 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
Package org.springframework.web
* 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)
* fixed various JSP form tag issues

Changes in version 2.0 RC1 (20.6.2006)

--------------------------------------
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!)
Package org.springframework.aop
* fixed AspectJAutoProxyCreator to avoid NPE in case of abstract beans without b
ean class specified
Package org.springframework.beans
* 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"
Package org.springframework.core
* StaticLabeledEnum offers its "readResolve" method with protected visibility, t
o kick in for subclasses as well
Package org.springframework.ejb
* fixed AbstractSlsbInvokerInterceptor to reobtain createMethod in case of cache
Home="false"/lookupHomeOnStartup="true"
Package org.springframework.jms
* 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
Package org.springframework.orm
* 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
Package org.springframework.samples
* added JPA support to PetClinic: EntityManagerClinic and JpaTemplateClinic, wit
h TopLink Essentials as default provider
Package org.springframework.scheduling
* added "jobListenerNames" bean property to MethodInvokingJobDetailFactoryBean
Package org.springframework.scripting
* fixed "spring-lang.xsd" to allow for multiple nested property elements
Package org.springframework.web
* 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
* fixed various JSP form tag issues

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
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* synchronized AbstractApplicationContext's "refresh()" method, for hot refreshi
ng in concurrent environments
Package org.springframework.core
* renamed GenericsHelper to GenericCollectionTypeResolver, more clearly reflecti
ng its actual role
* AnnotationUtils discovers annotations inherited via bridge methods now, throug
h the new BridgeMethodResolver
Package org.springframework.dao
* added generic PersistenceExceptionTranslator mechanism, supported by the JpaDi
alect abstraction for JPA providers
* added PersistenceExceptionTranslationPostProcessor, for automatic translation
to DataAccessExceptions
Package org.springframework.instrument
* 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
Package org.springframework.jdbc
* 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
Package org.springframework.orm
* 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
Package org.springframework.test
* added support classes for annotation-based tests in general and for JPA-based
tests in particular
Package org.springframework.transaction
* added "failEarlyOnGlobalRollbackOnly" flag to AbstractPlatformTransactionManag
er, for consistent fail-early behavior
Package org.springframework.util
* "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
Package org.springframework.validation
* 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
Package org.springframework.web
* 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

Changes in version 2.0 M4 (23.4.2006)

-------------------------------------
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
Package org.springframework.aop
* 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"
Package org.springframework.beans
* 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
Package org.springframework.context
* 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
Package org.springframework.core
* 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
Package org.springframework.dao
* introduced PermissionDeniedDataAccessException, thrown for valid operation tha
t was rejected due to lack of permission
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* 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)
Package org.springframework.jmx
* reworked NotificationListenerBean to avoid overloaded bean property setters fo
r "mappedObjectNames"
Package org.springframework.mail
* refined JavaMailSenderImpl to use "Session.getInstance(properties, null)", for
compatibility with (old) JavaMail 1.1
Package org.springframework.mock
* added overloaded constructors to MockFilterConfig, using a MockServletContext
instead of a ServletContext argument
Package org.springframework.orm
* 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
Package org.springframework.remoting
* 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
Package org.springframework.scheduling
* 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
Package org.springframework.scripting
* 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
Package org.springframework.transaction
* 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
Package org.springframework.util
* 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
Package org.springframework.validation
* 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
Package org.springframework.web
* 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)

Changes in version 2.0 M3 (8.3.2006)

------------------------------------
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* AbstractApplicationContext discovers its context MessageSource as "messageSour
ce" bean even through an alias
Package org.springframework.core
* 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
Package org.springframework.jdbc
* 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)
Package org.springframework.jms
* 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
Package org.springframework.jmx
* fixed MBeanServerConnectionFactoryBean to avoid potential initialization of un
used JMX Connector on shutdown
Package org.springframework.jndi
* added "defaultObject" property to JndiObjectFactoryBean, allowing to fall back
to default object if JNDI lookup fails
Package org.springframework.mock
* 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"
Package org.springframework.orm
* 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
Package org.springframework.scheduling
* 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
Package org.springframework.scripting
* fixed ScriptFactoryPostProcessor to let scripts receive bean references up the
entire container hierarchy
Package org.springframework.transaction
* added CompositeTransactionAttributeSource and "setTransactionAttributeSources(
[])" method for TransactionInterceptor
* JtaTransactionManager autodetects JNDI location "java:pm/TransactionManager" o
n Borland and Sun application servers
Package org.springframework.util
* fixed ResponseTimeMonitorImpl to properly synchronize access to its instance v
ariables in a multithreading environment
Package org.springframework.validation
* 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"
Package org.springframework.web
* 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

Changes in version 2.0 M2 (1.2.2006)

------------------------------------
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
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.context
* refined AbstractApplicationContext to never register more than one JVM shutdow
n hook
* deprecated ConsoleListener, since it doesn't serve any purpose
Package org.springframework.core
* 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
Package org.springframework.jdbc
* 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
Package org.springframework.jmx
* 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)
Package org.springframework.mock
* 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
Package org.springframework.orm
* 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"
Package org.springframework.samples
* 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
Package org.springframework.scheduling
* 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
Package org.springframework.scripting
* introduced scripting package based on ScriptFactory and ScriptSource abstracti
ons
* added support for BeanShell, Groovy and JRuby scripted objects
Package org.springframework.test
* fixed AbstractDependencyInjectionSpringContextTests's "populateProtectedVariab
les" to avoid incorrect warnings
* added "startNewTransaction()" method to AbstractTransactionalSpringContextTest
s
Package org.springframework.transaction
* 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
Package org.springframework.ui
* 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
Package org.springframework.util
* 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
Package org.springframework.validation
* DataBinder registers suppressed fields in BindException, which offers a "getSu
ppressedFields()" accessor now
Package org.springframework.web
* "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)

Changes in version 2.0 M1 (22.12.2005)

--------------------------------------
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)
Package org.springframework.aop
* 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
Package org.springframework.beans
* 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
Package org.springframework.core
* 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
Package org.springframework.context
* 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
Package org.springframework.dao
* introduced EmptyResultDataAccessException as specific subclass of IncorrectRes
ultSizeDataAccessException
Package org.springframework.jdbc
* 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
Package org.springframework.jms
* 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
Package org.springframework.jmx
* 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
Package org.springframework.jndi
* added JndiNamespaceHandler to support dedicated "jndi:*" XML tags
Package org.springframework.orm
* 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
Package org.springframework.remoting
* 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
Package org.springframework.scheduling
* 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
Package org.springframework.samples
* upgraded JPetStore (standard and annotation version) to use the new XML schema
namespaces "aop", "tx" and "jndi"
Package org.springframework.test
* added AbstractModelAndViewTests, a convenience super class for testing ModelAn
dView objects
Package org.springframework.transaction
* JtaTransactionManager only invokes rollback if transaction is still active (so
me JTA providers eagerly terminate)
* added TransactionNamespaceHandler to support dedicated "tx:*" XML tags
Package org.springframework.util
* 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)
Package org.springframework.web
* 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