SPRING FRAMEWORK CHANGELOG
==========================
http://www.springframework.org


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 declaration
* 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 aspectjweaver.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" suffix convention
* deprecated BeanWrapper's fallback to the global JavaBeans PropertyEditorManager
* DirectFieldAccessor registers Spring's common default PropertyEditors (like BeanWrapperImpl does)
* fixed AbstractBeanDefinition to properly include qualifiers and primary flag in equals comparison
* AbstractAutowireCapableBeanFactory's handling of lazy-init singletons is thread-safe again
* AbstractAutowireCapableBeanFactory only invokes "predictBeanType" post-processor method for non-null bean Class

Package org.springframework.core
* introduced InfrastructureProxy interface for resource proxies to be implemented if supposed to be considered as equal
* DefaultResourceLoader's ClassPathContextResource also returns ClassPathContextResource 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 annotation classes (for OSGi compatibility)

Package org.springframework.jdbc
* JdbcTemplate explicitly detects and skips null ResultSets returned from CallableStatement
* 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 timeToLive 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 default in case of no JTA TransactionManager

Package org.springframework.remoting
* JndiRmiClientInterceptor/ProxyFactoryBean work for JNDI objects which do not implement the Remote interface as well

Package org.springframework.test
* "executeSqlScript" (as in SimpleJdbcTestUtils) allows for multi-line statements, each separated by a semicolon

Package org.springframework.transaction
* TransactionSynchronizationManager automatically unwraps InfrastructureProxy objects for raw key comparisons
* AbstractFallbackTransactionAttributeSource uses concurrent Map for attribute cache in order to avoid lock contention

Package org.springframework.validation
* AbstractPropertyBindingResult's "formatFieldValue" finds PropertyEditor according 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 (XmlWebApplicationContext)
* added "contextAttribute" property (for WebApplicationContext retrieval) to DelegatingFilterProxy and FrameworkServlet
* RequestContext does not fail when WebApplicationContext's ServletContext is null (like in a plain Portlet environment)
* fixed JSP form tags to properly return SKIP_BODY instead of the non-defined EVAL_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 parent-last class loaders)
* spring-context.jar includes optional OSGi imports for "context:annotation-config"'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 "interceptorNames" in favor of "targetName"
* ProxyFactoryBean assumes a target bean if type cannot be determined for last element in "interceptorNames" list
* AbstractAutoProxyCreator predicts proxy class as bean type if known already (instead of predicting the target class)
* AbstractAutoProxyCreator exposes early singleton proxies (for resolving circular 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 unwanted octal support while preserving hex)
* GenericTypeAwarePropertyDescriptor respects "propertyEditorClass" specified on original PropertyDescriptor
* renamed ListableBeanFactory's "includePrototypes" flag to "includeNonSingletons" (affects javadoc only)
* added "getEarlyBeanReference" hook to SmartInstantiationAwareBeanPostProcessor interface
* AbstractBeanFactory does not log full exception stack trace (at debug level) on FactoryBean type check anymore
* AbstractAutowireCapableBeanFactory allows for resolving circular reference between beans wrapped by BeanPostProcessors
* DefaultListableBeanFactory passes full inherited AccessControlContext to the AccessController for bean creation
* DefaultListableBeanFactory does not eagerly initialize target beans when autowiring 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 nested value
* added "ignoreUnresolvableEditors" property to CustomEditorConfigurer, allowing to ignore type/editor classes not found
* XmlBeanDefinitionReader's "getValidationModeForResource" method is protected now in order to allow for overriding
* AbstractSimpleBeanDefinitionParser properly ignores namespace declaration attributes ("xmlns"/"xmlns:")
* AutowiredAnnotationBeanPostProcessor processes @Autowired annotation on most specific method only (when overriding)
* AutowiredAnnotationBeanPostProcessor marks @Autowired bean properties as processed (for @Required to accept them)

Package org.springframework.context
* ReloadableResourceBundleMessageSource is able to detect updates for a properties file stored in a jar/zip as well
* AbstractApplicationContext's temporary ClassLoader explicitly excludes types to match (for OSGi LTW compatibility)
* restored support for null location array argument in ClassPathXmlApplicationContext (for Apache CXF compatibility)
* added "registration" attribute to mbean-export element, accepting "failOnExisting"/"ignoreExisting"/"replaceExisting"
* CommonAnnotationBeanPostProcessor processes @Resource annotation on most specific method only (when overriding)
* revised default annotation post-processor ordering to apply most specific processors 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 case 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 to avoid class loader leaks
* added "lastModified()" method to Resource interface, for abstract access to the last-modified timestamp
* ClassPathResource and UrlResource use the last-modified timestamp of the archive file for jar/zip contents
* PathMatchingResourcePatternResolver sets "useCaches=false" on any JarURLConnection that it opens for path matching
* PathMatchingResourcePatternResolver detects WebSphere 6.1 "bundleresource:" URLs 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 element
* Spring 2.5 "jee:*" config elements use resource-ref="true" by default (non-resource-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-null (for WebLogic cluster compatibility)
* fixed SQLException translation for IBM DB2 and MS SQL to operate on error codes 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/Hsql/MySQLMaxValueIncrementer
* added DB2MainframeSequenceMaxValueIncrementer for DB2/390 and DB2/400 (differing from DB2 UDB for Unix and Windows)
* added "wrapAsLob" property to DefaultLobHandler, for passing Blob/Clob instances 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 results Map returned from "call" operation
* JdbcDaoSupport does not override specified JdbcTemplate on subsequent "setDataSource" call for same DataSource
* NamedParameterJdbcTemplate ignores Postgres-style "::" casting operator (i.e. not treated as named parameter)
* SimpleJdbcInsert supports "autoGeneratedKey" simulation using "insert ... returning" for PostgreSQL 8.2 and later
* SimpleJdbcCall supports metadata lookup of procedure columns for PostgreSQL (requires 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" calls in "reconnectOnException" mode
* introduced CachingConnectionFactory (as subclass of SingleConnectionFactory) for JMS 1.1 session and producer pooling
* SimpleMessageListenerContainer registers itself as ExceptionListener for automatic Connection recovery
* added "runningAllowed()" template method to DefaultMessageListenerContainer, allowing 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 listener, potentially triggering recovery
* MessageListenerAdapter propagates JMSExceptions thrown from listener method as-is (no wrapping in runtime exception)
* MessageListenerAdapter invokes target (SessionAware)MessageListener immediately, 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 ClassLoader (if necessary)

Package org.springframework.mock
* MockHttpServletResponse's "encodeURL" allows for central overriding in subclasses (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 "setZzzFactory" call for same factory
* added "executeWithNewSession" and "executeWithNativeSession" methods to HibernateTemplate
* revised EntityManagerFactoryInfo handling to autodetect all EntityManager interfaces 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 properties and uses itself as default factory
* ThreadPoolTaskExecutor uses its bean name as default thread name prefix (analogous to DefaultMessageListenerContainer)
* MethodInvokingRunnable logs target exception directly at error level (instead of InvocationTargetException wrapper)
* MethodInvokingJobDetailFactoryBean propagates invocation exceptions as non-JobExecutionExceptions (for error logging)
* DelegatingJob propagates exceptions as-is instead of wrapping them in JobExecutionExceptions (for error logging)

Package org.springframework.scripting
* ResourceScriptSource is able to detect updates for a script file stored in a jar/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 (non-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 for different test methods (with timeout)
* TransactionalTestExecutionListener reobtains transaction manager for every transaction (picking up context changes)
* fixed Abstract(Transactional)JUnit(38/4)SpringContextTests classes to be actually 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 rethrown IllegalArgumentException
* NumberUtils treats number with leading zeros as decimal (removed unwanted octal support while preserving hex)
* MethodInvoker scans all declared methods (of any visibility), being able to invoke protected/private methods as well
* added "getChildElementsByTagNames" method with tag names Collection argument to DomUtils

Package org.springframework.validation
* factored out AbstractErrors base class from AbstractBindingResult, providing common 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 request (for Portlet compatibility)
* RequestContextFilter supports "threadContextInheritable" init-param (analogous to DispatcherServlet)
* HttpRequestHandlerServlet translates HttpRequestMethodNotSupportedException into 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 controllers too ("/welcome/*" + "/welcome")
* added ControllerBeanNameHandlerMapping, deriving URL paths from bean names for well-known controller types
* AnnotationMethodHandlerAdapter's @RequestMapping matching is deterministic independent from the declared methor order
* AnnotationMethodHandlerAdapter accepts @RequestParam annotations for @InitBinder methods as well
* AnnotationMethodHandlerAdapter always exposes BindingResult objects for model attributes which are binding candidates
* AnnotationMethodHandlerAdapter throws clear IllegalStateException in case of invalid 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 consistently derived from the declared type
* added "exposedContextBeanNames" property to InternalResourceView(Resolver), for exposing specific Spring beans only
* InternalResourceView does not enforce ApplicationContext to be set anymore (allowing for "getServletContext" checking)
* JstlView, Tiles(Jstl)View and AbstractJasperReportsView expose current RequestContext's MessageSource for localization
* JSP form tags do not autogenerate id in case of empty id specified (empty id signals no id to be rendered)
* JSP OptionTag and OptionsTag support "id" attribute now, analogous to RadioButton(s)Tag and Checkbox(es)Tag
* added standard HTML "target" attribute to JSP FormTag, for submitting to another 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 sub-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 against method's declaring class
* ProxyFactoryBean and AbstractAutoProxyCreator check autodetected proxy interfaces for visibility in the ClassLoader
* Cglib2AopProxy properly detects overridden "finalize()" methods, never dispatching them to the interceptor chain
* CustomizableTraceInterceptor properly escapes method names and exception messages for regex parsing (wrt "$" signs)
* marked AbstractRefreshableTargetSource's status accessors as synchronized
* AbstractBeanFactoryBasedTargetSourceCreator applies containing BeanFactory's configuration to internal BeanFactory
* AbstractBeanFactoryBasedTargetSourceCreator creates an independent internal BeanFactory per target bean
* deprecated ClassLoaderAnalyzerInterceptor and associated ClassLoaderUtils class
* reintroduced AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(ParserContext,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 available 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) registered for short[], int[], long[] too
* CustomDateEditor and CustomNumberEditor preserve original ParseException as root cause of IllegalArgumentException
* MethodInvokingFactoryBean falls back to interpreting specified arguments as single method argument of array type
* deprecated RefreshablePagedListHolder class and associated PagedListSourceProvider interface
* added "getOriginatingBeanDefinition()" method to BeanDefinition interface, exposing the decorated definition (if any)
* PropertyOverrideConfigurer is able to properly override target bean definitions behind a scoped proxy decorator
* added "nullValue" property to PropertyPlaceholderConfigurer, allowing for resolving specific Strings into a null value
* CustomEditorConfigurer and CustomScopeConfigurer accept editor/scope values as class names as well
* factored out AliasRegistry/SimpleAliasRegistry from BeanDefinitionRegistry/AbstractBeanFactory
* introduced SimpleBeanDefinitionRegistry implementation for bean definition reader testing
* "registerAlias" allows for overriding as long as bean definition overriding is allowed
* added convenient "autowireBean(Object existingBean)" method to AutowireCapableBeanFactory
* AbstractAutowireCapableBeanFactory removes singleton if created for type check in case of circular reference issues
* AbstractAutowireCapableBeanFactory applies specified TypeConverter to bean references as well (not just to literals)
* AbstractAutowireCapableBeanFactory resolves the target type for a generically typed dependency (method parameter)
* AbstractAutowireCapableBeanFactory's "applyBeanPropertyValues" fully initializes the BeanWrapper used for binding
* AbstractAutowireCapableBeanFactory's "applyBeanPropertyValues" and "configureBean" 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 InstantiationAwareBeanPostProcessors for null bean
* fixed AbstractAutowireCapableBeanFactory to always resolve the bean class before a FactoryBean type check
* added "freezeConfiguration()" method to Configurable/DefaultListableBeanFactory, 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 generically typed dependency (method parameter)
* fixed AutowiredAnnotationBeanPostProcessor to correctly cache a collection with a single autowired bean as element
* fixed AutowiredAnnotationBeanPostProcessor to not cache special dependencies such 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 consistently named "addConstructorArgValue"
* deprecated various rarely used BeanDefinitionBuilder methods in favor of settings on the raw BeanDefinition object
* added overloaded "genericBeanDefinition(beanClass)" method and "setParentName" method to BeanDefinitionBuilder
* added support for "(scope)" key to PropertiesBeanDefinitionReader: e.g. "myBean.(scope)=prototype"
* refactored AbstractBeanConfigurerAspect into Abstract(InterfaceDriven)DependencyInjectionAspect
* nested XML decoration elements (e.g. "aop:scoped-proxy") are explicitly rejected if no corresponding handler present
* InitDestroy/Autowired/Common/PersistenceAnnotationBeanPostProcessor perform appropriate debug logging
* factored out generic SpringBeanELResolver and SimpleSpringBeanELResolver from "web.jsf.SpringBeanFacesELResolver"

Package org.springframework.context
* added "getId()" method to ApplicationContext interface, with corresponding "setId" in AbstractApplicationContext class
* moved CONFIG_LOCATION_DELIMITERS constant from ConfigurableWebApplicationContext 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 at the end of the "refresh()" phase
* exposed "allowBeanDefinitionOverriding"/"allowCircularReferences" properties in AbstractRefreshableApplicationContext
* factored out AbstractRefreshableConfigApplicationContext base class for common handling of specified config locations
* ClassPathXmlApplicationContext and FileSystemXmlApplicationContext allow for bean-style configuration
* StaticApplicationContext builds GenericBeanDefinitions by default (instead of RootBeanDefinitions)
* added "initApplicationContext(ApplicationContext)" template method to ApplicationObjectSupport
* ClassPathBeanDefinitionScanner detects scoped-proxy bean definitions as compatible (in case of duplicate scanning)
* refactored ClassPathBeanDefinitionScanner into various template methods (for easier overriding)
* refactored ComponentScanBeanDefinitionParser into various template methods (for easier overriding)
* ComponentScanBeanDefinitionParser includes annotation config processors in nested composite component
* "context:component-scan" resolves "${...}" placeholders in package paths against 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 "context:property-placeholder"

Package org.springframework.core
* introduced Named(Inheritable)ThreadLocal, used throughout the framework for self-descriptive thread-bound context 
* added "getParameterName()" method to MethodParameter, activated through a ParameterNameDiscoverer
* factored out GenericTypeResolver from BridgeMethodResolver and GenericCollectionTypeResolver
* factored out DecoratingClassLoader base class from OverridingClassLoader and ShadowingClassLoader
* added "isReadable()" method to Resource interface, giving a readability hint upfront (supported by FileSystemResource)
* fixed ClassMetadataReadingVisitor (as used by "context:component-scan") to correctly ignore *usage* of inner classes

Package org.springframework.dao
* PersistenceExceptionTranslationPostProcessor extends ProxyConfig and applies its settings to newly created proxies

Package org.springframework.ejb
* Local/SimpleRemoteSlsbInvokerInterceptor use EJB(Local)Home for EJB 2.x detection, 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 InstrumentationLoadTimeWeaver, avoiding direct access to agent
* fixed ShadowingClassLoader to not attempt defining a package in case of a class in the default package

Package org.springframework.jca
* ResourceAdapterApplicationContext registers BootstrapContext as resolvable dependency type (for @Autowired)
* ResourceAdapterApplicationContext registers WorkManager as lazily resolvable dependency type (for @Autowired)
* added "workManagerName" property to WorkManagerTaskExecutor, for J2EE env lookups in JNDI (e.g. a Geronimo gbean-ref)
* introduced JBossWorkManagerTaskExecutor as adapter for the JBoss JCA WorkManager (analogous to CommonJ)
* introduced GlassFishWorkManagerTaskExecutor as adapter for the GlassFish JCA WorkManager (analogous to CommonJ)

Package org.springframework.jdbc
* DriverManagerDataSource's "driverClassName" throws IllegalStateException instead of CannotGetJdbcConnectionException
* added "defaultTransactionIsolationName" property to LazyConnectionDataSourceProxy
* SQLStateSQLExceptionTranslator translates "01*" data truncation codes into DataIntegrityViolationException
* SQLStateSQLExceptionTranslator translates "61*" deadlock codes into ConcurrencyFailureException
* SQLErrorCodesSQLExceptionTranslator falls back to SQL state translation for IBM DB2 and MS SQL by default
* added further default "sql-error-codes.xml" mappings for MS SQL, MySQL, PostgreSQL and Oracle
* DatabaseStartupValidator lets startup continue instead of 'busy' waiting in case 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 CLOB (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 ParameterizedBeanPropertyRowMapper
* revised BeanPropertyRowMapper to use JavaBean property introspection instead of expecting field/setter name matches
* factored out "initBeanWrapper"/"getColumnValue" template methods in BeanPropertyRowMapper, allowing for customization
* BeanPropertyRowMapper shares ResultSet value access logic with SingleColumnRowMapper
* BeanPropertyRowMapper and SingleColumnRowMapper perform Oracle-specific "getObject" checks for unknown specified types
* added ParameterizedSingleColumnRowMapper with a convenient "newInstance" method to specify the required type only once
* BeanPropertySqlParameterSource derives a default SQL type from the corresponding 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 of ERROR level
* DefaultMessageListenerContainer allows for specifying a callback on "stop", for a notification after actual stopping
* DefaultMessageListenerContainer lets shutdown continue instead of 'busy' waiting 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 resource for JmsTemplate calls (like DMLC)
* deprecated ServerSessionMessageListenerContainer in favor of DefaultMessageListenerContainer/JmsMessageEndpointManager
* DefaultJmsActivationSpecFactory is compatible with WebSphere MQ 6.0.2.1 as well now

Package org.springframework.jmx
* factored out "doUnregister(objectName)" and "onRegister(objectName,mbean)" methods in MBeanRegistrationSupport
* MBeanExporter actually sets "exposeManagedResourceClassLoader" to "true" by default (matching the 2.5 javadoc now)
* MBeanExporter explicitly removes all of its registered NotificationListeners from the target MBeanServer on shutdown
* introduced NotificationListenerRegistrar for registering a listener with any MBean 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 LocalSessionFactoryBean
* fixed Hibernate AnnotationSessionFactoryBean to allow for mixed mapping sources (despite 2.5.1's "buildMappings" call)
* HibernateTemplate exposes the "org.hibernate.event.EventSource" and "org.hibernate.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 Connection in read-write transaction scenarios
* JDO/JPA factories check autodetected proxy interfaces for visibility in the ClassLoader (for WebSphere compatibility)
* added "entityManagerFactoryInterface" property to AbstractEntityManagerFactoryBean, 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 EclipseLink 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 ClassLoader as thread context CL (if necessary)
* added overloaded "executeRequest" method with original MethodInvocation argument 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 object refresh even after a type check call
* GroovyScriptFactory and JRubyScriptFactory refresh scripted object instances even 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 inline 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 instantiated (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 AbstractTransactionalXxxSpringContextTests (for reading scripts)

Package org.springframework.util
* revised ConcurrencyThrottleSupport's interruption handling to throw an IllegalStateException 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" flag by default, analogous to bean access

Package org.springframework.web
* ServletRequestAttributes keeps hold onto the original session if a "request.getSession" call suddenly returns null
* added "setConfigLocation" method to ConfigurableWeb/PortletApplicationContext, accepting an init-param style value
* added "initServletContext(ServletContext)" template method to WebApplicationObjectSupport
* optimized ServletContextResource's and PortletContextResource's "exists()" check to avoid unnecessary stream opening
* Commons(Portlet)MultipartResolver catches and logs any exception thrown from file item cleanup (not propagating it)
* introduced NativeWebRequest and MultipartRequest interfaces for even finer-grained generic request access options
* introduced FacesRequestAttributes adapter, with attributes access falling back to current JSF FacesContext by default
* added "dispatchOptionsRequest/TraceRequest" properties to FrameworkServlet, for dispatching all HTTP request methods
* deprecated PathMap attribute and CommonsPathMapHandlerMapping class in favor annotation-based request mapping
* deprecated ThrowawayController and ThrowawayControllerHandlerAdapter in favor annotation-based controllers
* @RequestMapping's "method" attribute supported at type level as well, expressing restriction for entire handler
* @RequestMapping's "params" attribute supported at type level for Servlets, expressing precondition for entire handler
* @RequestMapping's "params" attribute supported at type level for Portlets, mapping 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)" property on AnnotationMethodHandlerAdapter
* factored out common HandlerMethodResolver/Invoker classes from Servlet/Portlet AnnotationMethodHandlerAdapter
* AnnotationMethodHandlerAdapter does not restrict supported HTTP methods by default (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 typed @RequestParam/@ModelAttribute argument
* AnnotationMethodHandlerAdapter properly allows for resolving a Principal argument to null (in case of none defined)
* AnnotationMethodHandlerAdapter resolves InputStream/OutputStream and Reader/Writer subclasses as well
* added "synchronizeOnSession" property to AnnotationMethodHandlerAdapter, analogous to AbstractController
* fixed AnnotationMethodHandlerAdapter to avoid NPE in case of plain model attribute returned from handler method
* Servlet AnnotationMethodHandlerAdapter sends HTTP 404 instead of throwing IllegalState if no handler method found
* Portlet AnnotationMethodHandlerAdapter throws UnavailableException instead of IllegalState if no handler method found
* added "prepareResponse"/"generatesDownloadContent" methods to AbstractView, for HTTPS cache header workaround for IE
* AbstractPdfView and Abstract(J)ExcelView participate in AbstractView's HTTPS cache 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 case of pattern matches for same handler
* InternalResourceView prevents dispatch to same handler path only if the "preventDispatchLoop" flag is set to "true"
* InternalResourceViewResolver sets "preventDispatchLoop" to "true" for conventional name-based View instances only
* JstlView exposes a JSTL-aware MessageSource even for a custom MessageSource passed in through the constructor
* re-added AbstractDataBoundFormElementTag's COMMAND_NAME_VARIABLE_NAME in deprecated 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 after input element (for HTML compliance)
* JSP CheckboxesTag and RadioButtonsTag compare raw item / raw Map key for selection 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, for logging the target invocation trace

Package org.springframework.beans
* ConfigurablePropertyAccessor extends the TypeConverter interface (moved up from BeanWrapper interface)
* BeanWrapper supports well-known collection implementation types for generic element conversion again (like Spring 2.0)
* TypeConverterDelegate protects its text conversion step against PropertyEditors which don't support "setValue" calls
* factored out FactoryBeanRegistrySupport base class from AbstractBeanFactory and AbstractAutowireCapableBeanFactory
* optimized AbstractBeanFactory's access to cached FactoryBean-exposed objects, avoiding unnecessary locks
* ConstructorResolver prefers concrete class matches over interface matches at the same level when checking arguments
* revised accidental public exposure of "isPrimary" method in ConfigurableListableBeanFactory/DefaultListableBeanFactory
* moved "resolveDependency" implementation from AbstractAutowireCapableBeanFactory down to DefaultListableBeanFactory
* revised DefaultListableBeanFactory's "resolveDependency" exceptions with respect to clarity and context inclusion
* DefaultListableBeanFactory does not eagerly initialize FactoryBeans for type checks even with factory-bean reference
* DefaultListableBeanFactory throws descriptive exception in case of factory-bean circular reference
* DefaultListableBeanFactory supports ObjectFactory indirection for resolvable dependencies
* DefaultListableBeanFactory always resolves bean class before checking a bean definition as autowire candidate
* AbstractBeanDefinition stores and exposes the originating Resource (rather than just the resource description)
* XmlBeanDefinitionReader detects recursive loading of the same resource (e.g. through import cycles)
* DefaultBeanDefinitionDocumentReader sends ImportDefinition events containing the actually resolved Resource objects
* DefaultDocumentLoader includes the JAXP IllegalArgumentException in the rethrown ParserConfigurationException
* ClassPathBeanDefinitionScanner marks default init/destroy methods as not enforced (accepting beans without those)
* SingletonBeanFactoryLocator falls back to a single bean of type BeanFactory (if any) when given a null locator key
* SingletonBeanFactoryLocator removes bean factory group definition if its initialization fails
* factored out protected "getTargetBean" method in ObjectFactoryCreatingFactoryBean (for easier overriding)
* revised BeanConfigurerSupport to allow for usage as a delegate as well, not just as a base class
* revised BeanConfigurerSupport to re-initialize its default BeanWiringInfoResolver 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 invocation 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 elements in config location array
* added "addMessages(Map, Locale)" method to StaticMessageSource, for bulk adding messages
* ContextTypeMatchClassLoader does not generally exclude classes in the "org.springframework" package anymore
* DefaultContextLoadTimeWeaver only chooses GlassFishLoadTimeWeaver when running in the EAR ClassLoader
* DefaultContextLoadTimeWeaver removes all registered transformers from the VM Instrumentation 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 "location" attribute (for system properties)

Package org.springframework.core
* introduced SmartClassLoader marker interface, declaring a "boolean isClassReloadable(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 compatibility with the IBM 1.4.2 VM's debug mode)
* LocalVariableTableParameterNameDiscoverer caches parameter names per method and obtained ASM ClassReaders per class
* added "getEnclosingClassName()", "hasEnclosingClass()" and "isIndependent()" methods 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 Spring's @Autowired in EJB3 SBs/MDBs

Package org.springframework.instrument
* InstrumentationLoadTimeWeaver allows for operating on a pre-defined ClassLoader and for removing transformers again
* TomcatInstrumentableClassLoader always passes local ClassLoader into ClassFileTransformers (makes AspectJ LTW work)
* ShadowingClassLoader excludes the "com.ibm." package by default as well (for IBM JDK classes, DB2 JDBC driver, etc)

Package org.springframework.jdbc
* fixed JdbcUtils to not access the DatabaseMetaData implementation class for "extractDatabaseMetaData" calls
* TransactionAwareDataSourceProxy obtains target Connections lazily when the first call comes in on the Connection proxy
* added "reobtainTransactionalConnections" flag to TransactionAwareDataSourceProxy (for Connection handles on JBoss)
* WebSphereDataSourceAdapter, JBossNativeJdbcExtractor and CommonsDbcpNativeJdbcExtractor propagate SQLExceptions as-is

Package org.springframework.jms
* JmsUtils protects against misbehaving JMS providers (such as ActiveMQ) when closing an interrupted MessageConsumer
* JmsTemplate's standard "execute(ProducerCallback)" pre-initializes producer with default destination (if available)
* added overloaded execute methods with Destination/destination name and ProducerCallback to JmsOperations/JmsTemplate
* added various "browse"/"browseSelected" methods JmsOperations/JmsTemplate, for browsing a queue with a BrowserCallback
* DelegatingConnectionFactory adapts specific create(Queue/Topic)Connection calls to a generic JMS 1.1 ConnectionFactory
* JmsInvokerClientInterceptor accepts any JMS 1.1 ConnectionFactory, not insisting on a QueueConnectionFactory anymore
* MethodListenerAdapter uses type difference weight algorithm to choose between ambiguous listener methods
* DefaultMessageListenerContainer catches TaskRejectedException and pauses affected tasks for subsequent resuming
* DefaultMessageListenerContainer exposes listener Session as thread-bound resource for JmsTemplate calls
* ServerSessionMessageListenerContainer always establishes a shared Connection (even if autoStart="false")
* CommonsPoolServerSessionFactory removes specific ServerSessionPool on close (for proper reuse on stop and restart)
* "jms:listener-container" tag supports a concurrency range (e.g. "3-5"), for specifying a minimum number of consumers

Package org.springframework.jmx
* added "getServer()" method to MBeanRegistrationSupport (MBeanExporter), exposing the underlying JMX MBeanServer

Package org.springframework.jndi
* JndiTemplate prepares a specific Hashtable for the InitialContext, exposing default 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" without "useTransactionAwareDataSource" too
* LocalSessionFactoryBean eagerly compiles registered mappings, for availability in the post-processing phase
* added "cacheProvider" property to LocalSessionFactoryBean, allowing for a Spring-managed CacheProvider instance
* added overloaded "delete" methods with "entityName" argument to HibernateOperations and HibernateTemplate
* added "earlyFlushBeforeCommit" flag to HibernateTransactionManager, allowing to enforce a flush before synchronization
* fixed Jpa/JdoTransactionManager to correctly nest a REQUIRES_NEW transaction within a SUPPORTS scope with early access
* JPA PersistenceUnitReader supports location patterns for the "jar-file" attribute in "persistence.xml" files
* PersistenceAnnotationBeanPostProcessor accepts vendor-specific EntityManager interfaces for @PersistenceContext again

Package org.springframework.remoting
* HessianClientInterceptor/ProxyFactoryBean supports "debug", "chunkedPost", "readTimeout" and "hessian2" properties
* HessianServiceExporter supports "debug" property analogous to Hessian 3.1.3's HessianServlet
* HessianServiceExporter and BurlapServiceExporter expose the bean ClassLoader as thread context CL (if necessary)
* factored out stream-based HessianExporter and BurlapExporter classes
* factored out abstract RemoteInvocationSerializingExporter base class from HttpInvokerServiceExporter
* introduced SimpleHttpInvokerServiceExporter and SimpleHessian/BurlapServiceExporter 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 @Transactional 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 Groovy to derive a valid class name from it
* GroovyScriptFactory caches a temporarily created result object from "getScriptedObjectType" until "getScriptedObject"
* GroovyScriptFactory exposes "getGroovyClassLoader()" method and lazily initializes 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 anymore (for ease of using custom groups)

Package org.springframework.transaction
* added "validateExistingTransaction" property to AbstractPlatformTransactionManager, for isolation level checks
* added "prepareForCommit" template method to AbstractPlatformTransactionManager, called before commit synchronization
* JtaTransactionManager consistently throws TransactionSystemException in case of unexpected internal transaction state
* JtaTransactionManager detects JBoss 4.2 transaction rollbacks caused by a timeout, throwing a meaningful exception
* fixed WebSphereUowTransactionManager to correctly detect an existing global transaction (ignoring local tx contexts)

Package org.springframework.ui
* fixed ModelMap's "mergeAttributes" to correctly copy new attributes into the model
* added "containsAttribute" method to ModelMap, as a more specific alternative to 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 underlying 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 ContextLoader, for context lookup by thread
* introduced SpringBeanAutowiringSupport class for self-autowiring classes within a web app (e.g. JAX-WS endpoints)
* WebApplicationContext impls register request/session/ServletContext as resolvable dependencies (e.g. for @Autowired)
* PortletApplicationContext impls register request/session/PortletContext as resolvable dependencies (for @Autowired)
* CommonsMultipartResolver uses FileUpload 1.2's "isMultipartContent" variant when available (for stricter checks)
* added "useCacheControlNoStore" property to WebContentGenerator, allowing to suppress the "no-store" header value
* SimpleUrlHandlerMapping explicitly trims specified handler bean names (in order 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 request 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 methods (for consistency with @RequestMapping)
* MultiActionController detects and rejects invalid last-modified method return types
* WebRequest interface (as supported for @RequestMapping) supports "checkNotModified" 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 @InitBinder value matched against param names
* @ModelAttribute's default attribute names are consistently derived from the *declared* parameter/return type
* AnnotationMethodHandlerAdapter properly handles overridden handler methods with overridden @RequestMapping annotation
* AnnotationMethodHandlerAdapter maps relative paths specified at method level analogous to default method name mappings
* AnnotationMethodHandlerAdapter throws an exception if it cannot find a clear best path match for a specific request
* AnnotationMethodHandlerAdapter throws descriptive exception in case of optional parameter being declared as primitive
* AnnotationMethodHandlerAdapter automatically resolves arguments of type Principal as the request's user principal
* AnnotationMethodHandlerAdapter propagates checked exceptions as-is for handler/attribute/init-binder methods
* AnnotationMethodHandlerAdapter applies @InitBinder methods for view preparation as well (like WebBindingInitializers)
* AnnotationMethodHandlerAdapter applies binder initialization for 'end' views (with processing being complete) as well
* factored out "createBinder" template method within AnnotationMethodHandlerAdapter, 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/Render*Response* (to work on Liferay)
* InternalResourceView prevents dispatching to same path as handler (e.g. with default 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 scoped 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 initialized (throwing a descriptive exception)
* Tiles2 TilesView exposes Servlet 2.4 forward request attributes (for non-2.4-compliant web containers like OC4J)
* fixed JSP BindTag to correctly detect and ignore a repeated nested path for the global errors case
* JSP CheckboxTag/CheckboxesTag and RadioButtonTag/RadioButtonsTag use registered 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 (annotation-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 decoding 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 top-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-ref" attributes

Package org.springframework.orm
* Hibernate SpringSessionSynchronization explicitly disconnects on suspend/completion (to make "on_close" work on JBoss)

Package org.springframework.scheduling
* fixed CommonJ TimerManagerFactoryBean to not require the "scheduledTimerListeners" property

Package org.springframework.test
* TestContextManager logs TestExecutionListener exceptions at error/warn level instead of info/debug

Package org.springframework.transaction
* JtaTransactionManager swallows IllegalStateException when synchronizing with existing transaction (for JBoss 4.2)

Package org.springframework.web
* CommonsMultipartResolver detects multiple files for the same field name and throws a corresponding exception
* RequestToViewNameTranslator kicks in before the "HandlerInterceptor.postHandle" phase
* RequestToViewNameTranslator's "getViewName" is allowed to return null if no default found
* fixed AnnotationMethodHandlerAdapter to expose the implicit model even when using request-to-view-name translation
* fixed AnnotationMethodHandlerAdapter to correctly match parameters even in case of request method specified as well
* DispatcherPortlet/AnnotationMethodHandlerAdapter swallows IllegalStateException when setting implicit render parameter
* Portlet AnnotationMethodHandlerAdapter preserves implicit model from action phase to render phase
* Portlet AnnotationMethodHandlerAdapter applies cache settings (prevents caching when session attributes are involved)
* Portlet AnnotationMethodHandlerAdapter allows default @RequestMapping annotations for action as well as render methods
* Portlet AnnotationMethodHandlerAdapter resolves PortletPreferences, PortletMode, WindowState, PortalContext arguments
* factored out AbstractWizardFormController's "getTargetPage" logic into WebUtils/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:options" tags
* JSP form tags always autogenerate valid HTML ids (not including "[" or "]" characters 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 Advised configuration independent of factory

Package org.springframework.beans
* DefaultListableBeanFactory now supports autowiring of FactoryBean instances 'by type'
* revised DefaultListableBeanFactory's exception handling for clearer wrapping of nested exceptions
* DefaultListableBeanFactory performs bean creation within a PrivilegedAction (for SecurityManager compatibility)
* optimized DefaultListableBeanFactory's invocation of setter methods for re-created 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-validation for the same bean
* added bean type argument to MergedBeanDefinitionPostProcessor (for InitDestroyAnnotationBeanPostProcessor)

Package org.springframework.context
* "context:mbean-export" autodetects WebLogic and WebSphere, performing an appropriate MBeanServer lookup
* "context:mbean-export" falls back to a simple MBeanExporter on JDK 1.4, detecting standard MBeans
* introduced "context:mbean-server" configuration element, for setting up a standalone MBeanServer reference
* "context:load-time-weaver" automatically activates "spring-configured" if AspectJ weaving is enabled
* "context:load-time-weaver"'s temporary ClassLoader for type matching uses a fully isolated loader for each match

Package org.springframework.dao
* PersistenceExceptionTranslationAdvisor detects @Repository on interfaces as well

Package org.springframework.jca
* added missing "refresh()" call to SpringContextResourceAdapter's ApplicationContext

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 "convertValueToRequiredType" implementation
* SimpleJdbcCallOperations and SimpleJdbcInsertOperations return the interface type (not the impl) for method chaining

Package org.springframework.jndi
* "jee:jndi-lookup" supports "default-value" and "default-ref" attributes, translated to a default object

Package org.springframework.mail
* MailSendExceptions keeps failed messages in a LinkedHashMap, allowing for access in the order of sending
* added "getMessageExceptions()" accessor to MailSendException, with "getFailedMessages()" being transient now

Package org.springframework.orm
* fixed Jpa/JdoTransactionManager to correctly suspend and resume even for dialects without JDBC Connection retrieval
* SqlMapClientTemplate explicitly checks for TransactionAwareDataSourceProxy, avoiding double synchronization

Package org.springframework.remoting
* RmiClientInterceptor and AbstractSlsbInvokerInterceptor do not consider MarshalException as connect failure anymore

Package org.springframework.stereotype
* @Component, @Repository, etc are not marked as inherited anymore (i.e. inheritance checks to be performed explicitly)

Package org.springframework.test
* AbstractGenericContextLoader provides an opportunity for subclasses to customize the context before calling refresh
* revised TestExecutionListener method signatures to declare Exception instead of Throwable

Package org.springframework.transaction
* "tx:jta-transaction-manager" autodetects Oracle OC4J as well, in addition to WebLogic 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 multiple path patterns of equal length)
* AnnotationMethodHandlerAdapter for Servlet MVC exposes UrlPathHelper and PathMatcher configuration properties
* AnnotationMethodHandlerAdapter for Servlet MVC supports MethodNameResolver for resolving default handler methods
* AnnotationMethodHandlerAdapter for Servlet MVC supports path patterns for @RequestMapping 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 handler methods to take params into account
* @RequestParam's "value" attribute is not required anymore, defaulting to the method parameter name (if available)
* added "types" attribute to @SessionAttributes, allowing to enumerate model attributes types instead of names
* AbstractJasperReportsSingleFormatView converts exporter parameter values in the model (if appropriate)
* InternalResourceView lets explicit model attributes override Spring beans in case of "exposeContextBeansAsAttributes"
* JstlView does not set "exposeContextBeansAsAttributes" flag to "true" by default (analogous to InternalResourceView)
* JSF 1.1 DelegatingVariableResolver checks original VariableResolver first again (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, indicating its concrete lookup strategy
* fixed Tiles 1.x TilesConfigurer to explicitly set the factory name to empty String by default


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

General
* introduced spring-framework-with-docs.zip distribution; reduced spring-framework.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 (avoiding side effects with other ASM versions)
* spring-orm.jar contains the web ORM support (again), in order to avoid split packages 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 (annotation-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 (using a concurrent map with special keys)
* fixed AspectJ pointcut handling to strictly match generic return types according to Java language rules
* AspectJ pointcut matching only registers LocalVariableTableParameterNameDiscoverer 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 case of non-serializable property values
* URIEditor only tries to resolve "classpath:" locations if explicitly constructed 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 casts to AbstractBeanDefinition)
* deprecated ConfigurableBeanFactory's "registerCustomEditor" in favor of "addPropertyEditorRegistrar"
* AbstractBeanFactory ignores PropertyEditorRegistrars which tried to obtain a currently created bean
* revised AbstractBeanFactory to detect FactoryBeans which are in turn created through factory methods
* DefaultListableBeanFactory freshly resolves autowired arguments even for cached constructors (re-resolving prototypes)
* DefaultListableBeanFactory removes a singleton bean instance if a new bean definition gets registered
* DefaultListableBeanFactory fully destroys singleton bean instance when the corresponding 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 inner prototypes with MethodReplacer usage
* XmlBeanDefinitionReader initializes default EntityResolver lazily, avoiding classpath scan in case of custom resolver
* DefaultNamespaceHandlerResolver exposes public DEFAULT_HANDLER_MAPPINGS_LOCATION constant
* DefaultNamespaceHandlerResolver loads NamespaceHandler mappings and classes lazily (only when namespace actually used)
* fixed BeanDefinitionParserDelegate to correctly parse property sub-elements even 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 (formerly "name" and "value")
* AbstractBeanDefinition's qualifier handling provides a unified "addQualifier(AutowireCandidateQualifier)" method
* AbstractSingleBeanDefinitionParser applies full scope to inner beans, making them eligible for destruction callbacks
* added "getParentName" template method to AbstractSingleBeanDefinitionParser, allowing for child bean definitions
* @Autowired qualifier annotations may be defined with target 'type' as well, marking the target bean class
* Autowired/Common/PersistenceAnnotationBeanPostProcessor implement PriorityOrdered 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 determine valid scope names

Package org.springframework.context
* AbstractApplicationContext calls "cancelRefresh" method in case of refresh failure now, resetting the 'active' flag
* AbstractRefreshableApplicationContext calls the full "destroyBeans()" method when refreshing the bean factory
* ClassPathXmlApplicationContext and FileSystemXmlApplicationContext trim passed-in config location Strings
* added "concurrentUpdates" flag to AbstractApplicationEventMulticaster, enabling copy-on-write for the listener set
* AnnotationConfigUtils checks for EntityManagerFactory class instead of PersistenceContext (for Tomcat 6 compatibility)
* moved CommonAnnotationBeanPostProcessor class from package "beans.factory.annotation" to "context.annotation"
* CommonAnnotationBeanPostProcessor supports @Resource's "mappedName" attribute as (potentially global) JNDI location
* added "alwaysUseJndiLookup" flag to CommonAnnotationBeanPostProcessor, enforcing Java EE 5 JNDI lookups
* CommonAnnotationBeanPostProcessor detects and processes the JAX-WS @WebServiceRef annotation as well
* CommonAnnotationBeanPostProcessor detects and processes the EJB 3 @EJB reference annotation (if present) as well
* @PostConstruct/@PreDestroy methods are only called once even if they are specified as standard init/destroy methods
* added "context:mbean-export" configuration element to "spring-context-2.5" schema, for annotation-driven JMX export

Package org.springframework.core
* NestedRuntimeException/NestedCheckedException's "contains" checks the nested causes of any kind of wrapped exception
* added "ConcurrentMap createConcurrentMap" method to CollectionFactory, exposing a common ConcurrentMap interface
* deprecated CollectionFactory's "createLinkedSet/LinkedMap/IdentityMapIfPossible" (for usage on JDK 1.4 or higher)
* AttributeAccessorSupport uses a LinkedHashMap, keeping the attributes in the order 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 (exposed for context-relative lookups)
* reworked "core.asm.ClassReaderFactory" into "core.classreading.MetadataReaderFactory" (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 necessary (-> "startConnection" flag)
* JmsTransactionManager does not start transactional Connections until a transactional Session actually requires it
* added DestinationResolver support to StandardJmsActivationSpecFactory, for Destination objects on JCA ActivationSpecs
* DefaultJmsActivationSpecFactory autodetects WebSphere's JMS ResourceAdapter and extended ActivationSpec properties
* "spring-jms.xsd" supports "destination-resolver" attribute for "jca-listener-container" 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 registered 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 explicitly
* MBeanExporter supports dynamic AOP proxies with the target class being a standard MBean/MXBean
* introduced AnnotationMBeanExporter with conveniently pre-configured AnnotationJmxAttributeSource
* ManagedResource annotation allows for specifying the "objectName" as annotation value as well
* MetadataNamingStrategy falls back to bean key (bean name) if no "objectName" specified in source-level metadata
* fixed IdentityNamingStrategy to obtain the package name through class name inspection rather than "Class.getPackage()"
* MBeanClientInterceptor automatically converts MXBean CompositeData/TabularData structures according to Java 5/6 rules
* MBeanClientInterceptor uses the standard JDK MBeanServerInvocationHandler if possible (for full MXBean support)
* MBeanClientInterceptor propagates exceptions thrown by the target MBean directly (i.e. not wrapped in a JmxException)

Package org.springframework.mail
* added "getJavaMailProperties()" method to JavaMailSenderImpl, allowing for convenient configuration of specific keys

Package org.springframework.mock
* MockServletContext supports "getContext" (allowing to register contexts through the new "registerContext" method)
* MockServletContext supports "getMimeType" if the Java Activation Framework is present on the classpath
* added convenience constructors to MockPortletConfig, MockActionRequest and MockRenderRequest

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-transactional access even with async tx timeouts
* removed custom detach/attach/newNamedQuery hooks from JdoDialect, expecting providers to follow the final JDO 2.0 API
* deprecated JdoTemplate's "attachCopy" methods in favor of revised "makePersistent" with a JDO2-style return value
* LocalPersistenceManagerFactoryBean passes the application ClassLoader into "JDOHelper.getPersistenceManagerFactory"
* added "persistenceManagerFactoryName" property to LocalPersistenceManagerFactoryBean, supporting JDO 2.1 PMF lookup
* added "jdoPropertyMap" property to LocalPersistenceManagerFactoryBean, allowing for non-String JDO property values
* JdoTransactionManager and JpaTransactionManager support REQUIRES_NEW transactions in afterCompletion callbacks
* JPA support exposes the application ClassLoader as PersistenceUnitInfo ClassLoader even without a LoadTimeWeaver
* JPA support uses InstrumentationLoadTimeWeaver as default weaver if InstrumentationSavingAgent is active
* revised CommonsLoggingSessionLog to work with TopLink 11 as well (remaining compatible 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 anymore (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.jaxws"
* introduced RemoteInvocationFailureException, thrown by RMI/HTTP/JMS invoker proxies in case of server-side failure
* introduced SoapFaultException, thrown by JAX-RPC/JAX-WS proxies in case of a SOAP fault being reported

Package org.springframework.stereotype
* added @Service and @Controller stereotypes to the existing Component and Repository 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 any, in case of commit/rollback failure
* revised AbstractFallbackTransactionAttributeSource's template methods for specific attribute/annotation retrieval
* AnnotationTransactionAttributeSource supports a customizable TransactionAnnotationParser strategy
* AnnotationTransactionAttributeSource supports EJB3's TransactionAttribute annotation (if present) as well
* TransactionAspectSupport ignores transaction attributes when not configured with a transaction manager
* added "tx:jta-transaction-manager" configuration element to "spring-tx-2.5" schema

Package org.springframework.ui
* "ModelMap.addObject(Object)" follows JavaBeans property naming rules in case of 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 switch to lazy multipart resolution
* reworked MultipartException into a RuntimeException (it may be thrown from file/parameter access methods as well now)
* changed UrlPathHelper's and AbstractUrlHandlerMapping's/AbstractUrlMethodNameResolver'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, @RequestMapping, @RequestParam and @ModelAttribute
* introduced annotation-based command/form controller facilities using @InitBinder, @FormAttributes and FormStatus
* introduced DefaultAnnotationHandlerMapping and AnnotationMethodHandlerAdapter for Servlet MVC and Portlet MVC
* added "caseSensitive", "pathPrefix" and "basePackage" properties to ControllerClassNameHandlerMapping
* added "getActualValue()" method to BindStatus, exposing the raw property value for comparison purposes
* added "exposeModelAttributes" property to RedirectView, allowing to suppress model exposure completely
* added "exposeContextBeansAsAttributes" property to InternalResourceView and InternalResourceViewResolver
* 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 "commandName" 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 collection elements
* introduced JSP CheckboxesTag (form:checkboxes) and RadioButtonsTag (form:radiobuttons)
* JSF 1.1 DelegatingVariableResolver checks Spring bean match first (analogous to 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 JUnit 3.8 for the main test suite
* moved GlassFish and OC4J instrumentation support from spring-context-support.jar to spring-context.jar
* renamed spring-mock.jar to spring-test.jar, reflecting the focus on the test context framework
* factored out Struts 1.x support (including Tiles 1.x support) into spring-webmvc-struts.jar
* Spring-style pattern matching ("*xxx", "xxx*", "*xxx*") supports multi-part patterns as well now ("xxx*yyy")

Package org.springframework.aop
* ProxyFactoryBean and AbstractSingletonProxyFactoryBean are serializable if their target and interceptors are
* made parts of ReflectiveMethodInvocation and other internal impl classes public again (for framework integration)
* "AopNamespaceUtils.registerAutoProxyCreatorIfNecessary" registers a plain InfrastructureAdvisorAutoProxyCreator 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 PropertyEditors which don't support "setValue" calls
* TypeConverterDelegate falls back to "toString()" conversion for a primitive value type if the required type is String
* changed visibility of PropertyEditorRegistrySupport's "getDefaultEditor(requiredType)" method to public
* PropertyEditorRegistrySupport's "copyCustomEditorsTo" copies all editors if 'nestedProperty' argument is null
* exposed "String[] getDependentBeans(beanName)" method on ConfigurableBeanFactory interface
* introduced "String[] getDependenciesForBean(beanName)" method on ConfigurableBeanFactory interface
* DefaultSingletonBeanRegistry uses a concurrent Map for managing dependent beans, 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 ConfigurableListableBeanFactory interface
* introduced qualifier support, allowing to use custom parameter annotations for identifying specific target beans
* introduced AutowireCandidateResolver mechanism and QualifierAnnotationAutowireCandidateResolver implementation
* reworked Annotated/ScannedRootBeanDefinition into Annotated/ScannedGenericBeanDefinition
* 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 definitions
* optimized DefaultListableBeanFactory's resolution of bean references during prototype 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 annotations on static fields/methods
* factored out "isCandidateComponent(beanDefinition)" template method in ClassPathScanningCandidateComponentProvider
* ClassPathBeanDefinitionScanner does not apply scoped-proxy setting to prototypes (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, accepting Spring-style bean name patterns

Package org.springframework.context
* AbstractApplicationContext registers BeanFactory, ApplicationContext etc as resolvable dependency types for @Autowired
* fixed AbstractApplicationContext's temporary ClassLoader to work for by-type autowiring in ApplicationListeners etc
* AbstractApplicationContext propagates "start()"/"stop()" call to LifecycleBeans 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 OverridingClassLoader
* PathMatchingResourcePatternResolver's static "logger" variable is private now
* PathMatchingResourcePatternResolver detects Oracle OC4J's "code-source" URLs as jar files now

Package org.springframework.jdbc
* strengthened SQLExceptionTranslator's contract to define root cause handling for returned DataAccessExceptions
* added batch update support to SimpleJdbcTemplate
* added new SimpleJdbcInsert and SimpleJdbcCall classes to provide ease-of-use for inserts and stored procedure calls

Package org.springframework.jms
* MessageListenerAdapter logs at warn level if a listener method returned a result 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-container" XML configuration element
* added "response-destination" attribute to "jms:listener" element, defining a default in case of no JMSReplyTo header

Package org.springframework.orm
* HibernateJdbcException extracts the SQL statement and explicitly builds it into the exception message
* introduced EntityManagerProxy interface, allowing access to underlying EntityManager 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 TransactionSystemExceptions
* JpaTransactionManager provides fine-grained commit exceptions through translating JPA RollbackException root causes
* HibernateJpaDialect translates native HibernateExceptions (introspecting them as root causes of PersistenceExceptions)
* added savepoint support to JpaDialect, implemented by OpenJpaDialect, supported by JpaTransactionManager
* OpenJpaDialect exposes a special JDBC ConnectionHandle that immediately returns the Connection to the EntityManager
* OpenJpaVendorAdapter supports OpenJPA 1.0.0 (exposing the full OpenJPAEntityManagerSPI 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.parseClass (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 the context key String translation
* reduced AbstractTransactionalSpringContextTests's log level for transaction management from INFO to DEBUG
* introduced annotation-oriented test context framework based on test execution listeners
* introduced JUnit4 support (SpringJUnit4ClassRunner) based on the new test context 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 classes as well (for JMX compatibility)
* ReflectionUtils provides a "findMethod" variant without parameter types argument

Package org.springframework.web
* RequestContext uses a full ResourceBundleThemeSource as default again (for backwards compatibility)
* RequestContext lazily obtains the Theme instance (for more efficiency when theme support is not used)
* AbstractView does not log static attributes anymore, in order to allow for scoped proxies to be used as attributes
* factored out protected "isEligibleProperty(key, value)" template method in RedirectView
* 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 InternalResourceView) 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 defaultHtmlEscape 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 compatible with JasperReports 1.3


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

General
* fixed and updated reference documentation on JMS listener container configuration and transaction participation

Package org.springframework.aop
* Cglib2AopProxy uses weak references for advised object, interceptors and validated classes (avoiding a memory leak)
* ProxyFactoryBean avoids NPE in case of target class being null (due to misconfiguration)
* 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 impl 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 class proxying (not overriding the setting)
* ConfigBeanDefinitionParser turns "pointcut" attribute into inner bean definition (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 the 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 StringArrayPropertyEditor
* URIEditor trims whitespace before parsing the URI (allowing for XML formatting with whitespace)
* BeanWrapperImpl lazily performs JavaBeans introspection (avoiding introspection failure for non-visible target class)
* TypeConverterDelegate protects its collection conversion process against misbehaving Collections with a null Iterator
* TypeConverterDelegate only attempts to convert well-known collection types (skips 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", preserving "getBeansOfType" order
* added "isEagerInit()" method to SmartFactoryBean interface, making post-processors apply to an exposed object eagerly
* exposed "getBean(name, args)" method on BeanFactory interface
* exposed "BeanDefinition getMergedBeanDefinition(beanName)" method on ConfigurableBeanFactory interface
* exposed "isFactoryBean" and "registerDependentBean" methods on ConfigurableBeanFactory interface
* introduced "isAutowireCandidate" method on ConfigurableListableBeanFactory interface
* 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 overloaded factory methods and constructors
* PropertyPathFactoryBean supports a null property value (removed historic restriction there)
* exposed "parentName", "factoryBeanName" and "factoryMethodName" properties in BeanDefinition interface
* added "visitParentName", "visitFactoryBeanName" and "visitFactoryMethodName" callbacks to BeanDefinitionVisitor
* PropertyPlaceholderConfigurer resolves placeholders in parent, factory-bean and 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 beans 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" calls after the configuration phase
* bean creation records suppressed exceptions, exposing them as related causes in a subsequent BeanCreationException
* added "setTypeConverter" method to ConfigurableBeanFactory, allowing to override the default PropertyEditor mechanism
* introduced "removeBeanDefinition" method in BeanDefinitionRegistry interface and DefaultListableBeanFactory class
* exposed "isBeanNameInUse" method on BeanDefinitionRegistry interface
* AbstractBeanFactory supports any BeanDefinition implementation (does not require AbstractBeanDefinition anymore)
* reworked AbstractBeanFactory's bean definition merging for less coupling to RootBeanDefinition as merge result
* introduced GenericBeanDefinition as one-stop shop for standard bean definition purposes (with configurable parent)
* DefaultBeanNameGenerator does not require an AbstractBeanDefinition implementation for bean name generation anymore
* DefaultBeanNameGenerator generates a "#0" suffix in the canonical name even for 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 @Autowired, 'constructor', 'byType' autowiring)
* Autowired/CommonAnnotationBeanPostProcessor registers autowired beans as dependent on their injected target bean
* AnnotationBeanConfigurerAspect proceeds without injection in case of a circular reference problem, logging a warning
* added "registerBeanComponent" convenience method to ParserContext
* changed visibility of BeanDefinitionParserDelegate's "buildTypedStringValue(ForMap)" methods to protected

Package org.springframework.context
* AspectJWeavingEnabler implements Ordered, exposing HIGHEST_PRECEDENCE (executing before other factory post-processors)
* moved AnnotationConfigUtils to "context.annotation" package (post-processor beans are a context-specific feature)
* "context:annotation-config" XML tag activates JPA's @PersistenceContext and @PersistenceUnit as well (if available)
* AnnotationConfig/ComponentScanBeanDefinitionParser sends component registration for each registered BeanPostProcessor
* AnnotationBeanNameGenerator does not silently adapt the default bean name in case 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 the OSGi bundle structure (if any)

Package org.springframework.cache
* added "maxElementsOnDisk" bean property to EhCacheFactoryBean, supporting EHCache 1.2.4's extended Cache constructor

Package org.springframework.core
* added "isAtLeastJava16()" convenience method to JdkVersion class
* OverridingClassLoader (and hence SimpleThrowawayClassLoader) exclude classes from the "sun." package
* fixed PathMatchingResourcePatternResolver to build correct JarFile URLs on WebLogic and WebSphere
* PathMatchingResourcePatternResolver uses a static Log instance in order to avoid 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, analogous to OverridingClassLoader

Package org.springframework.jdbc
* added exception translation based on SQLException subclasses introduced in Java 6
* added additional exceptions to divide hierarchy into Recoverable, Transient and 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/ProxyFactoryBean (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 failure
* MBeanExporter accepts bean name keys in NotificationListener mappings (in addition to ObjectName Strings)
* revised reflective class loading to use the correct ClassLoader according to the OSGi bundle structure (if any)

Package org.springframework.orm
* HibernateTemplate delegates to "SessionFactory.getCurrentSession()" when "allowCreate" has been set to "false"
* added overloaded "findByExample" methods with entityName argument to HibernateOperations/HibernateTemplate
* deprecated HibernateTemplate's "saveOrUpdateAll" method in favor of individual "saveOrUpdate"/"merge" usage
* fixed Hibernate/JpaTransactionManager to clean up properly in case of transaction 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 transaction 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(int)" call too

Package org.springframework.remoting
* RmiClientInterceptor and JaxRpcClientInterceptor propagate any kind of declared 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 ScheduledExecutorFactoryBean
* changed ScheduledExecutorFactoryBean's default behavior to shutdown immediately, 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 autowiring (even in case of AUTOWIRE_NO)

Package org.springframework.scheduling
* Quartz SchedulerFactoryBean does not set default AdaptableJobFactory in case of RemoteScheduler (not supported there)

Package org.springframework.scripting
* "lang:*" configuration elements create their implicit ScriptFactoryPostProcessor under a fully qualified bean name

Package org.springframework.transaction
* refined TransactionAspectSupport to allow for overriding the "getTransactionManager()" method in subclasses
* TransactionInterceptor only uses ThrowableHolderException if necessary and makes 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 default 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 the correct context
* added "postProcessWeb/PortletApplicationContext" method to FrameworkServlet/Portlet
* DispatcherServlet/Portlet's "noHandlerFound" declares Exception instead of just IOException/PortletException
* added "addInterceptor" and "addInterceptors" methods to Servlet/Portlet HandlerExecutionChain
* AbstractUrlHandlerMapping exposes "path within mapping" attribute through an interceptor (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()" template 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 requires Hibernate 3.1 or higher now
* spring-context.jar includes JMX support and core remoting support (no spring-jmx 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 in 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 / AbstractBeanFactory
* mirrored FactoryBean's "getObjectType()" as abstract method in AbstractFactoryBean again, for @Override compatibility
* reworked SmartInstantiationAwareBeanPostProcessor's "determineConstructor" hook into "determineCandidateConstructors"
* added "resolveAliases" method to ConfigurableBeanFactory, applying a given StringValueResolver
* PropertyPlaceholderConfigurer applies its placeholder parsing to alias target names and aliases as well
* PropertyResourceConfigurer (and in particular PropertyPlaceholderConfigurer) is marked as PriorityOrdered
* BeanWiringInfo and ClassName/AnnotationBeanWiringInfoResolver support the notion of a 'default' bean name
* @Configurable applies factory callbacks (BeanFactoryAware, InitializingBean etc) and post-processors as well
* @Configurable applies factory callbacks and post-processors if no bean definition found for default bean name
* DefaultListableBeanFactory clears a cached merged bean definition in case of re-registering a bean definition
* AbstractBeanDefinition declares a public "clone()" method as well as "AbstractBeanDefinition cloneBeanDefinition()"
* AbstractBeanDefinition excludes purely descriptive metadata from its equals check (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 explicitly specified property value
* InitDestroy/Common/AutowiredAnnotationBeanPostProcessor use ConcurrentHashMaps for minimal locking
* introduced AnnotatedBeanDefinition interface and AnnotatedRootBeanDefinition implementation class
* added support for the JDK 1.6 ServiceLoader facility (package "beans.factory.serviceloader")

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(Factory)PostProcessors first
* AbstractApplicationContext creates all non-ordered BeanPostProcessors first before 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 (autodetecting the runtime environment)
* added LoadTimeWeaverAware interface, automatically supported if a default LoadTimeWeaver is available
* added AspectJWeavingEnabler, registering AspectJ's class transformer for standard AspectJ load-time weaving
* added "context:load-time-weaver" XML tag, building a default LoadTimeWeaver and enabling AspectJ load-time weaving
* introduced ScannedRootBeanDefinition class for autodetected components
* added @Scope annotation for autodetected components, indicating the target bean scope in the Spring context
* reworked ClassPathBeanDefinitionScanner into subclass of ClasspathScanningCandidateComponentProvider
* 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 extended messages and convenience accessors
* introduced PriorityOrdered marker interface, with order values automatically applied 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 with 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.filter"
* introduced ClassReaderFactory abstraction, with SimpleClassReaderFactory and CachingClassReaderFactory implementations
* introduced ClassReaderFactory as TypeFilter match argument, for resolving cached ClassReaders for the type hierarchy
* moved FilterType enum to "context.annotation" package, since it is closely related to component scanning
* introduced AnnotatedBeanDefinition interface and AnnotatedRootBeanDefinition implementation 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 from stored procedures
* added stored procedure support for retrieving update counts and storing the retrieved int in the output map
* added automatic processing of stored proc returned resultsets (will create default one if declared parameter missing)
* added automatic processing of stored proc update counts (will create default one if declared parameter missing)

Package org.springframework.jmx
* MBeanExporter does not insist of a minimum of 1 bean exposed anymore, also accepting no beans to export in the context

Package org.springframework.mail
* JavaMailSenderImpl sets the original message id (if specified in the given MimeMessage) after "message.saveChanges()"

Package org.springframework.mock
* added MockJspWriter and MockBodyContent classes for testing content-emitting JSP tags
* MockPageContext supports the "getOut()" method, exposing a MockJspWriter

Package org.springframework.orm
* LocalContainerEntityManagerFactoryBean and DefaultPersistenceUnitManager autodetect a context's default LoadTimeWeaver
* avoid double invocation of @PersistenceContext/Unit setter method in case of explicitly specified property value

Package org.springframework.transaction
* marked DelegatingTransactionAttribute as Serializable
* added mode="proxy"/"aspectj" flag to "tx:annotation-driven" config tag, for choosing the AspectJ transaction aspect
* WebSphereUowTransactionManager does not enforce the presence of a JTA UserTransaction anymore
* WebSphereTransactionManagerFactoryBean uses the context class loader for compatibility with the WSAD 5.1 test server

Package org.springframework.util
* added "makeAccessible(Method)" and "makeAccessible(Constructor)" convenience methods to ReflectionUtils
* added "matchStart" method to PathMatcher interface and AntPathMatch implementation, for checking the start of a match

Package org.springframework.web
* added "getDescription" method to WebRequest interface
* ServletWebRequest and PortletWebRequest expose a descriptive "toString()" result (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 call 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 handler methods (as handler methods)
* CancellableFormController suppresses validation for a cancel request
* AbstractView and AbstractTemplateView pass an explicit ServletContext reference 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 within 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 RemoteInvocationUtilsTests 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 init and destroy annotations
* introduced CommonAnnotationBeanPostProcessor, processing JSR-250's @PostConstruct, @PreDestroy and @Resource
* introduced @Autowired annotation, indicating that a field, config method or constructor is supposed to be autowired
* introduced AutowiredAnnotationBeanPostProcessor, processing the new @Autowired annotation
* fixed AbstractAutowireCapableBeanFactory to allow for changing the InstantiantionStrategy (again)
* deprecated BeanDefinitionReader's "BeanDefinitionRegistry getBeanFactory()" method in favor of "getRegistry()"
* exposed "getBeanNameGenerator()" method in BeanDefinitionReader interface
* changed XmlReaderContext's "getReader()" method to expose the plain BeanDefinitionReader interface
* added "getResourceLoader()" convenience method to XmlReaderContext, exposing the context's ResourceLoader (if any)
* added "getBeanClassLoader()" convenience method to XmlReaderContext

Package org.springframework.context
* introduced CandidateComponentProvider mechnism, for finding annotated component 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 files

Package org.springframework.jca
* introduced GenericMessageEndpointManager for JCA 1.5 message endpoint management, plus supporting infrastructure
* introduced SpringContextResourceAdapter, for deploying a Spring application context as JCA 1.5 RAR file
* added BootstrapContextAware interface, as a callback in a JCA 1.5 resource adapter environment

Package org.springframework.jdbc
* AbstractDataSource and DelegatingDataSource support the JDBC 4.0 Wrapper interface
* added Jdbc4NativeJdbcExtractor, delegating to JDBC 4.0's "unwrap" method (defined 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 message
* added BeanPropertyRowMapper, providing automatic mapping between columns and bean properties
* moved "isInputValueProvided" method from SqlOutParameter up to the SqlParameter 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 ActivationSpecs 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 MockServletContext

Package org.springframework.orm
* Hibernate LocalSessionFactoryBean prefers a Hibernate 3.1 CurrentSessionContext 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 creation of specific JTA Transaction objects
* JtaTransactionManager and WebLogic/OC4JJtaTransactionManager implement the TransactionFactory interface accordingly
* JtaTransactionManager autodetects and uses JTA 1.1's TransactionSynchronizationRegistry (e.g. on Java EE 5)
* added WebSphereUowTransactionManager, supporting full transaction management via IBM's UOWManager API on WAS 6.0/6.1
* removed WAS 4.0/5.0 support from WebSphereTransactionManagerFactoryBean, keeping 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 WebLogic 6.1 compatibility necessary anymore)
* removed CosMultipartResolver (as part of generally removing COS support from the Spring codebase)
* introduced explicit JSF 1.2 support (web.jsf.el): DelegatingFacesELResolver and WebApplicationContextFacesELResolver
* JSP InputTag, SelectTag etc support expressions as "disabled" and "readonly" attribute 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 class is not marked for raw target access
* AbstractRefreshableTargetSource's "getTargetClass()" method is properly synchronized
* 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 and no property-specific editor registered
* BeanWrapper converts an empty String to null in case of a Java 5 enum as target type
* default editor settings get copied to nested beans even if no default editors have been used yet
* revised MethodInvokingFactoryBean's "getObjectType()" implementation to gracefully return null if not prepared already
* added "determineConstructor(beanClass, beanName)" method to SmartInstantiationAwareBeanPostProcessor
* AbstractBeanFactory's "containsBean"/"isSingleton"/"isTypeMatch"/etc behave correctly for "&" FactoryBean dereferences
* AbstractBeanFactory uses concurrent Maps for singletons, aliases and bean definitions (for better concurrency)
* DefaultListableBeanFactory finds initialized FactoryBeans / factory-bean references in case of allowEagerInit=false
* fixed ConstructorResolver to correctly convert prepared collection arguments to arrays if necessary (for prototypes)
* added overloaded "rootBeanDefinition" factory methods with bean class name (instead 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, sharing 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:properties", allowing for scoped collections

Package org.springframework.context
* factored out fine-grained protected template methods from AbstractApplicationContext's "refresh()" implementation
* AbstractRefreshableApplicationContext actually calls the 2.0.3-introduced "customizeBeanFactory" template method

Package org.springframework.core
* BridgeMethodResolver is able to match open type variables in complex overloading scenarios as well
* BridgeMethodResolver caches based on TypeVariable references, handling overlapping type variable names appropriately
* added "createConcurrentMap" method to CollectionFactory, creating a JDK 1.5+ or backport-concurrent ConcurrentHashMap
* Constants class always uses upper-case transformation according to English notation
* added "toCodeForSuffix" operation to Constants class

Package org.springframework.instrument
* ShadowingClassLoader explicitly defines a package for all classes that it loads, for "Class.getPackage()" to work

Package org.springframework.jdbc
* fixed GeneratedKeyHolder to avoid NPE in exception message in case of a null key returned by the JDBC driver
* fixed JdbcTemplate's fallback support for batch updates to properly handle InterruptibleBatchPreparedStatementSetters
* added scale support to SqlParameter, for declaring numeric RdbmsOperation parameters with a specific scale
* added SqlParameterValue class, holding a value including SQL type and scale, accepted by JdbcTemplate argument arrays
* optimized SQL parsing in NamedParameterUtils, NamedParameterJdbcTemplate and SqlOperation through the use of caching
* added "execute" operation with PreparedStatementCallback argument to NamedParameterJdbcOperations/Template
* added overloaded "query" operations with ResultSetExtractor argument to NamedParameterJdbcOperations/Template
* SqlQuery and SqlUpdate accept named parameter declarations in arbitrary order (not requiring positional declaration)
* SqlQuery and SqlUpdate accept unparameter declarations for named parameter usage (assuming positional declaration)

Package org.springframework.jms
* JndiDestinationResolver prefers a concurrent Map for caching purposes (for better concurrency)
* changed visibility of various AbstractMessageListenerContainer property accessors from protected to public
* JmsInvokerClientInterceptor/ProxyFactoryBean and JmsInvokerServiceExporter support 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 PersistenceUnitInfo's "transactionType" (if possible)
* PersistenceAnnotationBeanPostProcessor is able to resolve a lazy EntityManagerFactory 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 specified service object being a String
* added "replaceExistingBinding" property to RmiServiceExporter, allowing to turn off the automatic replacement strategy
* JndiRmiClientInterceptor/ProxyFactoryBean detects CORBA SystemExceptions and converts them to RemoteAccessExceptions
* JndiRmiClientInterceptor/ProxyFactoryBean detects CORBA OBJECT_NOT_FOUND connect failures and recovers accordingly

Package org.springframework.scheduling
* MethodInvokingJobDetailFactoryBean avoids obtaining the target bean twice in case of "targetBeanName" specified
* revised MethodInvokingJobDetailFactoryBean's error message to include the target class instead of the target object
* DelegatingTimerTask catches any exception or error thrown from its delegate Runnable, to make the Timer proceed
* added "continueScheduledExecutionAfterException" flag to ScheduledExecutorFactoryBean, 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-final, allowing for flexible overriding

Package org.springframework.transaction
* AbstractPlatformTransactionManager properly resumes 'foreign' existing synchronization even in case of begin failure
* revised OC4JJtaTransactionManager to support the "oracle.j2ee.transaction" package on OC4J later than 10.1.3.2

Package org.springframework.ui
* ResourceBundleThemeSource will always return the same Theme instance for a given 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 separator 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 ApplicationContext refreshes
* made AbstractHandlerMapping's "setInterceptors" method non-final
* added "extendInterceptors" template method to AbstractHandlerMapping, for registering additional interceptors
* UrlFilenameViewController and InternalPathMethodNameResolver prefer a concurrent Map for caching purposes
* added "mappedHandlerClasses" property to Servlet/Portlet SimpleMappingExceptionResolver, for mapping specific types
* factored out protected "shouldApplyTo" and "doResolveException" template methods in SimpleMappingExceptionResolver
* added "localesToInitialize" property to ResourceBundleViewResolver, for initializing common locales eagerly
* XmlViewResolver (and similar strategies) work again in combination with the implicit default BeanNameUrlHandlerMapping
* JSP FormTag escapes the entire query string, including the parameter separators
* JSP SelectTag always renders a full closing tag (i.e. never renders a short-circuited 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 overridden "toString()" implementation
* FreeMarkerView exposes a ServletConfig object to FreeMarker, for use with ServletConfig-accessing JSP tags
* fixed AbstractXsltView to correctly apply a specified custom "contentType", even in case of a stylesheet specified
* revised XsltView for Servlet 2.3 compatibility, avoiding the "HttpServletResponse.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 source as well (for Hibernate/JPA queries)
* PortletUtils' "getParametersStartingWith" method checks for an empty value array (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 prototype 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 aspects, increasing performance
* introduced Simple(MetadataAware)AspectInstanceFactory, creating an independent aspect instance on every invocation
* revised AspectJProxyFactory to avoid "spring-beans" dependencies, using SimpleMetadataAwareAspectInstanceFactory now
* AbstractAspectJAdvice lazily calculates argument bindings, avoiding a "spring-beans" dependency (InitializingBean)
* "this" pointcut in AspectJ pointcut expressions is matched against the proxy object 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 allow for specific synchronization
* BeanWrapperImpl mimimizes bean name parsing overhead and caches parsed property path tokens
* PatternEditor allows for customization through specifying "java.util.regex.Pattern" 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 BeanFactory has not been injected yet
* AbstractAutowireCapableBeanFactory uses "filteredPropertyDescriptorsCache" for the PropertyDescriptor array per class
* DefaultListableBeanFactory is able to invoke public init and destroy methods on package-protected classes
* DefaultListableBeanFactory caches pre-converted property values as far as possible
* DefaultListableBeanFactory allows placeholders in class names even for non-lazy-init beans
* ConstructorResolver caches the resolved constructor or factory method, for faster re-creation of prototype instances
* ConstructorResolver caches converted argument values, to avoid conversion overhead 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 interface, for statically registered listeners

Package org.springframework.core
* added "getNames", "getNamesForProperty", "getNamesForSuffix" and "getValuesForSuffix" methods to Constants
* fixed GenericCollectionTypeResolver to correctly navigate Map-List-List structures with a nesting level of 3 or more
* BridgeMethodResolver performs multi-step resolution of type variables, for complex multi-type inheritance scenarios

Package org.springframework.dao
* PersistenceExceptionTranslationInterceptor supports PersistenceExceptionTranslator 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 TransactionAwareConnectionFactoryProxy
* 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 not currently running (has been stopped)
* DefaultMessageListenerContainer allows for specifying the listener object lazily, and for replacing it at runtime
* fixed JmsInvokerClientInterceptor/ProxyFactoryBean's "queue" property to declare type Queue now

Package org.springframework.jndi
* added "proxyInterfaces" property to JndiObjectFactoryBean, for specifying multiple interfaces
* JndiObjectFactoryBean autodetects proxy interfaces from a specified "expectedType", 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-Priority" 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 "OutputStream.flush()" / "Writer.flush()" call

Package org.springframework.orm
* SharedEntityManagerCreator's proxies deliver a "toString()" result without touching a target EntityManager
* added protected "getPersistenceUnitInfo" method to DefaultPersistenceUnitManager, to allow for better subclassing
* DefaultPersistenceUnitManager clears the default PersistenceUnitInfo once it has been obtained
* added "defaultPersistenceUnitName" property to PersistenceAnnotationBeanPostProcessor
* PersistenceAnnotationBeanPostProcessor only sets fields/methods accessible when actually necessary

Package org.springframework.remoting
* RemoteInvocationUtils detects cycles in exception causes when updating the stack trace (avoiding an infinite loop)

Package org.springframework.samples
* added default Hibernate EntityManager and Apache OpenJPA configurations to PetClinic's WAR file and integration tests
* PetClinic's JPA variant explicitly specifies "META-INF/orm.xml" as mapping file (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 Quartz, 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 NoClassDefFoundErrors in all scenarios
* added "scope" attribute to all script tags in the "lang" namespace, allowing for non-singleton script objects
* updated JRuby support for JRuby 0.9.8 (requiring this version now due to incompatible JRuby API changes)

Package org.springframework.test
* added "getActualException()" method to AssertThrows, for introspecting the actual exception instance after throwing

Package org.springframework.transaction
* factored out TransactionOperations interface from TransactionTemplate, defining 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 detect 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 PortletWebRequest to public
* CharacterEncodingFilter sets the encoding as default response encoding on Servlet 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 method 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, analogous to DispatcherServlet
* factored out protected "getHandlerExecutionChain" template method in Servlet/Portlet AbstractHandlerMapping
* added "getRootHandler()" method to AbstractUrlHandlerMapping, called on each access to the root handler
* added overloaded "suppressValidation(request, command, errors)" variant to BaseCommandController
* deprecated "suppressValidation(request)" in BaseCommandController, in favor of the "(request, command)" variant
* revised AbstractXsltView for transformer customization options ("buildTransformer" 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" attribute (not just a request-scoped one)
* JSP FormTag escapes the "action" attribute as well if HTML escaping has been requested
* JSP InputTag supports the common "autocomplete" HTML extension attribute (as supported 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 collection elements
* added missing "readonly" attribute to JSP TextareaTag
* checkbox and radiobutton macros in "spring.vm" for Velocity do not render an id anymore (because it isn't unique)
* checkbox macro in "spring.vm" for Velocity and "spring.ftl" for FreeMarker renders 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 ClassLoader (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" distribution

Package org.springframework.aop
* introduced AfterAdvice marker, as super-interface of AfterReturningAdvice and ThrowsAdvice, for reduced coupling
* exposed "invocableClone()" and "setUserAttribute"/"getUserAttribute" on ProxyMethodInvocation, for reduced coupling
* introduced TargetClassAware interface, extended by Advised, and framework-decoupled "AopUtils.getTargetClass" method
* fixed ClassFilters to provide JDK-1.3/1.4-compatible "hashCode()" implementations 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 AnnotationMatchingPointcut
* redefined target-class proxying to create a JDK proxy in case of the target class being an interface
* CGLIB proxies handle "hashCode" calls according to their "equals" behavior, analogous 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 down to new ProxyCreatorSupport base class
* AdvisorChainFactory is not forced to implement the AdvisedSupportListener interface anymore
* deprecated AdvisorChainFactoryUtils and HashMapCachingAdvisorChainFactory in favor of SimpleAdvisorChainFactory
* added overloaded ProxyFactory constructors for single-interceptor and TargetSource-only proxies
* ProxyFactoryBean exposes a composite interface as object type in case of multiple proxy interfaces specified
* AbstractSingletonProxyFactoryBean and AbstractAutoProxyCreator use the bean ClassLoader for generating proxies
* reworked AdvisorAdapter and AdvisorAdapterRegistry to expose a MethodInterceptor right away
* AspectJExpressionPointcut ignores target classes not accepted by PointcutExpression matching (such as arrays)
* AspectJExpressionPointcut falls back to the proxy method if the ShadowMatch failed for the target method
* revised AspectJPointcutAdvisor to never apply AspectJ advice methods to themselves (avoiding a stack overflow)
* AbstractAspectJAdvice calls "setAccessible" on an advice method right before invocation 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)" calls, cloning the underlying invocation
* PrototypeAspectInstanceFactory enforces that the target bean is a prototype; it does not accept scoped objects
* PrototypeTargetSource enforces that the target bean is a prototype; it does not accept scoped objects
* PrototypeTargetSource destroys bean instances on release (honors DisposableBean and/or destroy-method)
* ThreadLocalTargetSource destroys bean instances via ConfigurableBeanFactory's "destroyBean" (if possible)
* added "forClass" factory method to EmptyTargetSource, allowing to indicate a specific target class
* added "equals"/"hashCode" implementation to AbstractBeanFactoryBasedTargetSource
* HotSwappableTargetSource's "hashCode" implementation returns a constant value even if the target object changes
* added SimpleBeanTargetSource, performing a fresh getBean lookup on every request, 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 target 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 turn target class proxying off
* reworked "scoped-proxy" XML tag to enforce a target class proxy selectively, for its specific target bean
* "scoped-proxy" marks its targets as autowireCandidate=false, to make autowiring 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 superclass/interface of the target class
* added SmartInstantiationAwareBeanPostProcessor interface, supporting type prediction (for scripted object types)
* PropertyPlaceholderConfigurer detects and processes placeholders in scope names as well
* PropertyPlaceholderConfigurer does not log resolved (potentially decrypted) placeholder values at debug level anymore
* PreferencesPlaceholderConfigurer resolves paths in placeholders ("myPath/myPlaceholderKey") as preference nodes
* added "isPrototype(beanName)" method to BeanFactory interface, explicitly checking 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 "postProcessObjectFromFactoryBean" fails
* DisposableBeanAdapter (as passed into "Scope.registerDestructionCallback") is serializable, even for post-processors
* AbstractAutowireCapableBeanFactory does not trigger "toString()" call on argument for UnsatisfiedDependencyException
* turned visibility of AbstractAutowireCapableBeanFactory's "applyPropertyValues" method from private to protected
* DefaultListableBeanFactory's "getBeansOfType" only ignores currently-in-creation 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 AbstractBeanDefinitionReader
* added "generateBeanName/registerWithGeneratedName(BeanDefinition)" methods to XmlReaderContext
* BeanDefinitionParseDelegate always builds TypedStringValue for "value" and "null" XML elements, preserving the source
* BeanDefinitionParseDelegate builds TypedStringValue for "entry" and "prop" keys and values, preserving the source
* BeanDefinitionParseDelegate trims whitespace from "class" attributes in XML bean 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="true", 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 full compatibility with Spring 2.0 final
* added protected "shouldGenerateIdAsFallback()" template method to AbstractBeanDefinitionParser
* AbstractSingleBeanDefinitionParser applies a document's default-lazy-init="true" to its generated bean definitions
* added "isEligibleAttribute" template method to AbstractSimpleBeanDefinitionParser, for excluding specific attributes
* "util:properties" tag supports nested "prop" elements for local entries, analogous to the standard "props" tag

Package org.springframework.context
* AbstractApplicationContext instantiates BeanPostProcessors which implemented Ordered before non-Ordered ones
* AbstractApplicationContext applies start/stop callbacks to existing Lifecycle instances only, particularly on shutdown
* AbstractApplicationContext correctly detects listener creation failure (in case of currently-in-creation exception)
* factored out protected "destroyBeans()" template method in AbstractApplicationContext, for custom bean destruction
* AbstractRefreshableApplicationContext allows BeanFactory access during the destruction phase of a "refresh()" call
* added "customizeBeanFactory(DefaultListableBeanFactory)" template method to AbstractRefreshableApplicationContext
* (Reloadable)ResourceBundleMessageSource trims whitespace from specified bundle basenames
* ResourceBundleMessageSource by default uses the bean ClassLoader for loading bundles

Package org.springframework.core
* added "getMostSpecificCause()" method to NestedRuntime/CheckedException, retrieving the root cause or this exception
* fixed BridgeMethodResolver's "populateTypeMapFromParameterizedType" to properly handle nested generics
* fixed BridgeMethodResolver to properly detect a generic interface even in a class hierarchy
* fixed BridgeMethodResolver to properly detect a generic array type as exposed by a vararg signature
* introduced AsyncTaskExecutor extension interface, defining an "execute" variant with start timeout
* refactored SimpleAsyncTaskExecutor to allow for reuse of the CustomizableThreadCreator class
* SimpleAsyncTaskExecutor executes tasks with timeout='immediate' directly, bypassing the concurrency throttle
* introduced TaskTimeoutException, thrown by an AsyncTaskExecutor in case of a task rejected because of a timeout

Package org.springframework.dao
* PersistenceExceptionTranslationPostProcessor uses the bean ClassLoader for generating translation proxies

Package org.springframework.ejb
* AbstractEnterpriseBean uses the EJB instance as WeakReferenceMonitor handle, instead 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 Remote EJB (RMI) connect failure as well

Package org.springframework.instrument
* ShadowingClassLoader excludes "com.sun." package by default (for using Sun's Xerces version through JAXP)

Package org.springframework.jca
* TransactionAwareConnectionFactoryProxy throws JCA IllegalStateException in case of "getLocalTransaction()" access
* CciLocalTransactionManager unwraps given TransactionAwareConnectionFactoryProxy 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 and a SimpleTaskWorkManager implementation

Package org.springframework.jdbc
* added overloaded ConnectionHolder constructor with a given Connection plus "transactionActive" flag as arguments
* UserCredentialDataSourceAdapter delegates "getConnection(String, String)" to "doGetConnection", for unified handling
* introduced IsolationLevelDataSourceAdapter, preparing Connections with isolation 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 applications (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 JmsTemplate up to JmsAccessor
* TransactionAwareConnectionFactoryProxy throws TransactionInProgressException in case of manual commit/rollback calls
* JmsTransactionManager unwraps given TransactionAwareConnectionFactoryProxy to obtain its target ConnectionFactory
* ConnectionFactoryUtils's JmsResourceHolder only stops Connections if a SmartConnectionFactory explicitly asks for it
* factored out AbstractJmsListeningContainer base class from AbstractMessageListenerContainer
* AbstractMessageListenerContainer's "refreshSharedConnection" properly resets shared Connection in refresh failure case
* AbstractMessageListenerContainer explicitly aborts messages which have been delivered after initiated shutdown
* added "acceptMessagesWhileStopping" flag to AbstractMessageListenerContainer, for processing all delivered messages
* factored out AbstractPollingMessageListenerContainer base class from DefaultMessageListenerContainer
* added dynamic scaling up/down to DefaultMessageListenerContainer, configured through "maxConcurrentConsumers" property
* DefaultMessageListenerContainer's Connection recovery loop catches any Exception thrown from "createConnection"
* MessageListenerAdapter can delegate to native target (SessionAware)MessageListener if no listener method specified

Package org.springframework.jmx
* MBeanExporter and MBeanServerConnectionFactoryBean use the bean ClassLoader for generating lazy-init proxies
* MBeanExporter supports lazy-init standard MBeans analogously to lazy-init Spring 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 in case of no agent id specified
* MBeanServerFactoryBean tries to create a new MBeanServer if not allowed to access the JDK 1.5 platform MBeanServer
* added WebSphereMBeanServerFactoryBean, using WebSphere's proprietary AdminServiceFactory 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 proxies
* JndiObjectTargetSource (as used by JndiObjectFactoryBean's "proxyInterface" support) 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 (passing the call on to a Filter/Servlet)

Package org.springframework.orm
* added "flushMode" init parameter to Hibernate3 OpenSessionInViewFilter (supporting "AUTO" etc as value)
* Hibernate3 SessionFactoryUtils translates SQLGrammar/DataException into InvalidDataAccessResourceUsageException
* Hibernate3 HibernateAccessor/TransactionManager translates GenericJDBCException using a default SQLExceptionTranslator
* TopLink LocalSessionFactory provides "loginProperties"/"loginPropertyMap" bean properties, for applying login settings
* TopLink LocalSessionFactoryBean uses the bean ClassLoader as TopLink Session ClassLoader

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 overhead of locating an existing registry
* added "rebind()" method to JndiRmiServiceExporter, for recovering in case of the target registry having been restarted
* CodebaseAwareObjectInputStream uses "Class.forName", to be able to resolve array classes with any ClassLoader
* added "getTargetInterfaceName()" method to RmiInvocationHandler, for client-side introspection
* HttpInvokerClientInterceptor does not require an "afterPropertiesSet()" call for 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 if a lazy "prepare()" attempt failed
* added "refreshServiceAfterConnectFailure" bean property to JaxRpcPortClientInterceptor, 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 ThreadFactory 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 ScheduledExecutorFactoryBean
* 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"/"hashCode/"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 prototypes from the same class
* JRubyScriptUtils passes the declared return type to JRuby, for proper conversion of number types
* JRubyScriptUtils converts Ruby arrays back to declared Java arrays
* ScriptFactoryPostProcessor uses the bean ClassLoader for generating refreshable script proxies
* ScriptFactoryPostProcessor applies a config interface to the scripted target object only, not to a refreshable proxy
* revised ScriptFactoryPostProcessor to support AOP auto-proxying for scripted objects
* 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, created through "createApplicationContext"
* added "customizeBeanFactory(DefaultListableBeanFactory)" template method to AbstractSingleSpringContextTests
* AbstractSingleSpringContextTests supports "getConfigPaths()" method, specifying config files relative to test class
* AbstractSingleSpringContextTests supports "getConfigPath()" method, specifying a single file relative to test class
* changed the visibility of AbstractDependencyInjectionSpringContextTests's "injectDependencies" method to protected
* changed the visibility of AbstractTransactionalSpringContextTests's "transactionDefinition" field to protected
* AssertThrows preserves an unexpected exception as root cause in the "wrong exception 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-only even in case of a commit exception
* turned various AbstractPlatformTransactionManager methods from private to protected, for reuse in specific subclasses
* JtaTransactionManager does not fail if default UserTransaction lookup fails: falls 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 transaction names and isolation levels
* fixed AbstractFallbackTransactionAttributeSource to synchronize access to its attribute cache
* added "order" attribute to "tx:annotation-driven" tag, determining the order of the tx advisor in the advice chain

Package org.springframework.util
* ResourceUtils's "extractJarFileURL" only prepends a slash in front of a file path 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-null)
* ConfigurableWebApplicationContext and ConfigurablePortletApplicationContext expose 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 to log the exception to warn level
* added protected "determineStatusCode" method to Servlet SimpleMappingExceptionResolver, for custom status codes
* added "rootHandler" bean property to AbstractUrlHandlerMapping, kicking in for the "/" path
* added "detectHandlersInAncestorContexts" to BeanNameUrlHandlerMapping, for detecting handler beans in the root context
* added "excludedPackages" and "excludedClasses" bean properties to ControllerClassNameHandlerMapping
* ControllerClassNameHandlerMapping excludes all classes in the "org.springframework.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 option tags in such a case
* ErrorsTag properly supports HTML escaping (participates in default HTML escaping 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 (ViewTool callbacks are now deprecated)
* FreeMarker "formTextarea" macro does not re-escape its value (escaping is up to "htmlEscape"/"defaultHtmlEscape")
* added "messageArgs" and "messageArgsText" macros to the "spring.ftl" FreeMarker 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 "debug" log level more bearable

Package org.springframework.aop
* AbstractRegexpMethodPointcut trims whitespace from passed-in "patterns" and "excludedPatterns"
* fixed AbstractAutoProxyCreator to allow for proxying the same bean with multiple auto proxy creators (again)
* BeanNameAutoProxyCreator trims whitespace from passed-in "beanNames"
* ScopedProxyFactoryBean throws IllegalStateException if it couldn't determine the type of the target bean (avoid NPE)
* "scoped-proxy" tag works for non-singleton FactoryBeans as well, leveraging the BeanFactory's improved type check
* factored out BeanFactoryAdvisorRetrievalHelper from AbstractAdvisorAutoProxyCreator
* factored out BeanFactoryAspectJAdvisorsBuilder from AnnotationAwareAspectJAutoProxyCreator
* 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 if their classes are not cache-safe
* BeanWrapper interface extends TypeConverter interface, instead of just BeanWrapperImpl implementing TypeConverter
* BeanWrapperImpl converts nested collection value (e.g. List within Map) to declared generic type, if applicable
* BeanWrapperImpl's TypeMismatchException mentions the specific element that failed in case of a (generic) collection
* BeanWrapperImpl assigns a given array directly if component type matches and no 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 off a generated "#..." suffix
* FieldRetrievingFactoryBean and PropertyPathFactoryBean extract the original bean 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 unintended BeanCurrentlyInCreationException
* DefaultSingletonBeanRegistry and subclasses use unified mutex for singleton access, to avoid potential for deadlocks
* AbstractBeanFactory caches merged bean definitions with bean definition identity as key (to avoid bean name conflicts)
* AbstractAutowireCapableBeanFactory caches "isExcludedFromDependencyCheck" results for affected PropertyDescriptors
* AbstractAutowireCapableBeanFactory provides two-step FactoryBean type check for non-singleton FactoryBeans as well
* fixed AbstractAutowireCapableBeanFactory to only apply injection-before-wrapping check for singletons
* DefaultListableBeanFactory avoids expensive dependency check preparations unless 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 SAXParseException and its location information
* XmlBeanDefinitionReader chooses XSD validation if XmlValidationModeDetector indicates AUTO (= no clear indication)
* XML bean "id" and "name" (aliases) are allowed to define the same name (for backwards 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 use ProblemReporter instead of exceptions
* added "fatal" method to ProblemReporter, used by NamespaceHandlerSupport to report a missing parser or decorator
* added "defaultsRegistered" notification to ReaderEventListener, with DefaultsDefinition marker interface as argument
* reworked BeanDefinitionParserDelegate to build and hold a DocumentDefaultsDefinition instance, also firing an event
* BeanDefinitionParserDelegate/AbstractBeanDefinitionParser report bean name generation failure through ProblemReporter
* DefaultBeanDefinitioDocumentReader reports alias registration failure through ProblemReporter

Package org.springframework.context
* AbstractApplicationContext explicitly stops all Lifecycle Beans before destroying 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 proxies
* reworked CollectionFactory's "createApproximateCollection/Map" to preserve original Comparator for TreeSet/TreeMap
* LocalVariableTableParameterNameDiscoverer uses current ClassLoader for ASM analysis (not the system ClassLoader)
* PathMatchingResourcePatternResolver properly handles jar file roots returned by the ClassLoader (e.g. on Resin)

Package org.springframework.dao
* added "singleResult" and "requiredSingleResult" methods to DataAccessUtils, distinct from "uniqueResult"'s contract

Package org.springframework.jdbc
* RowMapperResultSetExtractor always uses ArrayList, even in case of unknown number of rows expected
* JdbcTemplate by default uses "PreparedStatement.setString" for any CharSequence (including String and StringBuilder)
* JdbcTemplate logs SQLWarnings at debug instead of warn level, to avoid repeated warn logs for acceptable conditions
* JdbcTemplate's "queryForObject" uses "requiredSingleResult" to never accept more than 1 row in result (as per its c.)
* SqlQuery's "findObject" explicitly uses "singleResult" to never accept more than 1 row in result (as per its contract)

Package org.springframework.jms
* introduced SmartConnectionFactory interface and "ConnectionFactoryUtils.releaseConnection" method
* introduced DelegatingConnectionFactory, configuring whether a Connection should be stopped before closing it
* JmsTemplate/DefaultMessageListenerContainer do *not* explicitly stop their Connections by default anymore (see above)
* added "transactionName" property to DefaultMessageListenerContainer (in particular for WebLogic's tx monitoring)
* fixed JmsInvokerClientInterceptor to always explicitly start its Connection (not rely on pre-started Connections)

Package org.springframework.jmx
* reworked MBeanProxyFactoryBean's and ConnectorServerFactoryBean's "setObjectName" 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 update (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 enforces COMMIT or AUTO for read-write tx
* fixed "hashCode()" handling in extended JPA EntityManager proxy, avoiding an eternal recursion
* extended JPA EntityManagers that join a synchronized transaction propagate a commit exception to the (commit) caller
* PersistenceUnitReader determines URI-conforming persistence unit root (for Hibernate EntityManager's archive browsing)
* JpaTransactionManager and EntityManagerFactoryUtils's JTA synchronization clear a pre-bound EntityManager on rollback
* PersistenceAnnotationBeanPostProcessor allows for specifying JNDI names for persistence 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 properly handle passed-in "registry")
* HttpInvokerClientInterceptor/ProxyFactoryBean uses the ClassLoader of the containing 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 well as Quartz 1.5.2 (again)
* reworked Quartz SpringBeanJobFactory's "ignoredUnknownProperties" into a String array of unknown properties to ignore
* CommonJ TimerManagerFactoryBean supports Lifecycle interface, suspending/resuming 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/resume/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 versions 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 AbstractSingleSpringContextTests
* added public "getJdbcTemplate()" method to AbstractTransactionalDataSourceSpringContextTests

Package org.springframework.transaction
* AbstractPlatformTransactionManager logs full transaction definition when creating a new transaction
* added "defaultTimeout" property to AbstractPlatformTransactionManager

Package org.springframework.ui
* VelocityEngineFactory/SpringResourceLoader supports Velocity-style comma-separated 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 that have fewer parts than the pattern
* XmlValidationModeDetector returns VALIDATION_AUTO if it encounters a CharConversionException

Package org.springframework.validation
* added "prefix" property and "postProcessMessageCode" template method to DefaultMessageCodesResolver

Package org.springframework.web
* IntrospectorCleanupListener explicitly exposes the web app ClassLoader as cacheable for CachedIntrospectionResults
* introduced MissingServlet/PortletRequestParameterException subclasses of Servlet/PortletRequestBindingException
* reworked the 'default value for missing parameter' check in Servlet/PortletRequestUtils to be as efficient as possible
* AbstractUrlHandlerMapping exposes PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for default handler as well
* extracted "getViewNameForUrlPath(String)" in UrlFilenameViewController, for full 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 that 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 InputTag


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) as infrastructure classes to ignore
* fixed AbstractAutoProxyCreator to only obtain beans for "interceptorNames" that have been fully initialized already
* reworked AbstractAdvisorAutoProxyCreator's "extendCandidateAdvisors" into "extendAdvisors", operating on sorted list
* renamed AspectJInvocationContextExposingAdvisorAutoProxyCreator to AspectJAwareAdvisorAutoProxyCreator
* removed unintended JDK 1.5 dependency in AspectJExpressionPointcut ("equals"/"hashCode" implementation)
* added "order" attribute to "aspect" tag in AOP schema, allowing to declaratively 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 DelegatePerTargetObjectIntroductionInterceptor

Package org.springframework.beans
* fixed BeanWrapperImpl to correctly determine generic type for each key in a chain (e.g. "myMap[myKey][myInnerKey]")
* introduced PatternEditor for "java.util.regex.Pattern", automatically registered 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 registered 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 enforces uniqueness of merged ValueHolders
* reworked BeanComponentDefinition into subclass of BeanDefinitionHolder, exposing aliases on the bean definition
* re-added BeanReferenceFactoryBean, to allow for substituting the target bean name 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 singleton-refers-to-scoped-bean problem
* factory methods are allowed to return null, with the null value exposed as bean reference
* introduced "isTypeMatch" method on BeanFactory interface, allowing for type checks without actually loading the Class
* AbstractBeanFactory supports alias chaining, with an alias registered for a bean name that is itself an alias
* AbstractBeanFactory uses bean name as cache key for merged bean definitions, to avoid equality matching overhead
* AbstractBeanFactory detects circular references between non-singletons and throws 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", for 2.0-style inheritance for inner beans
* added "findAutowireCandidates" template method to AbstractAutowireCapableBeanFactory, superseding "findMatchingBeans"
* DefaultListableBeanFactory excludes beans which are not autowire candidates even 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 back to the default ClassLoader)
* introduced CompositeComponentDefinition for holding nested components (applied e.g. for "aop:config" element)
* introduced "registerComponent" method on ParserContext, for transparent registration of top-level or nested components
* reworked AbstractBeanDefinitionParser to only determine id and build holder for top-level bean definition
* "util:list/set/map" are now allowed as nested elements as well and do not require an id anymore

Package org.springframework.cache
* reworked EhCacheFactoryBean to be based on EHCache 1.2's Ehcache interface rather than the concrete Cache class
* added "blocking" flag to EhCacheFactoryBean, for decorating the cache with EHCache 1.2's BlockingCache
* added "cacheEntryFactory" flag to EhCacheFactoryBean, for decorating with EHCache 1.2's (Updating)SelfPopulatingCache

Package org.springframework.context
* added serialVersionUID to ApplicationEvent, for serialization compatibility with Spring 1.2
* LocaleContextHolder supports standard ThreadLocal as well as InheritableThreadLocal
* 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 (avoid IllegalStateException)
* introduced TaskRejectedException, thrown from a TaskExecutor if it does not accept a given task

Package org.springframework.instrument
* added GlassFishLoadTimeWeaver for GlassFish / Sun Application Server
* refactored Java-5-only AbstractOverridingClassLoader into JDK-1.3-compatible OverridingClassLoader 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 specifying 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 JMSExceptions in a specific fashion as well
* refined AbstractMessageListenerContainer's autodetection of "pubSubDomain" flag to handle WebLogic Topic correctly
* DefaultMessageListenerContainer uses its bean name (if specified) as thread name prefix for its default TaskExecutor

Package org.springframework.jmx
* MBeanExporter uses ObjectName as exposed by returned ObjectInstance after registration (which differs on WebSphere)
* MethodExclusionMBeanInfoAssembler operates correctly in case of no "ignoredMethods" specified

Package org.springframework.mock
* added "isActive()" and "close()" methods to MockHttpServletRequest and MockPortletRequest
* MockHttpServletResponse handles HTTP header names as case-insensitive (analogous to MockHttpServletRequest)
* added "setOutputStreamAccessAllowed" and "setWriterAccessAllowed" methods to MockHttpServletResponse
* unified mock object constructors that take ServletContext/PortletContext/PortalContext arguments
* added all of MockPortletRequest's overloaded constructors to MockActionRequest and MockRenderRequest
* turned AbstractSingleSpringContextTests's "contextKey" and "loadContext" methods non-final again
* AbstractSingleSpringContextTests provides empty default implementation of "getConfigLocations" (not abstract anymore)

Package org.springframework.orm
* reworked Hibernate session synchronization to properly work with WebSphereExtendedJTATransactionLookup 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 entry URLs correctly
* PersistenceAnnotationBeanPostProcessor always injects transactional EntityManager with extended interfaces (if any)
* included OpenJPA support classes (OpenJpaDialect, OpenJpaVendorAdapter), tested 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 "createTimer(name, daemon)"
* ScheduledExecutorFactoryBean does not insist on statically specified ScheduledExecutorTasks anymore
* DelegatingWork/Job/TimerTask exposes the wrapped Runnable implementation through a "getDelegate()" method
* Concurrent/ThreadPoolTaskExecutor and WorkManagerTaskExecutor throw Spring's TaskRejectedException (when appropriate)
* CommonJ TimerManagerFactoryBean cancels all statically registered Timers on shutdown
* updated LocalTaskExecutorThreadPool to be compatible with Quartz 1.6

Package org.springframework.test
* AbstractTransactionalSpringContextTests invokes "onTearDownAfterTransaction" even for a manually completed transaction
* fixed AbstractJpaTests to not keep context reference in cache if context refresh 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 NPE if no current JTA transaction active
* TransactionAttributeEditor does not accept transaction attributes with invalid whitespace anymore
* fixed AnnotationTransactionAspect to not throw a NoTransactionException in case 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 favor 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, always falling back to the Jakarta JSTL
* WebDataBinder explicitly suppresses field marker prefix values in case of "ignoreUnknownFields" switched off
* Servlet/PortletRequestAttributes allow for accessing the session even after the request has been completed
* RequestContextHolder supports standard ThreadLocal as well as InheritableThreadLocal
* DispatcherServlet/Portlet do not expose LocaleContext/RequestAttributes as inheritable for child threads anymore
* added "threadContextInheritable" property to DispatcherServlet and DispatcherPortlet, 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 adding 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 array 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 session and request parameters)
* FreeMarkerView uses the ObjectWrapper as specified in the FreeMarker configuration, 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 instance in case of actual parameters
* added "boolean useWriter()" method to AbstractXsltView, allowing to prefer Writer 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) turn 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 ConfigurableBeanFactory interface
* added "getConversationId" method to Scope interface (exposing session id for session scope, null for request scope)
* introduced BeanMetadataElement interface, giving access to config source object (implemented by BeanDefinition etc)
* introduced BeanReference interface, implemented by RuntimeBeanReference as well as RuntimeBeanNameReference
* dropped BeanReferenceFactoryBean; use the available alias mechanisms instead
* reworked CustomScopeConfigurer to only support Scope instances as values for the "scopes" map
* DefaultSingletonBeanRegistry keeps singleton beans in registration order (requires JDK 1.4 or Commons Collections)
* AbstractBeanFactory does not explicitly register a given alias that is equal to the canonical bean name
* dropped BeanDefinitionRegistryBuilder in favor of refined BeanDefinitionReaderUtils convenience methods
* added "getInnerBeanDefinitions()" accessor to ComponentDefinition interface, exposing all relevant inner beans
* added Resource argument to SourceExtractor interface, exposing the defining resource for the given source candidate
* reworked type matching for FactoryBeans, avoiding repeated recreation/destruction through early "getObjectType" checks
* "lookup-method" overrides no-arg method only, to let overloaded variants be implemented in a traditional fashion
* added "setAllowRawInjectionDespiteWrapping" config method to DefaultListableBeanFactory, to enable Spring 1.2 behavior
* added overloaded AbstractSingleBeanDefinitionParser's "doParse" template method with a ParserContext argument
* moved ComponentDefinition, ReaderContext and support classes from "beans.factory.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 EHCache warning (requires EHCache 1.2 now)

Package org.springframework.core
* AbstractLabeledEnum uses label as "toString()" representation, analogous to JDK 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 with 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 AbstractMessageListenerContainer
* 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: JmsInvokerServiceExporter, 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 MockMultipartActionRequest for testing multipart access

Package org.springframework.orm
* added overloaded query/insert/update/delete operations without parameter object 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 LocalSessionFactoryBean
* Hibernate3 LocalSessionFactoryBean registers filter definitions before loading any mapping files
* ScopedBeanInterceptor for Hibernate3 exposes target class name as Hibernate entity name in case of a CGLIB proxy
* changed the semantics of AbstractJpaVendorAdapter's "generateDdl" flag to create/update (instead of drop-and-recreate)

Package org.springframework.transaction
* clarified @Transactional semantics for JDK/CGLIB proxies as well as for AspectJ
* AbstractPlatformTransactionManager properly propagates an "afterCommit" synchronization exception to the caller
* JtaTransactionManager executes "afterCommit" callbacks even when synchronizing with an existing JTA transaction
* factored out TransactionSynchronizationUtils and JtaAfterCompletionSynchronization helper classes
* introduced CallbackPreferringPlatformTransactionManager interface, to be implemented by callback-loving PTM impls
* TransactionTemplate/TransactionInterceptor automatically detect and use CallbackPreferringPlatformTransactionManager
* fixed MethodMapTransactionAttributeSource to avoid unnecessary reinitialization of method map

Package org.springframework.util
* ClassUtils falls back to the system class loader if the thread context class loader 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, allowed 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, allowing to intercept action phase too
* added "applyWebRequestInterceptorsToRenderPhaseOnly" flag to Portlet AbstractHandlerMapping
* factored out AbstractMapBasedHandlerMapping base class from Parameter/PortletMode/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 versioning of future additions and changes
* spring-beans-2.0.dtd/xsd does not support singleton="true"/"false" anymore. Use 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 as Hibernate EntityManager 3.2.0 CR4
* removed ORM support for Apache OJB from the Spring core distribution. OJB support 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/AopConfigException/IllegalStateException
* Cglib2AopProxy exposes additional interfaces of a CGLIB-enhanced target bean on a CGLIB AOP proxy as well
* fixed PointcutAdvisor support classes to avoid eager access to Advice and Pointcut 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 singletons (only once a pointcut matches)
* fixed @Configurable support to correctly identify the class name even for a CGLIB 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 collection/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 destroying a given instance based on a bean def
* added support for destruction callbacks to Scope abstraction, driven by a BeanFactory's definition for a scoped bean
* PropertyResourceConfigurer, CustomEditorConfigurer and CustomScopeConfigurer use 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 name (-> bean definition overriding)
* reworked AbstractBeanFactory's alias handling to support local alias definitions 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 BeanPostProcessor and wraps it in BeanCreationException
* DefaultListableBeanFactory's "preInstantiateSingletons" only fetches the FactoryBean instance (instead of its object)
* reworked DefaultListableBeanFactory's beans-by-type lookup to ignore beans that have been overridden by an alias
* inner bean definitions inherit the singleton status of their containing bean even 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 default now (requires EHCache 1.2)
* added "shared" flag to EhCacheManagerFactoryBean, allowing to explicitly ask for a shared CacheManager instance
* refined EhCacheManagerFactoryBean to use pass in an InputStream instead of a URL for CacheManager initialization

Package org.springframework.context
* exposed AbstractApplicationContext's "registerShutdownHook()" method in ConfigurableApplicationContext interface
* reverted AbstractApplicationContext to not inherit ClassLoader from parent context by default (as up until 2.0 RC1)
* added appropriate "equals"/"hashCode" implementations to DefaultMessageSourceResolvable

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 on JDK 1.3 without Commons Collections
* PathMatchingResourcePatternResolver ignores classpath roots that cannot be resolved as jar or in file system

Package org.springframework.ejb
* introduced EjbAccessException as replacement of AOP Alliance AspectException in local/remote SLSB invoker interceptors

Package org.springframework.instrument
* removed unused AbstractLoadTimeWeaver and AspectJWeavingTransformer classes
* reworked ReflectiveLoadTimeWeaver to cache Method references and consider "getThrowawayClassLoader" as optional
* fixed AbstractOverridingClassLoader to override "loadClass(name, resolve)" and correctly synchronize its variables
* fixed and reworked AbstractOverridingClassLoader's facility for excluding class 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" methods 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 "hashCode" based on proxy equality
* factored out "resetConnection", "prepareConnection" and "closeConnection" methods in SingleConnectionDataSource
* CommonsDbcpNativeJdbcExtractor supports original Commons DBCP as well as Tomcat 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 DataAccessResourceFailureException
* added SingleDataSourceLookup, exposing a single given DataSource for any data source name
* added AbstractInterruptibleBatchPreparedStatementSetter base class, with single "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" methods in SingleConnectionFactory
* added "exceptionListener" and "reconnectOnException" properties to SingleConnectionFactory
* JmsTemplate and AbstractMessageListenerContainer call "stop()" on a Connection before closing it (if started before)
* DefaultMessageListenerContainer does not block on startup until it can establish a shared Connection (if necessary)
* added support for synchronized local JMS transactions (alongside some other main transaction) to JmsTemplate
* added TransactionAwareConnectionFactoryProxy, including support for synchronized local JMS transactions

Package org.springframework.orm
* iBATIS support works correctly with "useTransactionAwareDataSource" and JTA transaction resume with subsequent access
* reintroduced default SQLExceptionTranslator in JdoAccessor/JdoTransactionManager/LocalPersistenceManagerFactoryBean
* HibernateTemplate exposes Session proxies that implement the SessionImplementor 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 cause of Spring's HibernateJdbcException
* added ScopedBeanInterceptor for Hibernate3, exposing the raw target class as entity name in case of a scoped proxy
* LocalPersistenceManagerFactoryBean and JdoTemplate perform full exception translation 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 just the PersistenceProvider class
* added PersistenceUnitManager interface and DefaultPersistenceUnitManager implementation (in "jpa.persistenceunit")
* added "persistenceUnitManager" bean property to LocalContainerEntityManagerFactoryBean (default is internal manager)
* "dataSourceLookup"/"dataSources" configuration is now available on DefaultPersistenceUnitManager instead of LCEMFB
* "postProcessPersistenceUnitInfo" hook method is now available on DefaultPersistenceUnitManager instead of LCEMFB
* introduced PersistenceUnitPostProcessor interface, to be registered on DefaultPersistenceUnitManager or LCEMFB
* introduced MutablePersistenceUnitInfo base class, to turn SpringPersistenceUnitInfo to package-protected again
* PersistenceUnitReader searches for "classpath*:**/SCHEMA_NAME" last, and catches and logs any IOException thrown
* added support for custom JPA properties to SharedEntityManagerBean/JpaTransactionManager/JpaInterceptor/JpaTemplate
* added support for custom JPA properties to OpenEntityManagerInViewInterceptor
* PersistenceAnnotationBeanPostProcessor supports @PersistenceContext's "properties", passed into "createEntityManager"
* PersistenceAnnotationBeanPostProcessor does not cache EntityManagerFactory instances 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 HttpSessionBindingListener interface to MockHttpSession

Package org.springframework.remoting
* added service URL check to UrlBasedRemoteAccessor, in the form of an InitializingBean implementation
* refined cache synchronization in (Jndi)RmiClientInterceptor and JaxRpcPortClientInterceptor
* reworked RmiClientInterceptor to throw RemoteLookupFailureException instead of MalformedURLException/RemoteException
* reworked Hessian/BurlapClientInterceptor to throw RemoteLookupFailureException instead of MalformedURLException
* Hessian/BurlapClientInterceptor configure a Hessian/BurlapProxyFactory directly (dropped CauchoRemoteAccessor)
* added "serializerFactory" and "sendCollectionType" properties to HessianClientInterceptor/ProxyFactoryBean
* added "serializerFactory" property to HessianServiceExporter, applied to HessianInput/Output objects
* HessianServiceExporter is compatible with the Hessian 2 protocol (Hessian version 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 "jobFactory" bean property
* SchedulerFactoryBean uses AdaptableJobFactory as default, which also supports Runnables as job class
* added SpringBeanJobFactory as subclass of AdaptableJobFactory, as JobFactory replacement for QuartzJobBean
* JobDetailBean allows any job class to be specified, to allow a JobFactory to adapt 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 like it also sets the volatile flag)

Package org.springframework.scripting
* fixed BshScriptFactory to correctly handle void, null, and primitive return values
* fixed JRubyScriptFactory to handle "toString()" invocations locally on the JRuby object proxy

Package org.springframework.test
* AbstractSpringContextTests calls ConfigurableApplicationContext's "registerShutdownHook()" for each context instance
* factored out concrete loading of a single context from specified config locations to AbstractSingleSpringContextTests
* restricted visibilities and stronger use of final in AbstractDependencyInjectionSpringContextTests

Package org.springframework.transaction
* added "afterCommit" callback to TransactionSynchronization interface
* fixed TransactionAttributeSourceAdvisor to avoid potential NPE in TransactionAttributeSourcePointcut's "hashCode"

Package org.springframework.validation
* added "getPropertyEditorRegistry" method to BindingResult interface, for re-registering 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 FieldError

Package org.springframework.web
* ExpressionEvaluationUtils falls back to Jakarta JSTL if JSP 2.0 ExpressionEvaluator API present but not implemented
* added support for attribute destruction callbacks to RequestAttributes abstraction + 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 subclass of AbstractPointcutAdvisor
* fixed AbstractAdvisorAutoProxyCreator to ignore Advisors for which "getBean" throws a BeanCurrentlyInCreationException
* fixed AnnotationAwareAspectJAutoProxyCreator to explicitly ignore FactoryBeans when looking for aspect beans
* reworked AspectJ auto-proxy creation to avoid the creation of unnecessary proxies
* renamed ScopedObject's "remove" method to "removeFromScope", to avoid conflicts with methods on the target class

Package org.springframework.beans
* added overloaded "setPropertyValues" variant with additional "ignoreInvalidFields" flag to PropertyAccessor
* fixed BeanWrapperImpl to properly catch and wrap conversion failures for map keys/values in TypeMismatchExceptions
* introduced TypeConverter interface, implemented by BeanWrapperImpl, plus separate SimpleTypeConverter implementation
* refined PropertyAccessExceptionsException to show nested details even when wrapped 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 name arrays (in case of ancestor factories)
* redefined BeanFactoryUtils' "countBeans/beanNamesIncludingAncestors" to build on "getBeanNamesOfType(Object.class)"
* reworked InstantiationAwareBeanPostProcessor's "postProcessPropertyValues" method to take a PropertyDescriptor array
* RequiredAnnotationBeanPostProcessor explicitly ignores special setter methods (such as "setBeanName"/"setBeanFactory")
* added "copyConfigurationFrom" method to ConfigurableBeanFactory, allowing to create a factory with same configuration
* exposed "getScope" and "setScope" methods on BeanDefinition interface, allowing a post-processor to override the scope
* DefaultSingletonBeanRegistry disallows the creation (or recreation) of singletons during "destroySingletons()" phase
* fixed AbstractBeanFactory to only invoke BeanPostProcessor for objects returned from FactoryBeans if non-null
* fixed AbstractBeanFactory to throw BeanCurrentlyInCreationException on null from non-fully-initialized FactoryBean
* AbstractBeanFactory's "getType" catches BeanCreationExceptions for a FactoryBean, treating it as "type unknown"
* AbstractBeanFactory catches an exception thrown from a FactoryBean's "getObjectType", treating it as "type unknown"
* AbstractAutowireCapableBeanFactory detects whether it injected raw instances of 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 singleton contained in a non-singleton
* DefaultListableBeanFactory's non-eager lookup by type finds matches for lazy-init beans as long as class is loadable
* added "setAllowEagerClassLoading" method to DefaultListableBeanFactory, to allow for turning off eager class loading
* restored Spring 1.2 compatibility for default-lazy-init="true", with respect to detection of special beans by type
* "idref" tag in XML bean definitions gets turned into a RuntimeBeanNameReference, which gets validated on bean creation
* XML definitions for inner beans receive a default scope based on their containing 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 BeanFactory after a "close()" call
* avoid AbstractRefreshableApplicationContext deadlock in case of BeanFactory access 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 PersistenceExceptionTranslationAdvisor

Package org.springframework.jdbc
* worked around "oracle.sql.DATE" problem on certain Oracle driver versions, extracting it as timestamp when appropriate
* check for ResultSetSupportingSqlParameter superclass instead of SqlOutParameter and SqlReturnResultSet subclasses
* factored out Spring/JtaLobCreatorSynchronization classes from Hibernate AbstractLobType to "jdbc.support.lob" package

Package org.springframework.jms
* introduced CachingDestinationResolver interface, implemented by JndiDestinationResolver (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 client 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 DefaultMessageListenerContainer, for overriding the default caching
* DefaultMessageListenerContainer is able to recover from a broken Connection (both with and without cached Connection)
* DefaultMessageListenerContainer is able to recover from a broken Destination if obtained via JndiDestinationResolver
* DefaultMessageListenerContainer waits until all listener tasks have completed before returning from "destroy"
* added "taskExecutor" property to SimpleMessageListenerContainer, allowing to execute listener in different thread
* added protected "buildListenerArguments" template method to MessageListenerAdapter, allowing for multiple arguments

Package org.springframework.orm
* refined iBATIS SqlMapClientTemplate to allow for nested calls to same SqlMapSession (checking "getCurrentConnection")
* reworked Hibernate JTA synch to expose beforeCompletion exceptions to the caller (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 PersistenceExceptionTranslator interface now
* reworked Hibernate3 and TopLink exception translation to only apply a SQLExceptionTranslator if explicitly specified
* JDO LocalPersistenceManagerFactoryBean implements the PersistenceExceptionTranslator interface now
* DefaultJdoDialect only applies a SQLExceptionTranslator if explicitly specified (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 OpenEntityManagerInViewFilter/Interceptor
* EntityManagerFactoryInfo interface does not extend PersistenceExceptionTranslator anymore (only JpaDialect does)
* SpringPersistenceUnitInfo is public to allow for post-processing in LocalContainerEntityManagerFactoryBean subclass
* added "determinePersistenceUnitInfo/postProcessPersistenceUnitInfo" methods to LocalContainerEntityManagerFactoryBean
* reworked OpenSession/PersistenceManager/EntityManagerInViewInterceptor to build on WebRequestInterceptor abstraction
* dropped PortletOpenSession/PersistenceManager/EntityManagerInViewInterceptor in 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/RmiProxyFactoryBean
* added dedicated "prepare()" method to JndiRmiServiceExporter

Package org.springframework.scheduling
* renamed SchedulingTaskExecutor's "isShortLivedPreferred" method to "prefersShortLivedTasks"

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 "tearDown" 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 timeout in seconds within the annotation

Package org.springframework.util
* optimized "ObjectUtils.nullSafeToString" implementation to return a given String right away

Package org.springframework.validation
* added "ignoreInvalidFields" flag to DataBinder, allowing to ignore inaccessible 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.scope" to "web.context.request"
* added WebRequest abstraction, with ServletWebRequest and PortletWebRequest implementations
* added WebRequestInterceptor interface, for generic request interceptors (independent of Servlet/Portlet)
* added support for WebRequestInterceptors to Servlet/Portlet MVC HandlerMappings (through "interceptors" property)
* renamed PortletBean to GenericPortletBean
* HttpServletBean/GenericPortletBean override "getXXXXletName"/"getXXXXletContext" to return null when no config set yet
* added "defaultLocale" property to CookieLocaleResolver and SessionLocaleResolver, 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 constants 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 beans which get adviced themselves
* moved AbstractAutoProxyCreator's "shouldSkip" check from "isInfrastructureClass" to "postProcessAfterInitialization"
* reworked AbstractAdvisorAutoProxyCreator to avoid fetching of all candidate Advisors on startup
* AbstractAdvisorAutoProxyCreator performs BeanFactory-based prototype cycle check instead of control flow check

Package org.springframework.beans
* factored out SingletonBeanRegistry interface from ConfigurableBeanFactory interface
* factored out DefaultSingletonBeanRegistry base class from AbstractBeanFactory
* added "isCurrentlyInCreation" method to ConfigurableBeanFactory interface
* reworked AbstractBeanFactory to allow for prototype cycle check for current thread
* fixed AbstractBeanFactory's "isBeanNameUsed" to correctly synchronize access to "dependentBeanMap"
* AbstractAutowireCapableBeanFactory creates "depends-on" beans even before resolving a bean's class
* AbstractAutowireCapableBeanFactory does not apply bean post-processors to "synthetic" beans
* AbstractAutowireCapableBeanFactory accepts null values returned from BeanPostProcessors
* added "synthetic" flag to AbstractBeanDefinition, for marking beans as internal infrastructure beans
* XmlBeanDefinitionReader uses given ResourceLoader/ApplicationContext's ClassLoader 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 ApplicationContext (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 for direct access
* adapted PathMatchingResourcePatternResolver to always use the ResourceLoader's ClassLoader
* added "getResourcePatternResolver(ResourceLoader)" utility method to ResourcePatternUtils

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 values 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/persistence.xml" files on the class path
* LocalContainerEntityManagerFactoryBean determines persistence unit root URL based 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 integration with the persistence provider
* JpaTransactionManager throws UnexpectedRollbackException in case of JPA RollbackException thrown from commit
* refined JPA exception translation to throw EmptyResultDataAccessException in case of JPA NoResultException
* refined JPA exception translation to throw IncorrectResultSizeDataAccessException in case of JPA NonUniqueResult
* refined JPA exception translation to throw DataIntegrityViolationException in case of JPA EntityExistsException
* refined JPA exception translation to throw InvalidDataAccessResourceUsageException in case of JPA TransactionRequired
* refined Hib exception translation to throw InvalidDataAccessApiUsageException in case of Hibernate ObjectDeleted
* refined Hib exception translation to throw IncorrectResultSizeDataAccessException in case of Hibernate NonUniqueResult

Package org.springframework.remoting
* JaxRpcPortClientInterceptor/JaxRpcPortProxyFactoryBean allow for direct "customPropertyMap[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 early 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 object 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" methods 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 "WebUtils.exposeForwardRequestAttributes")
* RequestContext's "getContextPath()" always exposes the context path for the originating request now
* added "getQueryString" method to RequestContext, exposing query string for originating 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 (which has been superseded by Hibernate3)
* basic download only contains reference PDF: no HTML variant and API docs anymore (only in -with-dependencies now!)

Package org.springframework.aop
* fixed AspectJAutoProxyCreator to avoid NPE in case of abstract beans without bean class specified

Package org.springframework.beans
* FactoryBeans are allowed to return null values now, with FactoryBeanNotInitializedException to be thrown by themselves
* fixed AbstractBeanFactory's "getType" to avoid NPE in case of a bean definition without bean class
* AbstractBeanFactory uses inverse order of bean instantiation for shutdown even without dependency relationships
* fixed DefaultListableBeanFactory to not call "FactoryBean.getObject()" for prototype 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.support" to "beans.factory.parsing"

Package org.springframework.core
* StaticLabeledEnum offers its "readResolve" method with protected visibility, to kick in for subclasses as well

Package org.springframework.ejb
* fixed AbstractSlsbInvokerInterceptor to reobtain createMethod in case of cacheHome="false"/lookupHomeOnStartup="true"

Package org.springframework.jms
* added "cacheSessions" flag to DefaultMessageListenerContainer, to be turned off 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 effects 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 Sessions to FlushMode.NEVER until closing
* refined HibernateTemplate to never register a Session for deferred close in case of "alwaysUseNewSession"=true
* removed special Session reconnection check for Hibernate 3.1 RC1
* renamed ContainerEntityManagerFactoryBean to "LocalContainerEntityManagerFactoryBean"
* fixed LocalContainerEntityManagerFactoryBean to always look for "META-INF/persistence.xml" in class path by default
* JpaTransactionManager autodetects the JDBC DataSource of the target EntityManagerFactory

Package org.springframework.samples
* added JPA support to PetClinic: EntityManagerClinic and JpaTemplateClinic, with 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 "setSupportedMethods" in subclasses
* FrameworkPortlet now catches all RuntimeException/Errors and rethrows them as PortletException
* PortletContentGenerator response preparation operates on RenderRequest and RenderResponse only
* changed Portlet HandlerInterceptor interface to have explicit callback methods for action/render requests
* Portlet HandlerInterceptorAdapter allows to adapt the specific action/render callback 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 AbstractTemplateView
* 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 BeanFactory
* removed incomplete support for ScopedObject handles and persistent scopes
* removed deprecated AttributesPooling/Prototype/ThreadLocalTargetSourceCreator
* removed unused Class argument from ParameterNameDiscoverer's "getParameterNames(Method)"
* reworked ProxyFactoryBean's "setProxyInterfaces" method from String array to Class array
* reworked ProxyFactoryBean to use the ClassLoader passed in through BeanClassLoaderAware
* factored out AbstractSingletonProxyFactoryBean from TransactionProxyFactoryBean

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)sOfType" into "allowEagerInit"
* introduced BeanClassLoaderAware interface, for passing the factory's class loader to beans that resolve class names
* reworked all FactoryBeans that resolve class names to leverage the BeanClassLoaderAware 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 InstantiationAwareBeanPostProcessor interface
* reworked RequiredBeanFactoryPostProcessor into RequiredAnnotationBeanPostProcessor, properly handling bean inheritance
* added scoping support to core BeanFactory, for creating raw target beans in arbitrary scopes
* added "scope" attribute at bean level to XML bean definition format, superseding singleton="true"/"false"
* renamed XmlBeanDefinitionReader's (Default)XmlBeanDefinitionParser SPI to (Default)BeanDefinitionDocumentReader
* renamed XmlBeanDefinitionParserHelper to BeanDefinitionParserDelegate
* re-introduced Spring 1.2 XmlBeanDefinitionParser SPI for backwards compatibility in case of "parserClass" specified

Package org.springframework.context
* synchronized AbstractApplicationContext's "refresh()" method, for hot refreshing in concurrent environments

Package org.springframework.core
* renamed GenericsHelper to GenericCollectionTypeResolver, more clearly reflecting its actual role
* AnnotationUtils discovers annotations inherited via bridge methods now, through the new BridgeMethodResolver

Package org.springframework.dao
* added generic PersistenceExceptionTranslator mechanism, supported by the JpaDialect abstraction for JPA providers
* added PersistenceExceptionTranslationPostProcessor, for automatic translation to DataAccessExceptions

Package org.springframework.instrument
* introduced class instrumentation support based on standard ClassFileTransformers (used by JPA SPI support)
* introduced LoadTimeWeaver abstraction for instrumentation-aware ClassLoaders plus 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 database product name for DB2
* reworked SimpleJdbcDaoSupport/NamedParameterJdbcDaoSupport initialization to work without afterPropertiesSet as well

Package org.springframework.orm
* Hibernate3 LocalSessionFactoryBean explicitly calls "buildMappings()" to prepare Configuration metadata for subclasses
* fixed JpaTransactionManager to not cause an NPE when the creation of a transactional 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 ContainerEntityManagerFactoryBean with LoadTimeWeaver support
* added JpaVendorAdapter abstraction, with out-of-the-box TopLinkJpaVendorAdapter and HibernateJpaVendorAdapter
* added PersistenceAnnotationPostProcessor, processing EJB3-style @PersistenceUnit 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 AbstractPlatformTransactionManager, 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 fields instead of allowed fields

Package org.springframework.web
* reworked mvc RequestHandler interface into HttpRequestHandler in root web package, to minimize module dependencies
* reworked RequestMethodNotSupportedException into HttpRequestMethodNotSupportedException in root web package
* reworked SessionRequiredException into HttpSessionRequiredException and PortletSessionRequiredException
* added HttpRequestHandlerServlet to "web.context.support" package, for exposing a single HttpRequestHandler bean
* dropped "getCause()" method from NestedServletException, to avoid conflicts with 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" reference
* factored out reusable "prepareBinder" method in BaseCommandController, for easier overriding of "createBinder"
* InternalResourceView exposes Servlet 2.4 forward request attributes even for Servlet 2.3-
* added "getOriginatingRequestUri" method to UrlPathHelper, detecting the Servlet 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 anymore

Package org.springframework.aop
* fixed Cglib2AopProxy to register an explicitly given ClassLoader with the CGLIB Enhancer
* deprecated Commons Attributes based TargetSourceCreators (PoolingAttribute, PrototypeAttribute, ThreadLocalAttribute)
* fixed CustomizableTraceInterceptor to expose the actual invocation time for exception messages
* added "trackAllInvocations" flag to JamonPerformanceMonitorInterceptor, for gathering statistics without logging
* auto-proxying works for objects created by FactoryBeans as well (rather than just on FactoryBean instances themselves)
* BeanNameAutoProxyCreator always proxies exposed objects, with "&beanName" syntax for proxying FactoryBean instances
* renamed "aspectj.autoproxy.AspectJAutoProxyCreator" to "aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"

Package org.springframework.beans
* BeanUtils throws explicit BeanInstantiationException in case of bean instantiation 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 value 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 parameterization in superclass/interface
* BeanWrapperImpl does not register a StringArrayPropertyEditor by default anymore
* fixed BeanWrapperImpl to convert a ManagedProperties instance into a plain Properties instance before applying it
* fixed BeanWrapperImpl to fall back to approximate collection/map type if it cannot 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, for example "\u00F6"
* refined FileEditor to treat absolute file paths as straight files (no ResourceLoader), for Spring 1.2 compatibility
* PropertyPlaceholderConfigurer catches and logs SecurityException on system property access, continuing resolution
* FieldRetrievingFactoryBean is able to access non-public fields as well
* added "propertiesArray" bean property to PropertiesFactoryBean, for merging multiple 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 created by FactoryBeans as well
* BeanPostProcessor's "postProcessAfterInitialization" gets applied after "postProcessBeforeInstantiation" as well
* fixed DefaultListableBeanFactory to not preinstantiate bean definition if explicit singleton object already registered
* added "loadBeanDefinitions(String[] locations)" method to BeanDefinitionReader and AbstractBeanDefinitionReader
* added Requiered annotation and RequiredBeanFactoryPostProcessor, allowing to enforce required bean properties

Package org.springframework.context
* refined AbstractMessageSource to resolve arguments eagerly, for message defined in parent and msg arg defined in child
* added (String[], Class) constructors to ClassPathXmlApplicationContext, allowing 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, through using the cause's "toString()"
* fixed FileSystemResource/UrlResource to retain leading "../" parts in paths, building correct relative paths for them
* ResourceEditor resolves placeholders in resource locations against system environment variables as well

Package org.springframework.dao
* introduced PermissionDeniedDataAccessException, thrown for valid operation that 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 incorrect 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 overhead of double parsing
* improved JdbcTemplate's logging of ignored SQLWarnings, including SQL state and error code in the log output
* refined NativeJdbcExtractorAdapter to retry with DatabaseMetaData Connection if extraction failed (for Hibernate 3.1)
* added NamedParameterJdbcTemplate which provides named parameters support for query and update functionality
* added "allowsUnusedParameters()" and "checkCompiled()" methods to RdbmsOperation, for better customizing in subclasses
* refined StoredProcedure to accept unused entries in given parameter Maps by default
* added named parameters support to SqlQuery/SqlUpdate hierarchy of classes

Package org.springframework.jms
* AbstractMessageListenerContainer prefers SessionAwareMessageListener over MessageListener (if both are implemented)
* added "exceptionListener" property to AbstractMessageListenerContainer, accepting a standard JMS ExceptionListener
* added "handleListenerException" template method to AbstractMessageListenerContainer, by default logging at error level
* fixed DefaultMessageListenerContainer to properly use separate invokers per thread, for actually concurrent Sessions
* fixed ServerSessionMessageListenerContainer(102) to use "createSession(Connection)" 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 for "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 the course of transaction suspension
* removed support for obsolete "EntityManagerFactory.getEntityManager()" method from LocalEntityManagerFactoryBean
* added "entityManagerInterface" property to SharedEntityManagerAdapter, for exposing a vendor-extended interface
* adapted OpenEntityManagerInViewFilter/Interceptor to not specify obsolete PersistenceContextType.EXTENDED anymore
* fixed JpaDaoSupport's "setEntityManager" method to accept an EntityManager instead of an EntityManagerFactory
* removed "getEntityManager()"/"getEntityManagerFactory()" accessor methods from JpaDaoSupport
* removed "allowCreate" flag from JpaTemplate, always allowing creation (analogous to shared EntityManager)
* added "exceptionConversionEnabled" flag to HibernateInterceptor, TopLinkInterceptor, JdoInterceptor, JpaInterceptor

Package org.springframework.remoting
* HTTP invoker and RMI invoker fill the client-side portion of the stack trace into transferred exceptions now
* RmiClientInterceptorUtils throws clearer exception message in case of proxy mismatch (for underlying RMI stubs)
* added "setContentType" configuration method to HttpInvokerServiceExporter and AbstractHttpInvokerRequestExecutor
* built client-side HTTP GZIP response support into SimpleHttpInvokerRequestExecutor/CommonsHttpInvokerRequestExecutor
* JaxRpcPortClientInterceptor synchronizes creation of JAX-RPC Calls, to make dynamic invocations with Axis thread-safe
* refined JaxRpcPortClientInterceptor to only use JAX-RPC port if "portInterface" specified (prefer dynamic invocations)
* added "setCustomPropertyMap" method to JaxRpcPortClientInterceptor/ProxyFactoryBean, accepting String-Object pairs
* added AxisBeanMappingServicePostProcessor to "jaxrpc.support" package, for declarative registration of bean mappings

Package org.springframework.scheduling
* refined Quartz SchedulerFactoryBean to re-register the associated JobDetail when overwriting a JobDetailAwareTrigger
* fixed Quartz SchedulerFactoryBean to handle potential cluster race condition on 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 cannot" message at debug level (not warn)
* TransactionInterceptor logs application exception at error level if commit throws 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 searching 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 BindingResults 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 class name if no filter name is available
* refined FrameworkServlet to log a request handling failure at debug level rather than error level
* refined AbstractRefreshablePortletApplicationContext to take PortletContext from PortletConfig if not explicitly set
* factored out "handleNoSuchRequestHandlingMethod" method in MultiActionController, to be overridden in subclasses
* fixed SimpleMappingExceptionResolver to correctly check the depth of all exception 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 cached view objects
* optimized BeanNameViewResolver to avoid internal throwing and catching of NoSuchBeanDefinitionExceptions
* ExpressionEvaluationManager supports concatenated expressions (e.g. "${var1}text${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 alternative to specifying it in configuration
* Struts ContextLoaderPlugIn ignores "Action.setServlet(ActionServlet)" method when performing a dependency check
* optimized Struts Delegating(Tiles)RequestProcessor to avoid unnecessary NoSuchBeanDefinitionException throw+catch
* added Autowiring(Tiles)RequestProcessor, autowiring created Actions (configurable 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 interfaces from BeanWrapper/BeanWrapperImpl
* BeanWrapperImpl supports PropertyEditors exposed by PropertyDescriptors (typically from BeanInfo classes)
* BeanWrapperImpl passes a null value to a PropertyEditor's "setValue" method, allowing 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 lead 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 convert a null value to an empty Collection
* added "containsLocalBean" method to HierarchicalBeanFactory interface, refactored from AbstractApplicationContext
* fixed AbstractBeanFactory to use canonical bean name (id) for prototype creation, exposing it to BeanPostProcessors
* fixed AbstractBeanFactory to destroy a failed bean completely, including dependent 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 anymore, not even for eager-init singletons
* re-added support for deprecated "class" property to PropertiesBeanDefinitionReader, 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 "messageSource" bean even through an alias

Package org.springframework.core
* added "getRootCause()" method to NestedRuntime/CheckedException, for retrieving 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 different thread (in case of JTA transaction)

Package org.springframework.jms
* reworked DefaultMessageListenerContainer to allow for breaking the receive loop into smaller, schedulable tasks
* DefaultMessageListenerContainer defaults "maxMessagesPerTask" to 1 for short-lived-preferring SchedulingTaskExecutor
* renamed ServerSessionMessageListenerContainer's "maxMessages" to "maxMessagesPerTask", for consistency

Package org.springframework.jmx
* fixed MBeanServerConnectionFactoryBean to avoid potential initialization of unused 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 paths that end with a slash
* MockHttpServletResponse detects charset specification in "setContentType" and sets character encoding accordingly
* fixed AbstractTransactionalSpringContextTests's "startNewTransaction" to initialize "complete" to "!defaultRollback"

Package org.springframework.orm
* Hibernate LocalSessionFactoryBean offers protected "executeSchemaStatement" method for overriding the failure handling
* fixed JpaTemplate's "findByNamedQuery" to correctly apply parameter indexes starting from 1

Package org.springframework.scheduling
* added SchedulingTaskExecutor interface, letting an executor declare a preference 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 (analogous to CommonJ's "isDaemon")
* CommonJ WorkManagerTaskExecutor/DelegatingWork exposes SchedulingAwareRunnable's "isLongLived" flag appropriately
* fixed TimerFactoryBean to properly initialize even without "scheduledTimerTasks" 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" on Borland and Sun application servers

Package org.springframework.util
* fixed ResponseTimeMonitorImpl to properly synchronize access to its instance variables in a multithreading environment

Package org.springframework.validation
* added further accessors to Errors interface: hasFieldErrors(), getFieldErrorCount(), getFieldErrors(), getFieldError()
* introduced BindingResult interface, as extension of the Errors interface
* reworked BindException to implement the BindingResult interface, wrapping an existing BindingResult
* added BeanPropertyBindingResult and SimpleMapBindingResult implementations, based 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 actually start with the package name
* ContextLoader throws IllegalStateException if there is already a root application context present
* fixed DispatcherServlet to keep and restore previous thread-bound LocaleContext and RequestAttributes
* added overloaded "getModelAndView" method with HttpServletRequest argument to SimpleMappingExceptionResolver
* added "cookieSecure" property to CookieGenerator, indicating that cookies should only be sent using HTTPS connections
* added schema support for configuring a SimpleUrlHandlerMapping using spring-web.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 initializing the DataBinder accordingly
* added overloaded "onFormChange" method with BindException argument to SimpleFormController
* MultiActionController does not consider "handleRequest" itself as handler method (to avoid potential stack overflow)
* added full JSP 1.2 form tag library in package "web.servlet.tags", complementing the existing base tag library
* upgraded VelocityToolboxView to use Velocity Tools 1.2+ API and avoid using deprecated earlier API
* added VelocityLayoutViewResolver, a convenience subclass of VelocityViewResolver 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 run 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 methods
* added "autodetectInterfaces" to ProxyFactoryBean, for TransactionProxyFactoryBean style behavior (is the default now!)
* refined ProxyFactoryBean to lazily initialize a singleton proxy, to let "getObjectType()" expose the type beforehand
* improved performance of IntroductionInfoSupport by faster determination of whether method is on introduced interface
* refined ThreadLocalTargetSource's synchronization to guarantee thread-safe destruction 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 refreshed 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 MethodInvocationProceedingJoinPoint

Package org.springframework.beans
* fixed PropertyAccessorUtils's "getLastNestedPropertySeparatorIndex" to correctly 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-converting to their element/key/value type
* added support for constructor arguments with generic Collections/Maps, auto-converting to their element/key/value type
* added "merge" attribute to "list"/"set/"map"/"props", for merging of collection values across parent/child definitions
* added "default-merge" attribute to "beans" element to allow control of collection merging at the file level
* changed FileEditor's behavior to consider input text as standard Spring resource location (instead of plain filename)
* added "postProcessAfterInstantiation" method to InstantiationAwareBeanPostProcessor
* fixed AbstractBeanFactory to correctly delegate to parent BeanFactory from "isFactoryBean"
* optimized AbstractBeanFactory to avoid internal NoSuchBeanDefinitionException throw+catch as far as possible
* AbstractBeanFactory caches merged bean definitions, for efficient prototype child creation and CGLIB class reuse
* reworked AbstractBeanFactory's currently-in-creation check to log debug message when unfinished singleton is returned
* added "allowCircularReferences" flag to AbstractAutowireCapableBeanFactory, to disallow circular references completely
* DefaultListableBeanFactory's "getBeansOfType" logs BeanCurrentlyInCreationException message instead of stacktrace
* refined DefaultXmlBeanDefinitionParser to explicity check for empty ref name and throw meaningful exception
* DefaultXmlBeanDefinitionParser wraps unexpected exceptions in BeanDefinitionStoreException with context info
* inner bean parsing/instantiation exceptions get wrapped in outer exceptions with appropriate context information
* moved general bean wiring support from "beans.factory.aspectj" to "beans.factory.wiring"/"beans.factory.annotation"
* renamed AspectJ AnnotationBeanConfigurer to AnnotationBeanConfigurerAspect
* deprecated BeanFactoryBootstrap in favor of using a BeanFactoryLocator or a custom bootstrap class

Package org.springframework.context
* refined AbstractApplicationContext to never register more than one JVM shutdown 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 NestedCheckedException-style root cause handling
* refined AbstractResource to work around "FilterInputStream.close()" NPE, simply 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 Resource array (rather than just one pattern)
* split previous AnnotationUtils delegatetetetete into core.annotation.AnnotationUtils and beans.annotation.AnnotationBeanUtils

Package org.springframework.jdbc
* DataSourceTransactionManager only attempts to release Connection if not pre-bound (to avoid inappropriate log message)
* TransactionAwareDataSourceProxy works correctly in combination with JdbcTemplate and transaction suspend/resume now
* fixed SingleColumnRowMapper to explicitly check "ResultSet.wasNull()" after "getInt"/"getLong"/"getFloat" etc
* turned visibility of "org.springframework.jdbc.core.StatementCreatorUtils" to package-protected
* removed ResultReader interface (sub-interface of RowCallbackHandler): use RowMapper instead
* reworked RowMapperResultReader adapter into RowMapperResultSetExtractor
* reworked ResultSetSupportingSqlParameter to expose a RowMapper directly through a "getRowMapper()" method
* reworked SqlQuery and subclasses to work with a RowMapper instead of a ResultReader -> "newRowMapper" template method
* fixed BatchSqlUpdate's constructor that takes a "batchSize" argument to correctly 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 BeanDefinitionRegistry 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 MockServletContext respectively MockPortletContext
* added "set/removeParameter" methods to MockHttpServletRequest, allowing to replace/remove existing parameters
* added alternative MockPortalContext constructor that accepts custom PortletMode and WindowState lists
* reworked MockActionResponse and MockPortletURL to check against list of supported PortletModes/WindowStates

Package org.springframework.orm
* SqlMapClientTemplate always works with SqlMapSession and provided Connection to enable proper batching in all cases
* added "configLocations" property to LocalSessionFactoryBean for Hibernate3, allowing to load multiple config files
* LocalSessionFactoryBean supports cache regions specified through "entity/collectionCacheStrategies" (on Hibernate 3.1)
* LocalSessionFactoryBean supports multiple event listeners per type through "eventListeners" (on Hibernate 3.1)
* added optional SpringSessionContext for Hibernate 3.1, to plug Spring into "getCurrentSession()" 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, corresponding to JPOX 1.1.0-beta-6)
* added full support for Java Persistence API 1.0 (JPA) Public Final Draft, in package "org.springframework.orm.jpa"

Package org.springframework.samples
* updated "views.properties" files in all sample applications to use "(class)" and "(parent)"
* renamed PetClinic's "Entity" base class to "BaseEntity", to avoid name collision 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 back to plain JobDataMap on Quartz 1.4

Package org.springframework.scripting
* introduced scripting package based on ScriptFactory and ScriptSource abstractions
* added support for BeanShell, Groovy and JRuby scripted objects

Package org.springframework.test
* fixed AbstractDependencyInjectionSpringContextTests's "populateProtectedVariables" to avoid incorrect warnings
* added "startNewTransaction()" method to AbstractTransactionalSpringContextTests

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 state
* marked AnnotationTransactionAttributeSource as Serializable

Package org.springframework.ui
* added ModelMap, providing "addObject" methods that auto-generate model attribute 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 of thread context ClassLoader only
* fixed "StringUtils.delimitedListToStringArray" to properly handle an empty String as delimiter
* refined StopWatch to not add new lines for "shortSummary()" but rather only for "prettyPrint()"
* fixed ConcurrencyThrottleSupport to serialize all relevant state

Package org.springframework.validation
* DataBinder registers suppressed fields in BindException, which offers a "getSuppressedFields()" accessor now

Package org.springframework.web
* "contextConfigLocation" params in "web.xml" support "${...}" style placeholders for system properties
* deprecated BindUtils and BindInitializer in package "web.bind" in favor of direct 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 NestedServletException, for Portlet reuse
* upgraded CommonsMultipartResolver to Commons FileUpload 1.1 (not using deprecated FileUpload 1.0 API anymore)
* added PortletMultipartResolver abstraction, with CommonsPortletMultipartResolver 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/SessionScopeMap with portlets
* refactored RequestHandledEvent into RequestHandledEvent base class and ServletRequestHandledEvent subclass
* renamed FrameworkPortlet's RequestHandledEvent to PortletRequestHandledEvent, a subclass of RequestHandledEvent
* PortletBean ignores init-params that do not match bean properties, analogous to HttpServletBean
* DispatcherServlet does not log handler exceptions at warn level anymore but rather 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 ModelMap's conventional attribute names
* added HttpSessionMutexListener and "WebUtils.getSessionMutex", used by AbstractController'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"/"clearAllRenderParameters" into PortletUtils methods
* added "propertyEditorRegistrars" property to BaseCommandController, for applying PropertyEditorRegistrars
* added "propertyEditorRegistrars" property to Portlet BaseCommandController, for applying PropertyEditorRegistrars
* added "bindingErrorProcessor" property to Portlet BaseCommandController, for configurable BindingErrorProcessor
* turned AbstractCommandController's and AbstractFormController's "handleRequestInternal" methods non-final
* refactored AbstractFormController's session form check into one single place, throwing SessionRequiredException
* reworked MultiActionController's "bind" and "createBinder" to work on HttpServletRequest instead of ServletRequest
* deprecated MultiActionController's "initBinder(ServletRequest...)" in favor of "initBinder(HttpServletRequest...)"
* refined ParameterMethodNameResolver to treat an empty method name as no name at 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 enforce 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 automatic 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, upgrade to iBATIS SQL Maps 2.0/2.1!)
* added explicit support for Hibernate 3.1 while remaining compatible with Hibernate 3.0 (as far as possible)
* factored out "spring-jdo", "spring-hibernate2/3", "spring-toplink", "spring-ojb" jars (not in "spring.jar" anymore!)
* distributed first AspectJ aspects (for transaction management and DI of objects 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 style and the AspectJ 5 annotation style
* added @Configurable annotation plus BeanConfigurer aspect to allow injection on 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 found
* fixed BeanWrapperImpl to pass its "extractOldValueForEditor" setting on to nested BeanWrappers
* refined BeanWrapperImpl to perform the accessible checking for read/write methods before every invocation
* changed "MutablePropertyValues.addPropertyValue(String, Object)" to return 'this'
* removed deprecated "getBeanDefinitionNames(type)" method from ListableBeanFactory 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 handlers
* added UtilNamespaceHandler to support dedicated "util:*" XML tags

Package org.springframework.core
* introduced TaskExecutor abstraction, as strategy interface for the execution of Runnables
* added SyncTaskExecutor and SimpleAsyncTaskExecutor as simple default implementations of the TaskExecutor interface

Package org.springframework.context
* added "getAutowireCapableBeanFactory()" accessor to ApplicationContext interface, for direct access without casting
* refined AbstractApplicationContext's lifecycle behavior to properly ignore repeated "close()" calls
* moved DefaultListableBeanFactory's cleanup on "preInstantiateSingletons()" behavior to AbstractApplicationContext
* reworked SimpleApplicationEventMulticaster to delegate to a TaskExecutor, using a SyncTaskExecutor as default

Package org.springframework.dao
* introduced EmptyResultDataAccessException as specific subclass of IncorrectResultSizeDataAccessException

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 Connection hasn't been used since resume
* fixed JdbcTemplate to extract the JDBC Connection for CallableStatementCreators if a NativeJdbcExtractor has been set
* factored out protected "getColumnMapRowMapper" and "getSingleColumnRowMapper" hooks within JdbcTemplate
* SingleColumnRowMapper throws specific IncorrectResultSetColumnCountException in case of invalid column count
* SingleColumnRowMapper explicitly calls "ResultSet.getBigDecimal()" if the required 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 JMS Message if content type is unknown
* added DefaultMessageListenerContainer mechanism for async message reception via the plain JMS MessageConsumer API
* added SimpleMessageListenerContainer mechanism for async message reception via the plain JMS MessageListener API
* added ServerSessionMessageListenerContainer mechanism for async message reception 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 MBeanExporter 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 metadata
* added NotificationPublisher(Aware) to support publication of JMX Notifications from Spring-managed beans
* added MBeanExporter option to have Spring extend ObjectNames to ensure they are unique per-instance
* added MBeanExporter option to have Spring expose the ClassLoader of the managed 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 rollback, to avoid illegal state exception
* HibernateTransactionManager autodetects Hibernate 3.1 to support its native transaction timeout
* removed "save" operations with explicit id argument from HibernateTemplate (following Hibernate 3.1's removal)
* upgraded FilterDefinitionFactoryBean to Hibernate 3.1 (which changed its FilterDefinition 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.close()", for potential schema export

Package org.springframework.remoting
* RmiServiceExporter performs explicit RMI unexport if binding to the registry failed, to avoid dangling exports
* JaxRpcPortClientInterceptor/ProxyFactoryBean apply given JaxRpcServicePostProcessors to existing JAX-RPC Service too
* HttpInvokerServiceExporter, HessianServiceExporter and BurlapServiceExporter implement Handler instead of Controller
* HttpInvokerRequestExecutor is allowed to throw any Exception, not just IOException and ClassNotFoundException

Package org.springframework.scheduling
* TimerFactoryBean creates a non-daemon Timer by default, to let running tasks finish 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 Quartz's default thread pool
* added SimpleThreadPoolTaskExecutor for Quartz, allowing to define Quartz's default 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 through 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 ModelAndView objects

Package org.springframework.transaction
* JtaTransactionManager only invokes rollback if transaction is still active (some 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 default path separator "/"
* fixed AntPathMatcher to correctly treat "*" right after separator, i.e. to accept path "/test/" for pattern "/test/*"
* WeakReferenceMonitor uses a daemon thread, to avoid a hanging thread even if weak 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 ServletException (for nicer root cause handling)
* WebApplicationContext interface does not extend ThemeSource anymore; implementing ThemeSource is now optional
* introduced ServletConfigAware interface, for getting access to a Framework/DispatcherServlet's ServletConfig object
* SimpleServletPostProcessor configures Servlets with DispatcherServlet's ServletConfig by default (can be turned off)
* introduced Handler interface as alternative to Controller, with no ModelAndView 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 Locale if no LocaleResolver found
* FixedLocaleResolver returns the JVM's default Locale if no explicit default Locale specified
* VelocityView converts Velocity's MethodInvocationException to a Spring NestedServletException with original root cause

