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


Changes in version 1.2.9 (7.3.2007)
-----------------------------------

General
* many javadoc refinements and clarifications
* declared all internal ThreadLocal variables as final (to avoid class reloading issues)
* overall startup/shutdown logging at info level is less verbose (activate debug log level for more config details)

Package org.springframework.aop
* reworked JdkDynamicAopProxy's "Method.setAccessible" handling to avoid unnecessary calls
* Cglib2AopProxy throws AopConfigException instead of AspectException, for better root cause handling
* CGLIB proxies handle "hashCode" calls according to their "equals" behavior, analogous to JDK dynamic proxies
* HashMapCachingAdvisorChainFactory uses synchronized access to its method cache Map
* exposed "indexOf(Advice)" method on Advised interface
* revised ProxyConfig/AdvisedSupport's "toString()" output
* RegexpMethodPointcutAdvisor references ORO classes indirectly, to avoid eager loading of ORO on Solaris JDK 1.6
* revised SingletonTargetSource's and AbstractBeanFactoryBasedTargetSource's "toString()" output
* HotSwappableTargetSource's "hashCode" implementation returns a constant value even if the target object changes
* AbstractAutoProxyCreator considers all Advices (not just MethodInterceptors) as infrastructure classes to ignore

Package org.springframework.beans
* fixed BeanWrapperImpl's "toString()" output in case of no wrapped object set
* Number objects (as property or argument values) are automatically coerced into the target Number type (if necessary)
* refined PropertyAccessExceptionsException to show nested details even when wrapped in a standard JDK exception
* deprecated BeanUtils's "canonicalName" in favor of PropertyAccessorUtils's "canonicalPropertyName"
* ConfigurableBeanFactory's "setParentBeanFactory" throws IllegalStateException if already associated with a parent
* UnsatisfiedDependencyException message for multiple matches mentions the names of all matching beans
* AbstractBeanFactory 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
* AbstractBeanFactory supports alias chaining, with an alias registered for a bean name that is itself an alias
* fixed AbstractBeanFactory to accept re-registration of alias for same bean name (-> bean definition overriding)
* AbstractAutowireCapableBeanFactory creates "depends-on" beans even before "postProcessBeforeInstantiation"
* AbstractAutowireCapableBeanFactory does not trigger "toString()" call on argument for UnsatisfiedDependencyException
* fixed method overrides check to accept methods declared on interfaces as well
* fixed PropertyPlaceholderConfigurer to throw a BeanDefinitionStoreException in case of any circular reference
* ResourceEntityResolver catches any kind of Exception in system root URL check (in particular AccessControlException)
* DefaultXmlBeanDefinitionParser trims whitespace from "class" attributes in XML bean definitions
* removed default for "abstract"/"singleton" attributes in "spring-beans.dtd", for 2.0-style inheritance for inner beans

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

Package org.springframework.core
* fixed JdkVersion to properly detect JDK 1.6/1.7 (Java 6/7) as higher than 1.5 (Java 5)
* fixed SpringVersion to return null if the package is not determinable because of ClassLoader restrictions
* fixed PathMatchingResourcePatternResolver to prevent eternal recursion in case of invalid prefix with pattern symbols
* PathMatchingResourcePatternResolver ignores classpath roots that cannot be resolved as jar or in file system
* PathMatchingResourcePatternResolver properly handles jar file roots returned by the ClassLoader (e.g. on Resin)
* ResourceArrayPropertyEditor always preserves order of resource entries, even on JDK 1.3 without Commons Collections

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

Package org.springframework.ejb
* fixed AbstractSlsbInvokerInterceptor to reobtain createMethod in case of cacheHome="false"/lookupHomeOnStartup="true"
* LocalSlsbInvokerInterceptor throws AspectException with proper exception message in case of EJB CreateException
* OC4J's "com.evermind.server.rmi.RMIConnectionException" gets detected as Remote EJB (RMI) connect failure as well

Package org.springframework.jca
* SingleConnectionFactory's Connection proxy implements "equals" and "hashCode" based on proxy equality

Package org.springframework.jdbc
* synchronized SQLErrorCodesFactory's access to the DataSource cache
* 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
* worked around "oracle.sql.DATE" problem on certain Oracle driver versions, extracting it as timestamp when appropriate
* RowMapperResultSetExtractor always uses ArrayList, even in case of unknown number of rows expected
* JdbcTemplate logs all warnings in case of "ignoreWarnings"=true, not just the first warning in the chain
* JdbcTemplate logs SQLWarnings at debug instead of warn level, to avoid repeated warn logs for acceptable conditions
* JdbcTemplate uses "PreparedStatement.setObject(index, null)" for null values with unknown SQL type on Informix
* JdbcTemplate by default uses "PreparedStatement.setString" for any CharSequence (including String and StringBuilder)
* JdbcTemplate does not check static SQL for bind parameters anymore, to avoid overhead of double parsing
* 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
* SingleConnectionFactory's Connection proxy implements "equals" and "hashCode" based on proxy equality
* reimplemented JMSException translation to handle subclasses of standard JMSExceptions in a specific fashion as well

Package org.springframework.jmx
* MBeanExporter only logs a warning (no error) when an MBean does not exist anymore when trying to unregister
* MBeanExporter's MBean autodetection properly registers multiple beans even if their instances as equal
* 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.orm
* iBATIS support works correctly with "useTransactionAwareDataSource" and JTA transaction resume with subsequent access
* added overloaded query/insert/update/delete operations without parameter object to SqlMapClientOperations/Template
* LocalPersistenceManagerFactoryBean and JdoTemplate perform full exception translation even for reflective calls
* removed warning for read-only from JdoTransactionManager, since a vendor dialect may support it
* 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+)
* Hibernate3 LocalSessionFactoryBean registers filter definitions before loading any mapping files
* added "flushMode" init parameter to Hibernate3 OpenSessionInViewFilter (supporting "AUTO" etc as value)
* reworked Hibernate JTA transaction synchronization to expose "beforeCompletion" exceptions to the caller
* Hibernate JTA transaction synchronization does not call "setRollbackOnly" on WebLogic, to preserve the root cause
* reworked Hibernate session synchronization to properly work with WebSphereExtendedJTATransactionLookup on WAS 6.0/6.1
* removed special Session reconnection check for Hibernate 3.1 RC1

Package org.springframework.remoting
* Burlap/Hessian/Rmi/JndiRmiClientInterceptor consistently throw RemoteProxyFailureException instead of AspectException
* RmiServiceExporter logs description of actual registry instead of port (to properly handle passed-in "registry")
* added public "getHost()" and "getPort()" accessors to RmiRegistryFactoryBean

Package org.springframework.samples
* updated PetClinic's HSQLPlatformWithNativeSequence for TopLink 10.1.3 GA (requires 10.1.3 GA or later now)

Package org.springframework.scheduling
* Quartz SchedulerFactoryBean uses given "nonTransactionalDataSource" as default DataSource if no "dataSource" specified
* MethodInvokingJobDetailFactoryBean always creates durable JobDetails (just like it also sets the volatile flag)
* added "jobListenerNames" bean property to MethodInvokingJobDetailFactoryBean

Package org.springframework.test
* AbstractTransactionalSpringContextTests properly ends a started transaction early if "onSetupInTransaction" fails
* AbstractTransactionalSpringContextTests only tries to end transaction on "tearDown" if the transaction is still active
* AbstractTransactionalSpringContextTests invokes "onTearDownAfterTransaction" even for a manually completed transaction

Package org.springframework.transaction
* active transaction synchronization gets suspended when going from SUPPORTS/NOT_SUPPORTED into REQUIRED/REQUIRES_NEW
* AbstractPlatformTransactionManager marks an existing transaction as rollback-only even in case of a commit exception
* AbstractPlatformTransactionManager properly resumes all synchronizations even after suspend or inner begin failure
* AbstractPlatformTransactionManager logs full transaction definition when creating a new transaction
* AbstractPlatformTransactionManager exposes "actualTransactionActive" flag for a newly synchronized existing tx as well
* JtaTransactionManager explicitly only calls "UserTransaction.setRollbackOnly()" if the transaction is still active
* JtaTransactionManager's "doRegisterAfterCompletionWithJtaTransaction" avoids NPE if no current JTA transaction active
* fixed AbstractFallbackTransactionAttributeSource to synchronize get/put calls on its attribute cache
* TransactionAttributeEditor does not accept transaction attributes with invalid whitespace anymore
* added "timeout" attribute to Transactional annotation, allowing to specify a timeout in seconds within the annotation

Package org.springframework.util
* ClassUtils falls back to the system class loader if the thread context class loader is inaccessible
* added "containsWhitespace", "trimAllWhitespace", "concatenateStringArrays" and "mergeStringArrays" to StringUtils
* added "contains", "arrayToList", "mergePropertiesIntoMap", "containsAny", "findFirstMatch" to CollectionUtils

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
* added public "getPropertyEditorRegistry()" method to BindException, for re-registering custom editors
* DataBinder matches all field names using their canonical name (for required and allowed checks)
* fixed BindUtils to not call "ValidatorUtils.invokeValidator" if no Validator given

Package org.springframework.web
* clarified MultipartFile constract details
* CharacterEncodingFilter only applies its encoding if actually specified (non-null)
* WebDataBinder explicitly suppresses field marker prefix values in case of "ignoreUnknownFields" switched off
* reworked the 'default value for missing parameter' check in RequestUtils to be as efficient as possible
* HttpServletBean overrides "getServletName"/"getServletContext" to return null when no config set yet
* DispatcherServlet logs its page-not-found warnings with the actual lookup URL even for import requests
* added "threadContextInheritable" property to DispatcherServlet, for turning off locale exposure to child threads
* added "cookieSecure" property to CookieGenerator, indicating that cookies should only be sent using HTTPS connections
* added "defaultLocale" property to CookieLocaleResolver and SessionLocaleResolver, for fallback to an explicit locale
* 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
* JSP MessageTag detects a single expression argument that resolves to an array and processes it as arguments array
* FreeMarkerConfigurer always registers ClassTemplateLoader for its own package (rather than the package of a subclass)
* added "boolean useWriter()" method to AbstractXsltView, allowing to prefer Writer access over OutputStream access
* deprecated XSLT view FormatHelper


Changes in version 1.2.8 (7.5.2006)
-----------------------------------

General:
* included "tiger" source tree in source build (spring-src.zip)

Package org.springframework.aop
* fixed Cglib2AopProxy to register an explicitly given ClassLoader with the CGLIB Enhancer
* fixed CustomizableTraceInterceptor to expose the actual invocation time for exception messages
* added "trackAllInvocations" flag to JamonPerformanceMonitorInterceptor, for gathering statistics without logging

Package org.springframework.beans
* BeanUtils throws explicit BeanInstantiationException in case of bean instantiation failure
* fixed BeanWrapperImpl to convert a null input for an array type to a null value rather than an array with null element
* changed MutablePropertyValues's "addPropertyValue" signature to void, to remain binary compatible with Spring <=1.2.6
* 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"
* 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
* fixed DefaultListableBeanFactory to not preinstantiate bean definition if explicit singleton object already registered
* added "loadBeanDefinitions(String[] locations)" method to BeanDefinitionReader and AbstractBeanDefinitionReader

Package org.springframework.context
* refined AbstractMessageSource to resolve arguments eagerly, for message defined in parent and msg arg defined in child

Package org.springframework.core
* 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

Package org.springframework.jdbc
* added further default SQL error codes for DB2 and HSQLDB
* refined NativeJdbcExtractorAdapter to retry with DatabaseMetaData Connection if extraction failed (for Hibernate 3.1)
* turned JdbcTemplate's "query(PreparedStatementCreator,PreparedStatementSetter,ResultSetExtractor rse)" method public
* improved JdbcTemplate's logging of ignored SQLWarnings, including SQL state and error code in the log output
* JdbcTemplate's "queryForObject"/"queryForInt"/etc methods correctly detect incorrect result sizes even for null values
* added "allowsUnusedParameters()" and "checkCompiled()" methods to RdbmsOperation, for better customizing in subclasses
* refined StoredProcedure to accept unused entries in given parameter Maps by default

Package org.springframework.jndi
* added "defaultObject" property to JndiObjectFactoryBean, allowing to fall back to default object if JNDI lookup fails

Package org.springframework.mail
* refined JavaMailSenderImpl to avoid "Session.getInstance(Properties)" call, 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
* refined JDO PersistenceManagerFactoryUtils to explicitly suspend pre-bound PM in the course of transaction suspension
* fixed LocalSessionFactoryBean's "updateDatabaseSchema" to declare the correct exception (DataAccessException)
* fixed BlobStringType for Hibernate2/3 to correctly handle SQL NULL

Package org.springframework.remoting
* RmiClientInterceptorUtils throws clearer exception message in case of proxy mismatch (for underlying RMI stubs)
* JaxRpcPortClientInterceptor synchronizes creation of JAX-RPC Calls, to make dynamic invocations with Axis thread-safe

Package org.springframework.scheduling
* fixed TimerFactoryBean to properly initialize even without "scheduledTimerTasks" configured
* 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.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
* fixed CollectionsUtils's "hasUniqueObject" to correctly handle null values

Package org.springframework.validation
* fixed ValidationUtils's "invokeValidator" to work correctly even in case of a null reference as object to be validated

Package org.springframework.web
* dropped "getCause()" method from NestedServletException, to avoid conflicts with JDK-1.4-based ServletException class
* ContextLoader throws IllegalStateException if there is already a root application context present
* 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
* fixed CommonsMultipartResolver to go through the "newFileUpload" template method for any FileUpload instance
* refined FrameworkServlet to log a request handling failure at debug level rather than error level
* added "propertyEditorRegistrar" bean property to BaseCommandController, as convenience option for a single registrar
* 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
* fixed SimpleMappingExceptionResolver to use local "exceptionMappings" reference
* 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
* "javaScriptEscape" feature of Spring tags correctly escapes "</script>" inside a literal value
* 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


Changes in version 1.2.7 (27.2.2006)
------------------------------------

Package org.springframework.aop
* added "autodetectInterfaces" property to ProxyFactoryBean, for TransactionProxyFactoryBean-style interface detection
* AbstractBeanFactoryBasedTargetSource offers explicit "setTargetClass" method, else determines target class on demand
* refined ThreadLocalTargetSource's synchronization to guarantee thread-safe destruction on shutdown
* deprecated AbstractLazyInitTargetSource in favor of AbstractLazyCreationTargetSource
* added "hideProxyClassNames" property to AbstractTraceInterceptor, to log with target class instead of proxy class
* deprecated AbstractPerformanceMonitorInterceptor in favor of AbstractMonitoringInterceptor
* fixed DebugInterceptor to properly synchronize access to its count field in a multithreading environment

Package org.springframework.beans
* 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
* 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
* BeanWrapperImpl passes a null value to a PropertyEditor's "setValue" method, allowing for conversion of null values
* added "nullAsEmptyCollection" flag to CustomCollectionEditor, allowing to convert a null value to an empty Collection
* 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
* fixed ArgumentConvertingMethodInvoker to perform conversion attempts on a copy of the argument array (not the source)
* added "containsLocalBean" method to HierarchicalBeanFactory interface, refactored from AbstractApplicationContext
* fixed AbstractBeanFactory to allow child bean definitions to refer to a parent via its alias name
* fixed AbstractBeanFactory to correctly delegate to parent BeanFactory from "isFactoryBean"
* optimized AbstractBeanFactory to avoid internal NoSuchBeanDefinitionException throw+catch as far as possible
* reworked AbstractBeanFactory's currently-in-creation check to log debug message when unfinished singleton is returned
* 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)
* added "allowCircularReferences" flag to AbstractAutowireCapableBeanFactory, to disallow circular references completely
* DefaultListableBeanFactory's "getBeansOfType" logs BeanCurrentlyInCreationException message instead of stacktrace
* 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
* 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

Package org.springframework.core
* refined Jdk13ControlFlow to be compatible with GNU ClassPath (whose stacktrace has a whitespace after the method name)
* added workaround for "FilterInputStream.close()" NPE to AbstractResource, 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)

Package org.springframework.context
* AbstractApplicationContext discovers its context MessageSource as "messageSource" bean even through an alias

Package org.springframework.jdbc
* added further default SQL error codes for MS SQL, MySQL, and Oracle
* 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
* refined DataSourceUtils to expect an "afterCompletion" callback from a different thread (in case of JTA transaction)
* 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 JdbcTemplate to extract the JDBC Connection for CallableStatementCreators if a NativeJdbcExtractor has been set
* factored out protected "getColumnMapRowMapper" and "getSingleColumnRowMapper" hooks within JdbcTemplate
* SingleColumnRowMapper explicitly calls "ResultSet.getBigDecimal()" if the required type is BigDecimal
* fixed SingleColumnRowMapper to explicitly check "ResultSet.wasNull()" after "getInt"/"getLong"/"getFloat" etc
* 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

Package org.springframework.jmx
* fixed MBeanServerConnectionFactoryBean to avoid potential initialization of unused JMX Connector on shutdown
* 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" configurable in MockServletContext
* MockServletContext's "getResourcePaths" correctly resolves directories as paths that end with a slash
* added "set/removeParameter" methods to MockHttpServletRequest, allowing to replace/remove existing parameters
* MockHttpServletResponse detects charset specification in "setContentType" and sets character encoding accordingly

Package org.springframework.orm
* SqlMapClientTemplate always works with SqlMapSession and provided Connection to enable proper batching in all cases
* Hibernate LocalSessionFactoryBean exposes its DataSource on "SessionFactory.close()", for potential schema export
* Hibernate LocalSessionFactoryBean offers protected "executeSchemaStatement" method for overriding the failure handling
* added "configLocations" property to LocalSessionFactoryBean for Hibernate3, allowing to load multiple config files
* 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 support to be compatible with JPOX JDO 2.0 API snapshot-9 (corresponding to JDO 2.0 final draft)
* JdoTransactionManager does explicit "isActive()" check before attempting a rollback, to avoid illegal state exception

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

Package org.springframework.samples
* updated "views.properties" files in all sample applications to use "(class)" and "(parent)"
* marked JPetStore's OrderForm, AccountForm and UserSession as Serializable

Package org.springframework.scheduling
* added support for Quartz 1.5's merged JobDataMap to QuartzJobBean, falling back to plain JobDataMap on Quartz 1.4

Package org.springframework.test
* added overloaded constructors that take a JUnit TestCase name to all of the provided TestCase subclasses
* fixed AbstractDependencyInjectionSpringContextTests's "populateProtectedVariables" to avoid incorrect warnings
* added "startNewTransaction()" method to AbstractTransactionalSpringContextTests

Package org.springframework.transaction
* fixed AbstractPlatformTransactionManager to serialize all relevant state
* refined AbstractPlatformTransactionManager to suspend synchronizations before the actual transaction (not after)
* JtaTransactionManager autodetects JNDI location "java:pm/TransactionManager" on Borland and Sun application servers
* JtaTransactionManager only invokes rollback if transaction is still active (some JTA providers eagerly terminate)
* marked AnnotationTransactionAttributeSource as Serializable

Package org.springframework.ui
* added "defaultEncoding" bean property to FreeMarkerConfigurationFactory(Bean), inherited by FreeMarkerConfigurer

Package org.springframework.util
* added "isNull()" methods to Assert class
* ClassUtils's "forName(String)" method uses "getDefaultClassLoader()" instead of thread context ClassLoader only
* fixed "StringUtils.delimitedListToStringArray" to properly handle an empty String as delimiter
* 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
* refined StopWatch to not add new lines for "shortSummary()" but rather only for "prettyPrint()"
* fixed ConcurrencyThrottleSupport to serialize all relevant state
* fixed ResponseTimeMonitorImpl to properly synchronize access to its instance variables in a multithreading environment

Package org.springframework.web
* used NestedServletException wherever a root cause gets wrapped by a ServletException (for nicer root cause handling)
* "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
* fixed DispatcherServlet to keep and restore previous thread-bound LocaleContext
* added "currentFormObject" template method to AbstractFormController, for post-processing of a session form object
* FixedLocaleResolver returns the JVM's default Locale if no explicit default Locale specified
* added HttpSessionMutexListener and "WebUtils.getSessionMutex", used by AbstractController's "synchronizeOnSession"
* added "FacesContextUtils.getSessionMutex", to make HttpSessionMutexListener's session mutex available to JSF code
* added overloaded "getModelAndView" method with HttpServletRequest argument to SimpleMappingExceptionResolver
* added "propertyEditorRegistrars" property to BaseCommandController, for applying PropertyEditorRegistrars
* turned AbstractCommandController's and AbstractFormController's "handleRequestInternal" methods non-final
* refactored AbstractFormController's session form check into one single place, throwing SessionRequiredException
* added overloaded "onFormChange" method with BindException argument to SimpleFormController
* 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
* VelocityView converts Velocity's MethodInvocationException to a Spring NestedServletException with original root cause
* added VelocityLayoutViewResolver, a convenience subclass of VelocityViewResolver with support for VelocityLayoutView
* added "useSingleModelNameAsRoot" property to AbstractXlstView, allowing to enforce the value of the "root" property
* refined Struts DelegatingActionProxy and Delegating(Tiles)RequestProcessor to fall back to root WebApplicationContext
* added DelegatingNavigationHandlerProxy and DelegatingPhaseListenerAdapter to JSF support (used by Spring Web Flow)


Changes in version 1.2.6 (14.11.2005)
-------------------------------------

Package org.springframework.aop
* fixed AbstractPerformanceMonitorInterceptor to have "prefix" and "suffix" initialized with emtpy String (avoiding NPE)

Package org.springframework.beans
* reworked BeanUtils's "copyProperties" method to properly ignore properties not found in the target bean
* added new "copyProperties" variant to BeanUtils, for restriction of copying to properties of specified class/interface
* factored out protected "newNestedBeanWrapper" template method from BeanWrapperImpl's "getNestedBeanWrapper" method
* factored out PropertyEditorRegistry interface from BeanWrapper, implemented by BeanWrapperImpl and DataBinder
* reworked PropertyEditorRegistrar interface to work on PropertyEditorRegistry interface instead of DataBinder class
* PropertyPlaceholderConfigurer logs resolved values at debug level, for improved traceability
* AbstractBeanFactory throws BeanDefinitionStoreException if parent not found (instead of NoSuchBeanDefinitionException)
* DefaultListableBeanFactory does not include its toString output in NoSuchBeanDefinitionException messages anymore
* deprecated PropertiesBeanDefinitionReader's "class" and "property" keywords in favor of "(class)" and "(keyword)"
* PropertiesBeanDefinitionReader supports loading bean definitions from properties files with non-standard encodings
* XmlBeanDefinitionReader supports reading from resource with explicit encoding
* XmlBeanDefinitionReader supports reading from SAX InputSource (useful to pass in XML system id or java.io.Reader)
* DefaultXmlBeanDefinitionParser supports system property placeholders in import paths: e.g. "file:${user.dir}/ctx.xml"
* DefaultXmlBeanDefinitionParser calls "postProcessXml" template method after parsing standard bean definitions
* DefaultXmlBeanDefinitionParser allows for overriding default lazy-init, autowire and dependency-check values

Package org.springframework.context
* AbstractApplicationContext registers a ClassLoader-aware ClassEditor for its configured ClassLoader
* fixed AbstractMessageSource to never try to create a MessageFormat instance for a null message
* fixed AbstractMessageSource to synchronize on MessageFormat instance while using it to format message with arguments
* added "getDefaultMessage" template method to AbstractMessageSource, allowing for customized fallback default messages
* added "renderDefaultMessage" template method to AbstractMessageSource, allowing for custom processing of default msgs

Package org.springframework.core
* unified path normalization in ClassPathResource, FileSystemResource, UrlResource and ServletContextResource
* UrlResource sets the "UseCaches" flag to "false" for every URLConnection, mainly to avoid jar file locking on Windows
* DefaultResourceLoader and PathMatchingResourcePatternResolver obtain thread context ClassLoader at construction time
* PathMatchingResourcePatternResolver uses linked Sets if possible, to preserve the order of resources found
* refined PathMatchingResourcePatternResolver's "findAllClassPathResources" to work with Oracle OC4J 10.1.2 as well
* refined PathMatchingResourcePatternResolver to use relative resources within jar locations (instead of URL building)
* added DescriptiveResource implementation, holding a resource description but not pointing to a readable resource
* added EncodedResource class to package "core.io.support", combining a Resource with an encoding to use for reading
* added StaticLabeledEnum, a convenient base class for type-safe enum classes declared as static final member variables
* reworked ShortCoded, StringCoded and LetterCoded enum implementations to be non-static "GenericLabeledEnums"

Package org.springframework.jdbc
* reworked DataSourceTransactionManager to support pre-bound non-transactional JDBC Connections (e.g. from SUPPORTS)
* JdbcTemplate applies "fetchSize" and "maxRows" settings to all created Statements, not just to "query" operations
* JdbcTemplate exposes Connection proxy to ConnectionCallbacks, preparing Statements, unless NativeJdbcExtractor is set
* avoid NPE in CallableStatementCreatorFactory if a ParameterMapper fails, through checking for not-null "inParameters"
* SingleColumnRowMapper explicitly extracts Strings/numbers/etc through "ResultSet.getString/getInt", as far as possible
* SqlRowSet extends Serializable interface now, assuming that the contained disconnected data is serializable
* refined JTA synchronization in DataSourceUtils to release JDBC Connection on suspend (for JBoss JTA compatibility)
* relaxed OracleLobHandler's eager "oracle.jdbc.OracleConnection" class check to avoid potential class loader issue

Package org.springframework.jms
* JmsException returns null from "getErrorCode()" (rather than some text) if the root cause is not a JMSException
* fixed JmsException to not throw NullPointerException in case of null root cause
* fixed JmsTemplate to only pass in the NoLocal argument in case of an actual Topic (for WebSphere 6.0 compatibility)

Package org.springframework.jmx
* fixed InterfaceMBeanInfoAssembler to expose methods declared by super-interfaces of specified interfaces as well
* added WebLogicJndiMBeanServerFactoryBean, for JNDI-based lookup of a WebLogic MBeanHome (by default the local one)

Package org.springframework.jndi
* added "lookup(String jndiName, Class requiredType)" method to JndiLocatorSupport, used by JndiObjectFactoryBean

Package org.springframework.orm
* all "executeFind" operations throw InvalidDataAccessApiUsageException if the result isn't actually a Collection/List
* added "postProcessResult" template method to JdoTemplate, enabling subclasses to perform auto-detachment of the result
* changed TopLink ServerSessionFactory's managed client handling to proxy-based, in base class AbstractSessionFactory
* added support for TopLink SessionBroker to LocalSessionFactoryBean, through SessionBrokerSessionFactory
* added "isOpen" assertions to Hibernate Session synchronization, seamlessly removing dangling Sessions (fail-safe)
* refined HibernateTransactionManager and SessionFactoryUtils to adapt to Hibernate 3.1's changed Session management
* added "enableFilter" operation to HibernateOperations/HibernateTemplate, for parameterizing a Hibernate3 Filter
* added "bulkUpdate" convenience operations to HibernateOperations/HibernateTemplate, for Hibernate3 bulk update/delete
* fixed HibernateTemplate to apply a "firstResult" value of 0 to DetachedCriteria too, resetting to beginning of results
* fixed HibernateSystemException to not throw NullPointerException in case of null root cause

Package org.springframework.remoting
* added "validateResponse" method to Simple/CommonsHttpInvokerRequestExecutor, by default rejecting HTTP status >= 300
* added support for JAX-RPC 1.1 "loadService(Class)" to LocalJaxRpcServiceFactory, via "jaxRpcServiceInterface" property
* added support for JAX-RPC 1.1 service properties to LocalJaxRpcServiceFactory, via "jaxRpcServiceProperties" property

Package org.springframework.samples
* reworked PetClinic form JSPs to use domain command name ("owner", "pet", "visit") in combination with "nestedPath" tag

Package org.springframework.test
* added "setAutowireMode" and "getAutowireMode" methods to AbstractDependencyInjectionSpringContextTests

Package org.springframework.transaction
* optimized TransactionSynchronizationManager to perform synchronization sort lazily (in "getSynchronizations")
* added "defaultTimeout" bean property to JotmFactoryBean, for specifying the default JOTM transaction timeout

Package org.springframework.ui
* Multiple custom TemplateLoaders / loader paths can now be set on FreeMarkerConfigurationFactory / FreeMarkerConfigurer

Package org.springframework.util
* fixed WeakReferenceMonitor to correctly synchronize access to the monitoring thread, for proper lazy initialization
* "NumberUtils.parseNumber" supports numeric values supplied as hexadecimal number with "0x"/"0X" prefix
* fixed BooleanComparator's "equals" implementation

Package org.springframework.validation
* BindException uses canonical bean property paths for error registration, allowing any map key syntax for error access
* added convenience constructors to DataBinder, WebDataBinder and ServletRequestDataBinder, using a default object name

Package org.springframework.web
* ContextLoader reads the default WebApplicationContext impl class from "ContextLoader.properties" in the same package
* factored out "findRequiredWebApplicationContext" method from *ActionSupport to DelegatingActionUtils for Struts
* added "detectAllHandlerAdapters" property to DispatcherServlet, allowing to enforce a single "handlerAdapter" bean
* added "bindingErrorProcessor" property to BaseCommandController, for declaratively overriding DataBinder's default
* added "getCommandName(Object command)" template method to MultiActionController, for overriding default command name
* refined UrlFilenameViewController to let its "handleRequestInternal" method throw Exception (for potential subclasses)
* created AbstractUrlViewController as base class for UrlFilenameViewController, providing UrlPathHelper path extraction
* MultiActionController invokes an exception handler method even in case of binding/validation failure
* InternalPathMethodNameResolver caches resolved method names (after prefix/suffix and method name post-processing)
* ParameterMethodNameResolver logs its resolution results at debug level (indicating the triggering request parameter)
* JSP MessageTag evaluates given "arguments" CSV into argument Objects, retaining their natural type (no stringifying)
* added "message" attribute to JSP MessageTag, accepting a MessageSourceResolvable argument (direct or through JSP EL)
* Velocity/FreeMarkerViewResolver allows for setting "allowRequestOverride" and "allowSessionOverride" on its Views
* Velocity and FreeMarker form macros include an "id" attribute on each element
* refined RedirectView to properly support anchors: appending an anchor fragment after URL parameters, if any
* added "outputProperties" bean property to AbstractXlstView, for specifying arbitrary transformer output properties
* added JasperReportsViewResolver as convenient UrlBasedViewResolver subclass, analogous to InternalResourceViewResolver


Changes in version 1.2.5 (23.9.2005)
------------------------------------

Package org.springframework.aop
* added overloaded "getProxy" method with an explicit ClassLoader argument to ProxyFactory
* added protected "Object getProxy(AopProxy)" hook to ProxyFactoryBean, for specifying a custom class loader
* modified AbstractAutoProxyCreator to defer setting of the frozen flag until *after* advice has been applied (SPR-1250)
* lowered Cglib2AopProxy's log level for detected final methods on a proxy class from "warn" to "info"

Package org.springframework.beans
* fixed BeanWrapperImpl's "getPropertyType" implementation to avoid potential NPE in case of no custom editors
* AbstractFactoryBean implements DisposableBean and calls the "destroyInstance(Object)" template method for a singleton
* AbstractBeanFactory logs singleton creation at debug level rather than info level
* fixed AbstractBeanFactory to validate merged bean definition, properly preparing inherited method overrides
* AbstractAutowireCapableBeanFactory considers CGLIB-overridden bean properties as eligible for dependency checking too

Package org.springframework.core
* refactored AbstractPathResolvingPropertyEditor into SystemPropertyUtils.resolvePlaceholders(text) helper method
* refined PathMatchingResourcePatternResolver's jar entry matching to handle the zip protocol as well
* fixed ResourceArrayPropertyEditor to include the original IOException message if resource pattern resolution failed
* added LocalizedResourceHelper class, factored out from AbstractExcelView and AbstractJExcelView

Package org.springframework.context
* fixed StaticMessageSource to use locale-specific MessageFormat for programmatically added messages

Package org.springframework.jms
* factored out JmsDestinationAccessor from JmsTemplate, as a more specialized subclass of JmsAccessor
* merged all of JmsTemplate/JmsTemplate102's "createConsumer" template methods into one

Package org.springframework.jmx
* added "excludedBeans" property to MBeanExporter to allow for some beans to be explicitly excluded from autodetection
* added "registrationBehavior" property to MBeanExporter, allowing to ignore/replace existing MBeans on name collision
* added MethodExclusionMBeanInfoAssembler, allowing to specify method names to be excluded from MBean exposure

Package org.springframework.mock
* fixed MockServletContext's "getResource" and "getInputStream" implementations to return null for non-existing resource

Package org.springframework.orm
* SessionFactoryUtils converts Hibernate3's StaleStateException into Spring's OptimisticLockingFailureException too
* added "findByExample" methods to HibernateOperations/Template for Hibernate3, for querying by example entity object

Package org.springframework.remoting
* reworked JndiRmiClientInterceptor/ProxyFactoryBean to handle RMI invoker targets as well (mainly for WebLogic's T3)
* reworked JndiRmiServiceExporter to handle RMI invoker targets as well (mainly for WebLogic's T3)
* added "lookupServiceOnStartup" flag to JaxRpcPortClientInterceptor/ProxyFactoryBean, to be turned off for lazy init

Package org.springframework.samples
* fixed Image Database to have its NativeJdbcExtractor defined for C3P0 (applied when using OracleLobHandler)

Package org.springframework.transaction
* added protected "Object getProxy(AopProxy)" hook to TransactionProxyFactoryBean, for specifying a custom class loader

Package org.springframework.util
* Log4jConfigurer resolves ${...} placeholders in Log4J config locations as system properties
* factored out ConcurrencyThrottleSupport base class from ConcurrencyThrottleInterceptor

Package org.springframework.web
* introduced NestedServletException for proper root cause handling, extended by Spring's MultipartException
* refined ServletContextResourcePatternResolver to handle absolute paths returned by servlet container too (-> OC4J)
* fixed CommonsMultipartResolver to freshly check standard GET request parameters even after a forward/include
* added various RequestLoggingFilters: for Commons Logging, the ServletContext log, and Log4J including NDC support
* FrameworkServlet exposes protected "processRequest" method, to be called for special HTTP methods (from "doXxx")
* BindStatus resolves error messages lazily, to allow for custom error code resolution (avoid NoSuchMessageException)
* refined RedirectView to use scheme-specific URL encoding on JDK 1.4+, only falling back to default encoding on JDK 1.3
* added "newWriter" and "prepareWriter" callbacks to AbstractPdfView, useful for registering a page event listener
* AbstractXsltView applies a specified "uriResolver" to every created Transformer, not just to the TransformerFactory
* added AbstractJExcelView for generating Excel files using JExcelApi (http://jexcelapi.sourceforge.net)
* AbstractJasperReportsView supports JasperReports 1.0.1+ (which introduces an incompatible JR API change)
* added protected "postProcessReport" hook to AbstractJasperReportsView, for modifying the populated JasperPrint object
* AbstractJasperReportsSingleFormatView's "createExporter()" method returns JRExporter instead of JRAbstractExporter
* added WebApplicationContextVariableResolver for JSF, exposing the root context as JSF variable "webApplicationContext"
* refined UrlFilenameViewController to extend AbstractController and provide "prefix" and "suffix" functionality


Changes in version 1.2.4 (26.8.2005)
------------------------------------

Package org.springframework.aop
* added "loggerName" bean property to AbstractTraceInterceptor, allowing to log into a specified log category
* added "whenExhaustedAction" and "whenExhaustedActionName" bean properties to CommonsPoolTargetSource
* Cglib2AopProxy logs warnings when a final method cannot be proxied (CGLIB will simply ignore such a method)

Package org.springframework.beans
* changed BeanWrapperImpl's default behavior to not extract old property values, avoiding side effects caused by getters
* added "setExtractOldValueForEditor" method to BeanWrapper and BeanWrapperImpl, allowing to control getter invocation
* BeanWrapperImpl's "getPropertyType" checks custom editors and takes registered type as hint for expected property type
* added public "getSortDefinition()" method to PropertyComparator, giving access to the sort definition for unit tests
* added overloaded constructor to CustomDateEditor, accepting an exact date length to check (to avoid misinterpretation)
* added "searchSystemEnvironment" bean property to PropertyPlaceholderConfigurer, for checking "System.getenv()" too
* refined "toString()" implementations of Root/ChildBeanDefinition to expose more state (such as factory method, etc)
* added no-arg constructor to RootBeanDefinition and constructor with parent name only to ChildBeanDefinition
* AbstractAutowireCapableBeanFactory performs static type checking for prototype factory methods on "factory-bean" too
* AbstractAutowireCapableBeanFactory only fetches target bean for type checking on "factory-bean" when not lazy-init
* refined AbstractAutowireCapableBeanFactory to not log debug exception stacktraces during factory method resolution
* XmlBeanDefinitionReader uses ResourceEntityResolver if the passed-in BeanFactory was autodetected as ResourceLoader

Package org.springframework.context
* AbstractApplicationContext does not set the parent MessageSource if local MessageSource object already has a parent
* AbstractXmlApplicationContext applies its class loader, if any, as bean class loader to the XmlBeanDefinitionReader

Package org.springframework.core
* added "setClassLoader" method to DefaultResourceLoader, also exposed on AbstractApplicationContext and its subclasses

Package org.springframework.jca
* CciTemplate exposes RecordFactory placeholder to RecordCreator callbacks if connector doesn't provide a RecordFactory

Package org.springframework.jdbc
* changed StatementCreatorUtils to use "PreparedStatement.setNull" with Types.NULL when value is null and type unknown
* JdbcTemplate's "update" version with a KeyHolder argument explicitly closes the generated keys ResultSet, if any
* removed JdbcTemplate's fetchSize/maxRows check to allow for specifying only one and leaving the other at default (0)
* fixed SqlFunction's default constructor to set "rowsExpected" to 1, like all other SqlFunction constructors
* reworked SqlFunction to use SingleColumnRowMapper underneath, exposing a "resultType" bean property of type Class
* deprecated SqlFunction's constructors that expect a SQL return type, in favor of specifying a result type Class
* added overloaded constructor to SqlCall, with DataSource and SQL arguments (for consistency with SqlFunction and co)

Package org.springframework.jms
* added "deliveryPersistent" bean property to JmsTemplate, for setting the delivery mode through a boolean flag

Package org.springframework.jmx
* MBeanClientInterceptor closes a JMX Connector opened through the "serviceUrl" bean property on shutdown
* added "connectOnStartup" flag to MBeanClientInterceptor, to be turned off for lazily connecting on first access

Package org.springframework.mail
* MimeMessageHelper supports 3 multipart modes: MIXED, RELATED (1.2 final default), and MIXED_RELATED (1.2.1+ default)
* added overloaded "addAttachment(attachmentFilename, inputStreamSource, contentType)" method to MimeMessageHelper

Package org.springframework.mock
* reworked ExpectedLookupTemplate to support multiple JNDI name/object pairs
* added overloaded constructor to MockServletContext, with just a ResourceLoader as argument
* fixed AbstractTransactionalDataSourceSpringContextTests to delete from tables even if info logging is turned off

Package org.springframework.orm
* upgraded to the most recently published version of the Hibernate 3.0.5 jar (there seem to be multiple versions around)
* added "findByCriteria" methods to HibernateOperations/Template for Hibernate3, for executing DetachedCriteria objects
* added "fetchSize" and "maxResults" bean properties to HibernateTemplate, applied to Query and Criteria objects
* refined LocalPersistenceManagerFactoryBean to work with JDO 1.0 API as well as with the latest JDO 2.0 API snapshot
* refined LocalSessionFactory for TopLink to use a new TopLink SessionManager instance rather than the shared singleton

Package org.springframework.remoting
* factored out protected "createObjectOutputStream(OutputStream)" template method in HttpInvokerServiceExporter
* factored out protected "setRequestBody" and "getResponseBody" template methods in CommonsHttpInvokerRequestExecutor
* factored out protected "writeRequestBody" and "readResponseBody" template methods in SimpleHttpInvokerRequestExecutor

Package org.springframework.scheduling
* added MethodInvokingRunnable adapter to support package
* added DelegatingTimerTask adapter for java.util.Timer, wrapping a given Runnable implementation
* added "setRunnable" method to SchedulerTimerTask, plus corresponding overloaded constructors
* reworked MethodInvokingTimerTaskFactoryBean to derive from MethodInvokingRunnable and create a DelegatingTimerTask

Package org.springframework.test
* refined AbstractTransactionalSpringContextTests to allow any Exception to be thrown on onTearDownIn/AfterTransaction

Package org.springframework.transaction
* added "cacheUserTransaction" flag to JtaTransactionManager, to be turned off for a fresh lookup for every transaction
* reworked JtaTransactionManager to always access the UserTransaction through the current JtaTransactionObject
* reworked JtaTransactionManager's "applyIsolationLevel" and "applyTimeout" signatures to include JtaTransactionObject
* reworked JtaTransactionManager's "doJtaSuspend" and "doResume" signatures to include JtaTransactionObject

Package org.springframework.ui
* UiApplicationContextUtils does not set the parent ThemeSource if local ThemeSource object already has a parent
* UiApplicationContextUtils registers a DelegatingThemeSource when no local ThemeSource found but parent available
* ResourceBundleThemeSource uses a synchronized Map for holding already loaded themes
* added "createMessageSource(basename)" template method to ResourceBundleThemeSource, for using custom MessageSources
* deprecated JasperReportsUtils methods with JRAbstractExporter parameter in favor of versions with JRExporter parameter

Package org.springframework.util
* ClassUtils's "forName" supports primitive array names ("boolean[]", "int[]", etc) too, e.g. for constructor type hints
* fixed ClassUtils's "getShortNameAsProperty" to use correct JavaBeans decapitalization (through JavaBeans Introspector)

Package org.springframework.validation
* added sections on validation and error messages and content on data binding to reference documentation
* DataBinder keeps extracting old field values for property editors by default (as introduced in Spring 1.2.3)
* added "setExtractOldValueForEditor" method to DataBinder, allowing to control getter invocation

Package org.springframework.web
* XmlWebApplicationContext applies its class loader, if any, as bean class loader to the XmlBeanDefinitionReader
* added ServletContextParameterFactoryBean, explicitly retrieving and exposing a "context-param" defined in web.xml
* AcceptHeaderLocaleResolver/FixedLocaleResolver throw UnsupportedOperationException from "setLocale" (rather than IAE)
* FixedThemeResolver throw UnsupportedOperationException from "setThemeName" (rather than IllegalArgumentException)
* ResourceBundleViewResolver caches factories per actual bundle found, even if Locale differs (to avoid factory copies)
* MultiActionController now allows Validators to be specified and used for the optional command object(s)
* AbstractJasperReportsView holds a default "exporterParameters" Map, to allow for property-driven population of it
* AbstractJasperReportsSingleFormatView applies the configured exporter encoding as HTTP response encoding


Changes in version 1.2.3 (26.7.2005)
------------------------------------

Package org.springframework.aop
* changed AbstractPoolingTargetSource's "maxSize" default to -1, clearly indicating no size limit
* mirrored "maxIdle", "minIdle", "maxWait" and other Commons Pool properties in CommonsPoolTargetSource
* fixed DefaultAdvisorAutoProxyCreator's Advisor lookup to ignore FactoryBeans (avoiding potential for unproxied beans)

Package org.springframework.beans
* BeanWrapperImpl passes the old value to each applied PropertyEditor before calling "setAsText", as far as possible
* fixed PagedListHolder to always go through the "getPageCount()" method when determining the current number of pages
* refactored AbstractBeanFactory's type determination for "factory-method" into "getTypeForFactoryMethod" template
* AbstractBeanFactory does not create beans with "factory-method" if the type can clearly be determined statically
* AbstractAutowireCapableBeanFactory correctly indicates "constructor" or "factory method" in debug log messages
* AbstractAutowireCapableBeanFactory prefers raw arg matches over converted arg matches when choosing a constructor
* AbstractAutowireCapableBeanFactory throws BeanCreationException if a factory method returned null
* DefaultListableBeanFactory does not create beans with "factory-bean" for type check if "includeFactoryBeans"=false
* DefaultListableBeanFactory matches raw FactoryBean classes against specified type when "includeFactoryBeans"=false
* fixed BeanDefinitionReaderUtils to be able to generate a bean name for anonymous beans with "factory-bean" declaration
* AbstractBeanDefinitionReader autodetects BeanDefinitionRegistry that implements ResourceLoader (-> ApplicationContext)
* added "loadBeanDefinitions(location)" method to BeanDefinitionReader interface, given resource location/pattern String
* DefaultXmlBeanDefinitionParser supports resource patterns for XML "import" tag (requires a ResourcePatternResolver)
* DefaultXmlBeanDefinitionParser registers unique bean names for inner beans as well, with identity hashcode as suffix

Package org.springframework.context
* factored out AbstractApplicationEventMulticaster base class from SimpleApplicationEventMulticaster
* AbstractApplicationEventMulticaster allows for specifying the collection class to use (e.g. CopyOnWriteArraySet)
* AbstractApplicationContext registers raw FactoryBean instances that implement ApplicationListener as listeners
* added overloaded DefaultMessageSourceResolvable constructor that accepts a single code String

Package org.springframework.core
* added ByteArrayResource adapter, useful for example to create mail attachments from local content
* fixed InputStreamResource's "equals"/"hashCode" to only consider InputStreamResources with same InputStream as equal
* PathMatchingResourcePatternResolver always uses PathMatcher's pattern detection instead of hardcoded asterisk checks
* fixed PropertiesLoaderSupport to correctly ignore a resource not found failure if "ignoreResourceNotFound" is "true"

Package org.springframework.dao
* refined DataAccessUtils to consider a Collection with multiple references to same instance as having a unique result

Package org.springframework.jdbc
* added check to JdbcUtils's "getResultSetValue" method: turning Blob/Clob object into byte array respectively String
* JdbcUtils's "getResultSetValue" explicitly extracts Timestamp if metadata indicate Timestamp (Oracle 10g workaround)
* fixed bug in StatementCreatorUtils where NUMERIC and DECIMAL types could lose decimals when passing in BigDecimal
* refined StatementCreatorUtils to use straight "setTimestamp" calls instead of "setObject" where possible
* refined StatementCreatorUtils to treat StringBuffer and StringWriter as the resulting String

Package org.springframework.jmx
* revised ObjectNameManager to delegate to JMX 1.2's "ObjectName.getInstance()" methods (when available) for caching
* MBeanServerConnectionFactoryBean closes its JMX Connector on shutdown
* added "environment" and "environmentMap" properties to MBeanServerConnectionFactoryBean, for JMX connector parameters
* changed ConnectorServerFactoryBean's "environment" bean property to type Properties, with separate "environmentMap"
* added "locateExistingServerIfPossible"/"agentId" properties to MBeanServerFactoryBean, for retrieving existing servers

Package org.springframework.mail
* added InternetAddressEditor to JavaMail support package, to be registered as custom editor (e.g. for form objects)

Package org.springframework.orm
* extended doc coverage regarding plain DAO implementations: based on plain Hibernate3/JDO/TopLink/OJB/iBATIS API
* added "allowCreate" flag to TransactionAwarePersistenceManagerFactoryProxy, allowing to enforce transactional PMs
* added "FLUSH_COMMIT" support to HibernateTemplate/Interceptor for H2.1/H3, and "FLUSH_ALWAYS" support for H3
* HibernateTemplate/Interceptor also apply their flush mode to transactional Sessions, as far as feasible

Package org.springframework.remoting
* added RmiRegistryFactoryBean to RMI support package, for explicit setup of an RMI registry (existing or newly created)
* added "registry" bean property to RmiServiceExporter, for explicitly referring to an existing RMI registry instance

Package org.springframework.test
* added "onSetUpBeforeTransaction" and "onTearDownAfterTransaction" callbacks to AbstractTransactionalSpringContextTests

Package org.springframework.transaction
* factored out AbstractTransactionStatus class from AbstractPlatformTransactionManager's DefaultTransactionStatus
* added SimpleTransactionStatus class, provided as start for custom transaction managers and as static mock for testing
* added "globalRollbackOnParticipationFailure" flag to AbstractPlatformTransactionManager, with default "true"
* JtaTransactionManager calls "afterCompletion" of Spring synchronizations immediately if JTA tx is marked rollback-only
* added convenience constructors to TransactionInterceptor, passing in tx manager and tx attributes through constructor

Package org.springframework.validation
* DataBinder logs warnings about non-allowed binding fields at "debug" instead of "warn" level now

Package org.springframework.web
* fixed XmlWebApplicationContext to set itself as ResourceLoader on the underlying XmlBeanDefinitionReader that it uses
* fixed SpringBindingActionForm adapter to correctly work for nested properties (suppressing Struts binding completely)
* refined SpringBindingActionForm to be compatible with Struts 1.1 (which doesn't support default ActionMessages)
* added "suppressBinding(request)" callback method to BaseCommandController, to suppress binding for specific requests
* added "onFormChange" callback to AbstractFormController, to allow for post-processing in case of a form change request
* added CancellableFormController, supporting cancel requests and a corresponding "onCancel" callbck plus "cancelView"
* deprecated AbstractWizardFormController's "isFinish"/"isCancel" in favor of "isFinishRequest"/"isCancelRequest"
* fixed BindTag to be able to handle existing attributes named "status" of any type, simply storing and re-exposing them


Changes in version 1.2.2 (5.7.2005)
-----------------------------------

Package org.springframework.aop
* added "getTargetClass" method to AopProxyUtils (factored out from the JMX support's AbstractMBeanInfoAssembler)

Package org.springframework.beans
* BeanWrapperImpl supports JDK 1.5 enums and old-style enum classes: String values will be treated as enum value names
* added convenience constructor to PropertyComparator, passing in "property", "ignoreCase" and "ascending" directly
* optimized PropertyComparator to reuse a single BeanWrapperImpl instance without default editors
* factored out protected "copySortDefinition" and "doSort" hooks in PagedListHolder, allowing for custom comparators
* added "beanNameSeparator" property to PropertyOverrideConfigurer, allowing to specify a separator other than a dot
* MethodInvokingFactoryBean throws target exception in case of InvocationTargetException
* fixed AbstractBeanFactory to apply custom property editors even for typed values as collection entries
* fixed AbstractBeanFactory to hold names of dependent beans in Set rather than List, avoiding leak for prototype beans
* fixed AbstractAutowireCapableBeanFactory to not track dependencies for passed-in existing beans (avoiding memory leak)
* fixed DefaultListableBeanFactory to exclude bean definitions with factory method from pre-instantiation type matching
* fixed DefaultListableBeanFactory to pre-instantiate and match beans with factory method / "factory-bean" definition

Package org.springframework.context
* added "alwaysUseMessageFormat" property to AbstractMessageSource, enforcing MessageFormat for messages without args
* refined AbstractMessageSource to format passed-in default messages as well, resolving arguments when necessary
* ReloadableResourceBundleMessageSource also supports JDK 1.5's properties XML files, for files with ".xml" filename

Package org.springframework.core
* fixed ClassPathResource to fall back to its ClassLoader if none specified and no thread context ClassLoader available
* deprecated ResourcePatternResolver's "CLASSPATH_URL_PREFIX" constant in favor of "CLASSPATH_ALL_URL_PREFIX"
* factored out PropertiesLoaderSupport class from PropertiesFactoryBean and PropertyResourceConfigurer
* added "localOverride" property to PropertiesLoaderSupport, for configurable overriding (local or properties from file)
* PropertiesLoaderSupport also supports JDK 1.5's properties XML files, for files with ".xml" filename
* added "enums" package, containing support for type-safe enums with code and label (working on JDK >= 1.3)
* added "styler" package, containing a ToStringCreator utility class with ToStringStyler/ValueStyler strategy mechanism

Package org.springframework.dao
* added generic DaoSupport base class, defining a logger and "initDao" method and pre-implementing "afterPropertiesSet"

Package org.springframework.jca
* added CCI section to the reference documentation
* reworked transaction synchronization to correctly handle suspension even from beforeCompletion/afterCompletion
* reworked CciDaoSupport class to extend the new generic DaoSupport base class

Package org.springframework.jdbc
* added "connectionProperties" bean property to DriverManagerDataSource, accepting arbitrary properties for the driver
* SQLState/SQLErrorCodeSQLExceptionTranslator always include SQL in message, even for generic DataAccessExceptions
* UncategorizedSQLException includes SQL state and error code in message, to indicate potential exception classification
* reworked transaction synchronization to correctly handle suspension even from beforeCompletion/afterCompletion
* JdbcTemplate releases Connection early, to avoid potential connection pool deadlock due to SQLException translation
* reworked JdbcDaoSupport class to extend the new generic DaoSupport base class

Package org.springframework.jms
* fixed JmsTemplate to always close JMS MessageProducers (not relying on implicit close through JMS Session)
* reworked JmsGatewaySupport class to follow DaoSupport pattern ("afterPropertiesSet" not throwing Exception anymore)

Package org.springframework.jmx
* introduced MBeanExporterListener interface, for notification about MBean registration and unregistration events
* added "listeners" bean property to MBeanExporter, accepting a list of MBeanExporterListeners to be notified
* added SelfNaming interface, to be implemented by infrastructure components that provide their own JMX ObjectName
* refined MetadataMBeanInfoAssembler to not specify defaults for a managed attribute (letting JMX use MBean defaults)

Package org.springframework.jndi
* added "expectedType" bean property to JndiObjectLocator, for eager checking of the type of the located JNDI object

Package org.springframework.orm
* added sections on JDO, TopLink and OJB to the reference documentation
* reworked all transaction synchronizations to correctly handle suspension even from beforeCompletion/afterCompletion
* reworked all XxxDaoSupport classes to extend the new generic DaoSupport base class
* fixed PersistenceBrokerDaoSupport to be abstract and to actually implement InitializingBean
* LocalSessionFactoryBean executes DDL scripts with autoCommit=true, to be able to proceed after a failed statement
* made "entityInterceptorBeanName" property available to OpenSessionInViewInterceptor (for Hibernate 2.1 and Hibernate3)
* added "cacheableMappingLocations" property to LocalSessionFactoryBean, for Hibernate3's caching of parsed XML as bins
* added dedicated support for Hibernate Annotation 3.0 beta 2: AnnotationSessionFactoryBean in "tiger" source tree
* made JDO2-style "detachCopy(All)", "attachCopy(All)" and "newNamedQuery" behavior overridable through JdoDialect

Package org.springframework.samples
* added Hibernate 3.0's JMX statistics service to Hibernate version of PetClinic, exported via Spring's MBeanExporter
* dropped unmaintained alternative scenarios (with database access) from Countries sample application
* revised all XML application context definition files to use Spring 1.2 shortcut attributes as far as possible

Package org.springframework.scheduling
* fixed SchedulerFactoryBean to support passed-in JobDetails in combination witb autodetected JobDetailAwareTriggers

Package org.springframework.transaction
* fixed AbstractPlatformTransactionManager to always execute all synchronizations, even on unexpected assertion failures
* AbstractPlatformTransactionManager logs exceptions thrown by before/afterCompletion, keeping the original exception
* added "registerAfterCompletionWithExistingTransaction" template method to AbstractPlatformTransactionManager
* added further fallback JNDI location to JtaTransactionManager: "java:comp/TransactionManager" (for Resin 3.0)
* JtaTransactionManager calls "afterCompletion" of Spring synchronizations at completion of outermost JTA transaction
* JtaTransactionManager throws UnexpectedRollbackException in case of global rollback-only if not thrown by JTA commit

Package org.springframework.util
* added "loadFromXml" and "storeToXml" methods to PropertiesPersister, by default implemented to delegate to JDK 1.5
* refined ClassLoaderUtils to not expose recursion arguments as public and to offer overloaded convenience methods
* added "comparator" subpackage, containing useful generic Comparator implementations (e.g. invertible, compound)

Package org.springframework.web
* DispatcherServlet throws ServletException in case of Error during request processing, rather than the Error itself
* added "postProcessPage" hook to AbstractWizardFormController, called after binding and page-specific validation
* fixed BindTag and BindErrorsTag to correctly reset all their instance variables in their "doFinally" implementations
* added "indent" bean property to AbstractXlstView, to be turned off when the choice should be up to the stylesheet
* changed "showErrors" macro for FreeMarker to not add a separator after the final error shown
* added SpringBindingActionForm adapter, using Spring's POJO binding and validation, exposing results to Struts tags


Changes in version 1.2.1 (28.5.2005)
------------------------------------

Package org.springframework.aop
* fixed ThrowsAdviceInterceptor to log at DEBUG level rather than INFO level
* changed CustomizableTraceInterceptor to use "$[...]" syntax, to avoid conflicts with PropertyPlaceholderConfigurer

Package org.springframework.beans
* reworked ArgumentConvertingMethodInvoker to determine an appropriate overloaded method (with assignable arguments)
* refined BeanWrapperImpl and PropertyPlaceholderConfigurer to never log property values (which might be sensitive data)
* fixed PropertyResourceConfigurer to actually call "convertProperties" and "convertPropertyValue" for merged properties
* fixed MethodInvokingFactoryBean's "getObjectType" implementation to return null if not fully initialized yet
* added "getBeanPostProcessorCount" method to ConfigurableBeanFactory interface
* fixed AbstractBeanFactory to destroy chains of beans in correct order even with non-disposable beans in the middle
* fixed AbstractAutowireCapableBeanFactory to only match untyped argument values as fallback (avoid unintended matches)
* added "ignoreDependencyInterface" method to AbstractAutowireCapableBeanFactory and ConfigurableListableBeanFactory
* reworked AbstractAutowireCapableBeanFactory's dependency exclusion check to support ignored dependency interfaces
* AbstractAutowireCapableBeanFactory registers BeanFactoryAware as default ignored dependency interface

Package org.springframework.context
* AbstractApplicationContext registers MessageSourceAware/ApplicationContextAware/etc as ignored dependency interfaces
* fixed AbstractApplicationContext to not exclude dependencies of type MessageSource/ApplicationContext/etc by default
* AbstractApplicationContext logs message when a bean is not eligible for getting processed by all BeanPostProcessors

Package org.springframework.dao
* fixed DataAccessUtils' "(required)UniqueResult" methods to treat a passed-in null value as empty Collection

Package org.springframework.ejb
* adapted LocalSlsbInvokerInterceptor to support a local EJB that does not directly implement the business interface

Package org.springframework.jms
* moved "sessionTransacted" and "sessionAcknowledgeMode(Name)" bean properties from JmsTemplate up to JmsAccessor

Package org.springframework.mail
* fixed MimeMessageHelper to use a "multipart/mixed" root with nested "multipart/related", for Lotus Notes compatibility

Package org.springframework.orm
* DefaultJdoDialect integrates JDOException message into translated DataAccessException even with nested SQLException
* HibernateAccessor and HibernateTransactionManager integrate JDBCException message into Spring DataAccessException
* SessionFactoryUtils keeps nested exception even case in case of TransientObjectException/PersistentObjectException
* fixed Hibernate SessionFactoryUtils to correctly handle asynchronous timeouts in case of mixed JTA/Spring transactions
* fixed SessionFactoryUtils for Hibernate 2.1 to not prevent transaction synchronization when allowCreate=false
* fixed LocalSessionFactoryBean for Hibernate3 to use connection release mode "on_close" as default (-> safe tx cleanup)
* fixed LocalSessionFactoryBean for Hibernate3 to register type definitions before any Hibernate configuration loading
* fixed TypeDefinitionBean for Hibernate3 to use empty Properties as parameters and to check "typeName" and "typeClass"
* refined HibernateTransactionManager for Hibernate3 to not call "Session.toString" (which is broken in Hibernate3)
* added "filterNames" property to HibernateTemplate/Interceptor, allowing to enable a list of filters for all operations

Package org.springframework.samples
* added demonstration of JMX export to PetClinic's JDBC version: exposure of the CachingClinic management interface
* added demonstration of JMX export to PetClinic's JDBC version: exposure of a CallMonitor that monitors the Clinic
* switched PetClinic's default data access strategy to JDBC, to highlight the JMX export

Package org.springframework.transaction
* exposed "hasSavepoint" and "isCompleted" methods on TransactionStatus interface (not just on DefaultTransactionStatus)
* added "getCurrentTransactionName" method to TransactionSynchronizationManager, exposing the transaction name (if any)
* added "isActualTransactionActive" flag to TransactionSynchronizationManager (different from "isSynchronizationActive")
* fixed AbstractPlatformTransactionManager to set the "isCurrentTransactionReadOnly" flag correctly in any case
* added specific "isLocalRollbackOnly" and "isGlobalRollbackOnly" methods to DefaultTransactionStatus
* added "shouldCommitOnGlobalRollbackOnly" callback method to AbstractPlatformTransactionManager, with default "false"
* AbstractPlatformTransactionManager throws UnexpectedRollbackException if attempting commit with rollback-only tx
* JtaTransactionManager expects "doCommit" call for global rollback-only tx, letting JTA handle it (e.g. for tx timeout)

Package org.springframework.util
* refined MethodInvoker to find matching method with assignable parameters if no direct match found for given arguments

Package org.springframework.web
* refactored HtmlUtils implementation, reading character entity references from a properties file in the classpath
* changed HtmlUtils' "htmlEscape" method to return standard entity references by default (named, not decimal or hex)
* added "htmlEscapeDecimal" and "htmlEscapeHex" methods to HtmlUtils, for escaping in decimal or hex style, respectively
* reimplemented HtmlUtils' "htmlUnescape" to correctly handle any entity references, including decimal and hex style
* changed EscapedErrors to not stringify and HTML-escape non-String values, to keep type even with escaping turned on
* changed BindStatus to not stringify and HTML-escape non-String values for "value" but only for "displayValue"
* fixed FreeMarker macro "formSingleSelect" (in spring.ftl) to correctly compare selected numerical values
* AbstractJasperReportsView exposes current Spring-managed Locale and MessageSource to JasperReports i18n ($R expr etc)
* refined AbstractJasperReportsView to properly handle Internet Explorer HTTPS through resetting the response first


Changes in version 1.2 final (13.5.2005)
----------------------------------------

Package org.springframework.aop
* introduced AbstractTraceInterceptor superclass for all trace interceptors, supporting a static or a dynamic logger
* deprecated TraceInterceptor in favor of SimpleTraceInterceptor, which is a subclass of AbstractTraceInterceptor
* reworked PerformanceMonitorInterceptor/JamonPerformanceMonitorInterceptor into subclasses of AbstractTraceInterceptor
* reworked DebugInterceptor into a subclass of SimpleTraceInterceptor
* added CustomizableTraceInterceptor, supporting pattern-based enter and exit messages with placeholders
* all trace interceptors log at Commons Logging's "trace" level now, instead of "info" or "debug"
* moved AopUtils' "getAllInterfaces" and "getAllInterfacesForClass" methods to org.springframework.util.ClassUtils

Package org.springframework.beans
* factored out BeanDefinitionVisitor from PropertyPlaceholderConfigurer, making the bean definition traversal reusable
* ConstructorArgumentValues holds generic ValueHolders in a List instead of a Set now, keeping their definition order
* ConstructorArgumentValues offers "get(Generic)ArgumentValue" variant that excludes already used ValueHolders
* AbstractAutowireCapableBeanFactory applies generic constructor argument values of the same type in definition order
* factored out BeanDefinitionValueResolver helper class from AbstractAutowireCapableBeanFactory
* AbstractAutowireCapableBeanFactory excludes CGLIB-defined bean properties (-> method injection) from dependency checks
* reworked ResourceEntityResolver to depend on ResourceLoader only and moved it to package "beans.factory.xml"
* factored out resource editor registration from AbstractApplicationContext into ConfigurableBeanFactoryUtils helper
* fixed DefaultXmlBeanDefinitionParser to correctly parse null keys for XML map entries

Package org.springframework.context
* reworked LocaleContextHolder to use an InheritableThreadLocal, also exposing the thread-bound Locale to child threads
* fixed GenericApplicationContext to correctly propagate the internal parent BeanFactory in case of a "setParent" call
* GenericApplicationContext detects a passed-in ResourceLoader that implements ResourcePatternResolver and uses it

Package org.springframework.dao
* reworked IncorrectResultSizeDataAccessException into subclass of DataRetrievalFailureException

Package org.springframework.jca
* removed overloaded "getConnection" method with "allowSynchronization" flag -> moved code into transaction manager impl

Package org.springframework.jdbc
* removed overloaded "getConnection" method with "allowSynchronization" flag -> moved code into transaction manager impl

Package org.springframework.jms
* added UserCredentialsConnectionFactoryAdapter for JMS, analogous to the UserCredentialsDataSourceAdapter for JDBC

Package org.springframework.jmx
* changed MBeanServerNotFoundException to unchecked and added constructor with root cause argument
* added WebLogicMBeanServerFactoryBean, obtaining the WebLogic MBeanServer through WebLogic's proprietary JMX Helper
* reworked MBeanInfoAssembler interface to take a managed bean instance as argument instead of just the bean class
* reworked AbstractMBeanInfoAssembler and subclasses to expose proper class/interface for CGLIB/JDK proxies
* added "exposeClassDescriptor" field to AbstractReflectiveMBeanInfoAssembler, to expose the "class" field for WebLogic
* marked JDK 1.5+ annotations (ManagedResource, ManagedAttribute, ManagedOperation, etc) as @Documented

Package org.springframework.jdbc
* deprecated "closeConnectionIfNecessary" method in favor of "releaseConnection" (in DataSourceUtils and JdbcDaoSupport)
* added "releaseConnection" method to ConnectionHandle interface, allowing for JDO2-style Connection borrowing
* reworked ConnectionHolder to explicitly fetch a current Connection on demand and release it on receiving "released"

Package org.springframework.orm
* removed resource acquisition methods with "allowSynchronization" flag -> moved code into transaction manager impls
* redefined "allowCreate" flag: allowCreate=false does not prevent transaction synchronization (e.g. with JTA)
* deprecated "closePersistenceManager/BrokerIfNecessary" methods in favor of "releasePersistenceManager/Broker"
* deprecated "closeSessionIfNecessary" methods in favor of "releaseSession" (for both Hibernate2, Hibernate3)
* JTA Session synchronization detects read-only status of Spring-managed transaction (for both Hibernate2, Hibernate3)
* Hibernate3 SessionFactoryUtils doesn't call "setReadOnly(true)" anymore, to avoid Open Session in View side effects
* LocalSessionFactoryBean exposes proxy, with Hibernate 3.0.1's "getCurrentSession" returning the Spring-managed Session
* LocalSessionFactoryBean defaults Hibernate 3.0.3's Connection release mode to "after_statement"/"after_transaction"
* added TypeDefinitionBean, representing a Hibernate3 type definition (TypeDef / typedef XML tag) in bean-style format
* added "typeDefinitions" property to LocalSessionFactoryBean for Hibernate3, accepting TypeDefinitionBean objects
* added IdTransferringMergeEventListener for Hibernate3, setting newly assigned ids on the original objects too
* added "evictAll", "refreshAll" and "makePersistentAll" convenience methods to JdoOperations and JdoTemplate
* added support for JDO2 "getObjectById", "detachCopy" and "attachCopy" to JdoOperations and JdoTemplate
* added support for JDO2 single string queries and named queries to JdoOperations and JdoTemplate
* updated DefaultJdoDialect for JDO2: exposing a JDO2 DataStoreConnection and calling the JDO2 flush method
* changed JdoTemplate's "exposeNativePersistenceManager" default to "false": all PM interfaces get proxied now
* added TransactionAwarePersistenceManagerFactoryProxy, returning Spring-managed PMs from "getPersistenceManager" calls
* added Oracle-donated support for TopLink as Spring-style data access option: TopLinkTemplate, TopLinkCallback, etc
* added TopLink SessionFactory abstraction for creating TopLink Sessions, including a convenient LocalSessionFactoryBean
* added TopLinkTransactionManager, a Spring PlatformTransactionManager implementation for TopLink's native transactions
* added TransactionAwareSessionAdapter, providing a Session that exposes the Spring-managed active Session/UnitOfWork
* added CommonsLoggingSessionLog(904) classes for TopLink, redirecting TopLink's Session logging to Commons Logging

Package org.springframework.samples
* changed "id" property of PetClinic's persistent entities from type int to Integer
* reworked PetClinic's Hibernate DAO to use "merge" (plus IdTransferringMergeEventListener) instead of "saveOrUpdate"
* added TopLink persistence layer to PetClinic, as alternative to the existing Hibernate3, OJB and JDBC layers

Package org.springframework.util
* added "split" and "splitArrayElementsIntoProperties" convenience methods to StringUtils (moved over from Acegi)
* NumberUtils' "parseNumber" method now trims Strings before parsing them, and works correctly for the Byte type

Package org.springframework.web
* added DelegatingFilterProxy, delegating to a Spring-managed Filter bean (successor of Acegi's FilterToBeanProxy)
* changed visibility of ServletContextResource's "getServletContext" and "getPath" methods to public
* added GenericWebApplicationContext as subclass of GenericApplicationContext for web environments
* WebContentGenerator sets "no-store" value for "Cache-Control" header too, to prevent caching on FireFox
* AbstractCachingViewResolver expects fully initialize View instances now, not calling "setApplicationContext" anymore
* factored out "buildView" method from UrlBasedViewResolver's "loadView", separating View instantiation from lifecycle
* reworked XmlViewResolver to use a GenericWebApplicationContext for loading the view definitions
* reworked ResourceBundleViewResolver to use a GenericWebApplicationContext for loading the view definitions


Changes in version 1.2 RC2 (18.4.2005)
--------------------------------------

Package org.springframework.aop
* added "targetName" property to ProxyFactoryBean, as alternative to target name at the end of "interceptorNames" array
* changed RegexpMethodPointcutAdvisor to use JdkRegexpMethodPointcut by default on JDK 1.4+, unless "perl5" is specified

Package org.springframework.beans
* BeanUtils' "isSimpleProperty" considers primitive wrapper types (Boolean, Integer, etc) as "simple" types too
* BeanWrapperImpl registers a default CustomBooleanEditor for primitive boolean fields (accepting various flag values)
* added CharacterEditor, registered as default editor for "java.lang.Character" and "char" by BeanWrapperImpl
* CustomCollectionEditor's/InputStreamEditor's "getAsText" returns null to indicate that there is no text representation
* added "getBeanNamesForType" method with "includePrototypes" and "includeFactoryBean" arguments to ListableBeanFactory
* deprecated ListableBeanFactory's "getBeanDefinitionNames(type)" method, in favor of "getBeanNamesForType"
* refined FieldRetrievingFactoryBean to trim passed-in "targetField" and "staticField" values, stripping off whitespace
* fixed ServiceLocatorFactoryBean to explicitly check for calls of java.lang.Object methods (for JRockit compatibility)
* added "serviceLocatorExceptionClass" property to ServiceLocatorFactoryBean, allowing for custom locator exceptions
* AbstractAutowireCapableBeanFactory supports autowiring for factory methods too
* fixed CglibSubclassingInstantiationStrategy's overload detection for method overrides
* DefaultXmlBeanDefinitionParser accepts entity references in text values
* added "value"/"value-ref" attributes to XML "entry" tag for maps, as shortcut alternative to respective child elements
* added "alias" root element for XML bean definition files, allowing to define aliases for beans in other files
* removed JndiBeanFactoryLocator, in favor of the existing default ContextJndiBeanFactoryLocator in the context package
* deprecated SingletonBeanFactoryLocator's alias-through-String-bean feature, in favor of BeanReferenceFactoryBean

Package org.springframework.core
* added public "getClassName" method and protected "getFieldCache" method to Constants
* added explicit abstract "getDescription" method to AbstractResource, to work around a bug in Sun's JDK 1.3 classic VM
* fixed PathMatchingResourcePatternResolver's jar entry matching to also work with BEA JRockit's additional slashes

Package org.springframework.context
* added "i18n" subpackage, with LocaleContext abstraction and global LocaleContextHolder (holding a thread-bound Locale)
* reworked MessageSourceAccessor to use LocaleContextHolder to determine the default locale for the current thread
* AbstractApplicationContext implements DisposableBean, to properly shut down when running in a bean factory itself
* AbstractApplicationContext creates and invokes non-Ordered BeanFactoryPostProcessors separately, after Ordered ones

Package org.springframework.ejb
* added SmartSessionBean interface, exposing a "getSessionContext()" method, implemented by Spring's AbstractSessionBean

Package org.springframework.jca
* added support for the Common Client Interface (CCI) as Spring-style data access option: CciTemplate, EisOperation, etc
* added CciLocalTransactionManager, a Spring PlatformTransactionManager implementation for CCI's local transactions
* added various JCA connection support classes: LocalConnectionFactoryBean, SingleConnectionFactory, etc

Package org.springframework.jdbc
* changed SmartDataSource interface to only have package visibility (it is only used internally)
* added convenience constructors to DriverManagerDataSource and SingleConnectionDataSource
* TransactionAwareDataSourceProxy handles "equals" and "hashCode" locally within the Connection proxy
* DataSourceTransactionManager unwraps a passed-in TransactionAwareDataSourceProxy to get access to the raw DataSource
* added "setDatabaseProductName" method to SQLErrorCodeSQLExceptionTranslator, for specifying the DB name explicitly
* added "setDatabaseProductName" method to JdbcAccessor, for specifying the DB name explicitly to avoid metadata lookup
* switched default value of JdbcAccessor's "lazyInit" flag to "true", for lazy SQLExceptionTranslator initialization
* added no-arg constructor plus "requiredType" bean property to SingleColumnRowMapper, to allow for property injection

Package org.springframework.jms
* factored out JmsAccessor base class from JmsTemplate, containing the "connectionFactory" property
* added "defaultDestinationName" property to JmsTemplate, allowing for resolving the default destination dynamically

Package org.springframework.jmx
* added "defaultCurrencyTimeLimit" property to AbstractReflectiveMBeanInfoAssembler, for specifying an explicit default
* AbstractReflectiveMBeanInfoAssembler translates "getFoo" getter to "Foo" attribute now (see "useStrictCasing" flag)

Package org.springframework.mail
* added "setFileTypeMap" method to MimeMessageHelper, allowing to override the default Activation Framework FileTypeMap
* added "defaultFileTypeMap" property to JavaMailSenderImpl, specifying a default FileTypeMap for MimeMessageHelpers
* added "defaultEncoding" property to JavaMailSenderImpl, specifying a default character encoding for MimeMessageHelpers
* added ConfigurableMimeFileTypeMap, building an Activation FileTypeMap from a mapping file and from local mappings
* added default "mime.types" mapping file, loaded by default ConfigurableMimeFileTypeMap, used by JavaMailSenderImpl

Package org.springframework.orm
* Hibernate/Jdo/PersistenceBrokerTransactionManager unwraps a passed-in TransactionAwareDataSourceProxy
* HibernateAccessor, HibernateTransactionManager and DefaultJdoDialect lazily initialize their JDBC exception translator
* added "entityCacheStrategies"/"collectionCacheStrategies" properties to LocalSessionFactoryBean for Hibernate3
* added "eventListeners" property to LocalSessionFactoryBean for Hibernate3, accepting listener type/object pairs
* added "filterDefinitions" property to LocalSessionFactoryBean for Hibernate3, accepting FilterDefinition objects
* added FilterDefinitionFactoryBean, to allow for defining Hibernate FilterDefinitions as Spring beans

Package org.springframework.remoting
* added RemoteInvocationTraceInterceptor, logging incoming remote calls and resulting exceptions on the server
* RemoteExporter and its subclasses register a RemoteInvocationTraceInterceptor for the service proxy (by default)
* CodebaseAwareObjectInputStream explicitly resolves primitive class names (necessary on JDK 1.3)
* HTTP invoker uses CodebaseAwareObjectInputStream even with no codebase specified, to deserialize primitives on JDK 1.3

Package org.springframework.transaction
* added "jndiEnvironment" property to JtaTransactionManager, as alternative to specifying a JndiTemplate instance
* marked JDK 1.5+ Transactional annotation as "@Inherited" and "@Documented"

Package org.springframework.util
* refactored static PathMatcher class into PathMatcher interface and AntPathMatcher implementation

Package org.springframework.validation
* BindException's "getFieldValue" only transforms the value if the PropertyEditor's "getAsText" does not return null
* factored out protected "checkAllowedFields", "checkRequiredFields" and "applyPropertyValues" methods in DataBinder
* factored out protected "checkFieldMarkers", "getEmptyValue", "checkMultipartFiles" methods in ServletRequestDataBinder

Package org.springframework.web
* UrlPathHelper supports URL-decoding with the VM platform default encoding on JDK 1.3 (instead of just working on 1.4)
* factored out WebDataBinder from ServletRequestDataBinder, offering field marker support without Servlet API dependency
* DispatcherServlet exposes the current LocaleResolver and its current Locale through the global LocaleContextHolder
* added "commandName" property and "createBinder" and "initBinder" callbacks to ThrowawayControllerHandlerAdapter
* fixed BindStatus to apply HTML-escaping to plain bean values too (when no Errors object is available in the model)
* EscapedErrors and BindTag perform HTML escaping for any non-null value (stringifying it), not just for String values
* added "toolboxConfigLocation" property to VelocityViewResolver, for creating VelocityToolboxView instances
* removed "spring." prefix for internal access to variables in Spring's FreeMarker macro library (spring.ftl)
* updated AbstractJasperReportsView for JasperReports 0.6.6, using JRDefaultCompiler instead of JRBshCompiler
* added "reportCompiler" bean property to AbstractJasperReportsView, to override the default JRCompiler implementation
* reworked AbstractJasperReportsView to work on JasperPrint instance rather than JasperReport instance
* reworked JasperReportsMultiFormatView's "formatMappings" to replace existing properties, also replacing defaults
* added support for reports with embedded SQL statements to AbstractJasperReportsView, via the "jdbcDataSource" property


Changes in version 1.2 RC1 (28.3.2005)
--------------------------------------

Overall
* removed all deprecated classes and methods whose deprecation dated back to Spring <= 1.1 final
* added AOP Alliance interfaces to spring-aop.jar and spring.jar, avoiding the need for aopalliance.jar on the classpath
* split spring-core.jar into spring-core.jar (core utilities) and spring-beans.jar (bean support, bean container)
* split spring-dao.jar into spring-dao.jar (DAO interfaces, transaction support) and spring-jdbc.jar (JDBC support)
* split spring-context.jar into spring-context.jar, spring-support.jar (incl. JMX support) and spring-remoting.jar
* split spring-orm.jar into spring-orm.jar (without Hibernate) and spring-hibernate.jar (with Hibernate2/3 support)

Package org.springframework.aop
* deprecated AopUtils' "getAllInterfaces(ForClass)AsList" methods in favor of "getAllInterfaces(ForClass)AsSet"
* removed deprecated RegexpMethodPointcut class: use Perl5RegexpMethodPointcut or JdkRegexpMethodPointcut instead
* reworked AbstractAutoProxyCreator to check for custom TargetSourceCreator before instantiation of target bean
* reworked TargetSourceCreator mechanism to work with bean class rather than bean instance (non-backwards-compatible)
* reworked AbstractPrototypeBasedTargetSourceCreator into AbstractBeanFactoryBasedTargetSourceCreator
* added LazyInitTargetSourceCreator, automatically creating a LazyInitTargetSource for each bean marked as "lazy-init"

Package org.springframework.beans
* fixed BeanUtils' "copyProperties" to avoid fetching a property descriptor for a property that will be ignored anyway
* added protected "convertElement" hook to CustomCollectionEditor, for converting each encountered collection element
* added InstantiationAwareBeanPostProcessor extension of BeanPostProcessor interface, intercepting before instantiation
* added TypedStringValue class, allowing to register property values with a specific target type on a bean definition
* PropertyOverrideConfigurer does not log invalid keys at WARN level in case of "ignoreInvalidKeys" (only at DEBUG)
* added BeanReferenceFactoryBean, allowing for exposure of a target bean under a different name (effectively an alias)
* refined AbstractBeanFactory's "getType" to only suppress specific exceptions like BeanCurrentlyInCreationException
* refined AbstractAutowireCapableBeanFactory's "autowireConstructor" to only suppress UnsatisfiedDependencyException
* XmlBeanDefinitionReader offers an "errorHandler" property and uses the factored-out SimpleSaxErrorHandler as default
* added "value"/"ref" attributes to XML "property"/"constructor-arg" tag, as shortcut alternative to child elements
* added "key" sub-element to XML "entry" tag for maps, allowing for inner beans, refs, values etc specified as key
* added "key-ref" attribute to XML "entry" tag for maps, as shortcut alternative to a key element with "ref bean="

Package org.springframework.context
* fixed DelegatingMessageSource to return default message for MessageSourceResolvable, if no parent MessageSource found
* fixed ReloadableResourceBundleMessageSource's "clearCache" operation to clear the cache for merged properties too
* ReloadableResourceBundleMessageSource accepts non-refreshable (non-file-system) resources even if "cacheSeconds" >0

Package org.springframework.core
* PathMatchingResourcePatternResolver collects resource entries in a Set and normalizes paths (to avoid double entries)

Package org.springframework.dao
* added PessimisticLockingFailureException as super class for CannotAquireLock/DeadlockLoser/CannotSerializeTransaction
* refined DataAccessUtils' "requiredUniqueResult" method to not throw an exception in case of a single null element

Package org.springframework.jdbc
* added InvalidResultSetAccessException, typically thrown when an invalid ResultSet column index or name was specified
* replaced "dataRetrievalFailureCodes" with "invalidResultSetAccessCodes" and SQLErrorCodes and sql-error-codes.xml
* removed "optimisticLockingFailureCodes" from SQLErrorCodes and sql-error-codes.xml (never thrown by database itself)
* added "deadlockLoserCodes" and "cannotSerializeTransactionCodes" to SQLErrorCodes and sql-error-codes.xml
* added "getTargetConnection" method to DataSourceUtils, returning the innermost target Connection of a given proxy
* refined DataSourceUtils' "closeConnectionIfNecessary" to detect given target Connection handles as transactional too
* LazyConnectionDataSourceProxy handles "toString", "equals" and "hashCode" itself (avoiding to fetch target Connection)
* added debug logging to LazyConnectionDataSourceProxy, logging whether an operation is handled locally or in target
* added "1213" as SQL error code for CannotAcquireLockException on MySQL (in the default "sql-error-codes.xml" file)
* added LOB accessor methods that take column names to LobHandler interface, pre-implemented in AbstractLobHandler class
* added "support.rowset" package, with SqlRowSet abstraction for disconnected result sets with Spring exceptions
* added "queryForRowSet" methods to JdbcTemplate, returning a SqlRowSet as generic representation of the result rows
* added "queryForObject" convenience methods to JdbcTemplate, taking a RowMapper argument and expecting a single row
* added "queryForList" methods with "elementType" argument to JdbcTemplate, for extracting values from a single column
* added "queryForMap" methods to JdbcTemplate, creating a Map representation for the columns of a single row
* refined JdbcTemplate's "queryForList"/"queryForMap" to use a Commons Collections CaseInsensitiveMap if available
* added RowSetResultExtractor, SingleColumnRowMapper and ColumnMapRowMapper as separate classes in "jdbc.core"
* factored out protected "createJdbcTemplate" in JdbcDaoSupport, allowing to override JdbcTemplate creation

Package org.springframework.jmx
* added JMX support, for registration of Spring-managed beans as JMX MBeans as well as for access to remote JMX MBeans
* added Commons Attributes annotations for MBean export, plus corresponding AttributesJmxAttributeSource
* added JDK 1.5+ annotations for MBean export, plus corresponding AnnotationJmxAttributeSource

Package org.springframework.mail
* JavaMailSenderImpl uses the current date as "sentDate" if none specified, to make sure the mail contains a date header

Package org.springframework.orm
* added "orm.hibernate3" support package for Hibernate3, mirroring the Hibernate 2.1 support in "orm.hibernate"
* removed deprecated "createQuery" and "createCriteria" methods from HibernateTemplate: use Session methods instead
* SessionFactoryUtils sets Hibernate Session's flush mode to NEVER for a read-only transaction even with JTA

Package org.springframework.samples
* migrated Petclinic's Hibernate layer from Hibernate 2.1 to Hibernate 3.0 RC1
* added new JPetStore version based on Spring's JDK 1.5+ "Transactional" annotation (in "samples/jpetstore/annotation")

Package org.springframework.scheduling
* fixed Quartz SchedulerFactoryBean to properly pass on given scheduler name, supporting multiple Scheduler instances
* fixed Quartz LocalDataSourceJobStore to use scheduler name as part of Quartz data source name, avoiding conflicts
* added "nonTransactionalDataSource" property to SchedulerFactoryBean, for an explicit non-transactional DataSource
* reworked LocalDataSourceJobStore to use a non-transactional DataSource if specified, falling back to the default else

Package org.springframework.transaction
* added JDK 1.5+ "Transactional" annotation, plus corresponding AnnotationTransactionAttributeSource
* added "getName" method to TransactionDefinition interface, allowing to specify a symbolic name for a transaction
* TransactionInterceptor exposes fully qualified class name + "." + method name as transaction name (by default)
* added thread-bound "currentTransactionReadOnly" flag to TransactionSynchronizationManager
* JtaTransactionManager autodetects JTA TransactionManager at "java:/TransactionManager" too (JBoss, JRun4)
* JtaTransactionManager properly initializes with "transactionManagerName" only too (creating a UserTransactionAdapter)
* WebLogicJtaTransactionManager autodetects WebLogic 7.0 or 8.1+, adapting accordingly (TransactionManager lookup etc)
* WebLogicJtaTransactionManager invokes WebLogic's special "begin(name)" method, for visibility in WebLogic's tx monitor
* WebLogicJtaTransactionManager applies per-transaction isolation level as WebLogic's "ISOLATION LEVEL" tx property

Package org.springframework.util
* reworked FileCopyUtils to return byte/character count on appropriate "copy" methods
* added SimpleSaxErrorHandler and SimpleTransformErrorListener to "util.xml" package

Package org.springframework.validation
* added "addAllErrors(Errors)" method to Errors interface and BindException, for merging Errors objects
* factored out BindingErrorProcessor strategy from DataBinder, with DefaultBindingErrorProcessor implementation
* DataBinder does not generate any further field errors for "requiredField" that has already caused missing field error

Package org.springframework.web
* UrlPathHelper accepts different case for context path in "getRequestURI" vs "getContextPath" (can happen on Resin)
* CommonsMultipartResolver exposes query parameters in multipart requests too, not just multipart POST parameters
* AbstractFormController/AbstractWizardFormController perform debug logging for session attributes being added/removed
* AbstractWizardFormController allows for dynamic pages through overriding the "getPageCount" and "getViewName" methods
* changed MultiActionController's log level from INFO to DEBUG
* added "prefix" and "suffix" properties to InternalPathMethodNameResolver, for common method name prefixes/suffixes
* added "methodParamNames" property to ParameterMethodNameResolver, for params where the very existence chooses a method
* added "logicalMappings" property to ParameterMethodNameResolver, for logical mappings between params and method names
* added "createBinder" and "initBinder" methods to MultiActionController, which may be overridden by subclasses
* removed deprecated BindStatus class from "servlet.tags": use BindStatus from "servlet.support" (recompile old JSPs)
* JSP BindTag saves previous "status" value and re-exposes it at the end of the tag (to support BindTag nesting)
* added VelocityLayoutView, emulating the functionality offered by Velocity's VelocityLayoutServlet
* AbstractXlstView offers an "errorListener" property and registers a default ErrorListener with the XSLT transformer
* deprecated AbstractXsltView's "createDomNode" method in favor of new "createXsltSource" method


Changes in version 1.1.5 (28.2.2005)
------------------------------------

Documentation
* moved Tapestry integration content to a separate chapter ("Integrating with other web frameworks")

Package org.springframework.aop
* adapted AdvisedSupport to keep the order of proxy interfaces, to create JDK proxy with specified order of interfaces
* introduced private monitor within ConcurrencyThrottleInterceptor, to avoid synchronizing on the user-visible instance

Package org.springframework.beans
* ClassEditor trims class name strings and converts empty strings into null values
* CustomBooleanEditor accepts "1" (true) and "0" (false) values too
* CustomBooleanEditor only accepts default "true/"on"/"yes"/"1" and "false"/"off"/"no"/"0" if not given explicit Strings
* added overloaded StringTrimmerEditor constructor that takes a set of chars to delete (e.g. for unwanted line breaks)
* added "getBeanNamesForType" method to ListableBeanFactory interface, also checking FactoryBeans and manual singletons
* added "beanNamesForTypeIncludingAncestors" method to BeanFactoryUtils, corresponding to "getBeanNamesForType"
* renamed FactoryBeanCircularReferenceException to FactoryBeanNotInitializedException, reflecting general causes
* fixed AbstractAutowireCapableBeanFactory to ignore further satisfiable constructors with less arguments
* added "getResourceLoader" method to BeanDefinitionReader interface, plus setter in AbstractBeanDefinitionReader
* moved "loadBeanDefinitions(Resource[])" method from AbstractBeanDefinitionReader to BeanDefinitionReader interface
* fixed PropertiesBeanDefinitionReader to not consider dots in map/props keys as separator between name and property
* DefaultXmlBeanDefinitionParser supports "classpath:" and standard URLs as resource locations for the "import" tag

Package org.springframework.context
* AbstractApplicationContext uses new DelegatingMessageSource as placeholder, to avoid StaticMessageSource side effects
* AbstractApplicationContext detects and registers prototype beans that implement the ApplicationListener interface too
* added overloaded "registerSingleton"/"registerPrototype" methods without property values to StaticApplicationContext

Package org.springframework.core
* fixed FileSystemResource's "createRelative" to correctly apply a given relative path when starting from a directory

Package org.springframework.ejb
* added "homeInterface" property to AbstractRemoteSlsbInvokerInterceptor, for specifying the home interface to narrow to

Package org.springframework.jdbc
* added "int[] batchUpdate(String[] sql)" method to JdbcTemplate, for executing a group of SQL statements as a batch
* DataSourceUtils only executes Connection cleanup in "beforeCompletion" synchronization if there are no open references
* added C3P0NativeJdbcExtractor for C3P0 0.8.5 or later (for earlier C3P0 versions, use SimpleNativeJdbcExtractor)
* added "maxRows" bean property to JdbcTemplate, allowing to specify the maximum number of rows to be fetched
* added "fetchSize" and "maxRows" bean properties to RdbmsOperation, passing the values to the internal JdbcTemplate
* BatchSqlUpdate stores clones of passed-in argument arrays, to avoid side effects with reused (modified) arrays

Package org.springframework.jndi
* added "lookup(name, requiredType)" convenience method to JndiTemplate, matching the JNDI object against the given type

Package org.springframework.mail
* introduced MailMessage interface as common interface for SimpleMailMessage and JavaMail MIME messages
* added MimeMailMessage implementation of MailMessage interface, as adapter for a MimeMessageHelper or a MimeMessage

Package org.springframework.mock
* upgraded MockHttpServletRequest to Servlet API 2.4 (added getRemotePort, getLocalName, getLocalAddr, getLocalPort)
* upgraded MockPageContext to JSP API 2.0 (added getExpressionEvaluator, getVariableResolver, overloaded include)
* added MockExpressionEvaluator for JSP 2.0, delegating to the Jakarta JSTL ExpressionEvaluatorManager
* deprecated MockHttpServletRequest's "addRole" method in favor of the new "addUserRole" method
* fixed MockHttpServletRequest to create a new HttpSession if the previous session has been invalidated
* fixed MockHttpServletResponse to use "ISO-8859-1" as default character encoding

Package org.springframework.orm
* reworked SqlMapClientTemplate to execute calls directly on SqlMapClient in case of TransactionAwareDataSourceProxy
* added AbstractLobTypeHandler class for iBATIS SQL Maps 2.0.9, for type handlers that delegate to a Spring LobHandler
* added ClobStringTypeHandler, BlobByteArrayTypeHandler and BlobSerializableTypeHandler for iBATIS SQL Maps 2.0.9
* fixed AbstractLobType for Hibernate, cleaning up in afterCompletion if necessary (for HibernateTransactionManager)
* AbstractLobType uses low order value for transaction synchronizations, to always execute before resource cleanup
* added "lookupSessionFactory(request)" callback to OpenSessionInViewFilter, for request-dependent SessionFactory lookup
* SessionFactoryUtils/PersistenceManagerFactoryUtils/OjbFactoryUtils execute synchronizations before Connection cleanup

Package org.springframework.samples
* changed JPetStore's "declarativeServices.xml" file to avoid autowiring (avoid autowiring for BeanPostProcessors!)
* introduced C3P0 ComboPooledDataSource as connection pool for Image Database (to show an alternative to Commons DBCP)

Package org.springframework.transaction
* added TransactionTimedOutException, to be thrown if an explicit transaction timeout is detected
* ResourceHolderSupport throws TransactionTimedOutException if no time-to-live left (before attempting an operation)
* added optional reference counting to ResourceHolderSupport, to be able to check for pending resource release calls
* AbstractPlatformTransactionManager throws IllegalTransactionStateException on repeated commit/rollback attempts
* AbstractPlatformTransactionManager's "isExistingTransaction" and "doSetRollbackOnly" are provided in default impls now
* AbstractPlatformTransactionManager's "doSuspend" and "doResume" are provided in default impls now, throwing exceptions
* TransactionSynchronization objects can influence their execution order through implementing the Ordered interface
* MethodMap/NameMatchTransactionAttributeSource automatically convert String values to TransactionAttribute instances
* reworked TransactionAttributeSourceAdvisor and AttributesTransactionAttributeSource to allow bean-style configuration
* TransactionProxyFactoryBean auto-detects a matching PlatformTransactionManager bean if not explicitly specified
* JtaTransactionManager is able to work with a JTA TransactionManager only (i.e. without a UserTransaction handle)

Package org.springframework.util
* added ResourceUtils utility class, for resolving resource locations to files in the file system (without any logging)
* Log4jConfigurer accepts a "classpath:" URL or a "file:" URL as location too, not just a plain file path
* Log4jConfigurer accepts config files that do not reside in the file system, as long as there is no refresh interval
* fixed DefaultPropertiesPersister to correctly handle empty property values when reading with specific encoding

Package org.springframework.validation
* added overloaded "reject" and "rejectValue" methods without default message to Errors interface and BindException

Package org.springframework.web
* Log4jWebConfigurer supports a "log4jExposeWebAppRoot" context-param, for turning off exposure of the system property
* added overloaded "getXxxParameter" methods to RequestUtils, returning wrapper types or null (instead of primitives)
* added "contextOverride" option to ServletContextPropertyPlaceholderConfigurer, letting web.xml override local settings
* added "searchContextAttributes" option to ServletContextPropertyPlaceholderConfigurer, resolving context attributes
* added "clear" and "isEmpty" methods to ModelAndView, allowing to clear the view of a given ModelAndView object
* DispatcherServlet only attempts to render a ModelAndView object if it isn't empty (empty = nothing to render)
* reworked DispatcherServlet's fallback to default strategies, reading in default strategy names from a properties file
* DispatcherServlet does not override "doHead" anymore, leveraging HttpServlet's default "HEAD" handling via "doGet"
* factored out protected "resolveViewName" method from DispatcherServlet's "render" implementation
* added "HEAD" to WebContentGenerator's default set of supported methods (in addition to "GET" and "POST")
* added overloaded "showForm" version with request, response, errors and control model to SimpleFormController
* added "suppressValidation" calls to AbstractWizardFormController, analogous to SimpleFormController's behavior
* added SimpleServletHandlerAdapter, supporting handlers that implement the Servlet interface within DispatcherServlet
* added SimpleServletPostProcessor, applies init and destruction callbacks to beans that implement the Servlet interface
* added support for declarative configuration of exporter parameters to AbstractJasperReportsView
* factored out AbstractJasperReportsSingleFormatView from AbstractJasperReportsView
* added JasperReportsMultiFormatView, allowing to specify the output format dynamically via a discriminator in the model
* JSP EL expressions in Spring's JSP tags will be parsed with JSP 2.0 ExpressionEvaluator on JSP 2.0 (Jakarta JSTL else)
* changed "spring:transform" tag's "value" attribute from String to Object, to allow for expressions resolved by JSP 2.0


Changes in version 1.1.4 (31.1.2005)
------------------------------------

Package org.springframework.aop
* added "setClassFilter" method to StaticMethodMatcherPointcut, to allow for overriding the default ClassFilter.TRUE
* factored out AbstractBeanFactoryBasedTargetSource superclass from AbstractPrototypeBasedTargetSource
* added LazyInitTargetSource, lazily accessing a singleton from a BeanFactory (lazily initializing on first call)
* fixed AbstractAdvisorAutoProxyCreator to match pointcuts against interface methods if appropriate (e.g. for regexp)

Package org.springframework.beans
* fixed BeanWrapperImpl to allow custom PropertyEditor (setValue) to kick in before applying String[]-to-CSV conversion
* added "getResourceDescription" and "getBeanName" accessors to BeanCreationException and BeanDefinitionStoreException
* added overloaded CustomBooleanEditor constructor that takes explicit String values for true/false (e.g. "on"/"off")
* fixed AbstractFactoryBean's "afterPropertiesSet" implementation to avoid singleton creation in case of a prototype
* added "ignoreInvalidKeys" bean property to PropertyOverrideConfigurer, allowing to just log invalid keys as warning
* added ServiceLocatorFactoryBean, allowing to map custom service locator interface methods to BeanFactory.getBean calls
* added "containsSingleton" method to ConfigurableBeanFactory, checking the singleton cache for a specific bean name
* added "getSingletonCount" method to AbstractBeanFactory, returning the number of objects in the singleton cache
* AbstractBeanFactory ignores BeanCreationExceptions on FactoryBean type checks, avoiding certain autowiring failures
* fixed AbstractAutowireCapableBeanFactory to avoid potential NPE in case of chained factory-methods with factory-bean
* fixed AbstractAutowireCapableBeanFactory to correctly destroy original bean objects if wrapped by a BeanPostProcessor
* reworked AbstractAutowireCapableBeanFactory to allow for multiple disposable inner beans of the same name
* changed DefaultListableBeanFactory's "getBeansOfType" to ignore beans that cause BeanCreationExceptions on "getType"
* DefaultListableBeanFactory's "getBeansOfType" returns its result as linked map (if on JDK 1.4 or Commons Collections)
* added "factoryBean" argument to InstantiationStrategy's "instantiate" method for a factory method (required for above)
* XML bean definition DTD allows "lookup-method" and "replaced-method" in arbitrary order

Package org.springframework.context
* fixed AbstractApplicationContext to ignore "applicationEventMulticaster" bean in parent context (-> only local bean)
* optimized ReloadableResourceBundleMessageSource to never check the same message file twice for the same message
* added protected "getDefaultLocale" method to MessageSourceAccessor, to allow to use a thread-bound user locale

Package org.springframework.core
* reworked ResourcePatternResolver to extend ResourceLoader, for ResourcePatternResolver checks in ResourceLoaderAware

Package org.springframework.ejb
* added "isConnectFailure(RemoteException)" hook to AbstractRemoteSlsbInvokerInterceptor, for customized failure checks

Package org.springframework.jdbc
* TransactionAwareDataSourceProxy automatically applies Spring-managed transaction timeouts to all created Statements
* added LazyConnectionDataSourceProxy, for lazily fetching JDBC Connections with native JDBC or Hibernate transactions
* added "databaseProductNames" property to SQLErrorCodes, allowing to specify multiple product names per bean definition
* added database product name "Adaptive Server Enterprise" to Sybase definition in default sql-error-codes.xml file
* changed CustomSQLErrorCodesTranslation's "exceptionClass" property from type String to Class (compatible in XML)
* added "lazyInit" flag to JdbcAccessor, allowing to enforce lazy initialization of the SQLExceptionTranslator
* reworked WebSphereNativeJdbcExtractor to detect a WebSphere version 4 DataSource even when running on WebSphere 5
* added overloaded "queryForList"/"queryForObject"/"queryForLong"/"queryForInt" methods with arg types to JdbcTemplate
* optimized JdbcTemplate's "queryForList" result set parsing to not access result set meta data for empty results
* added overloaded SqlReturnResultSet constructor, taking a ResultSetExtractor as argument

Package org.springframework.jms
* added "messageIdEnabled" and "messageTimestampEnabled" properties to JmsTemplate, to disable id/timestamp on producer
* added "pubSubNoLocal" property to JmsTemplate, leading to the NoLocal flag being specified on MessageConsumer creation
* added "receiveSelected" and "receivedSelectedAndConvert" methods to JmsTemplate, accepting JMS message selectors
* fixed JmsTemplate's send and receive operations to suppress commit and rollbacks calls within JTA transactions
* fixed JmsTemplate's "...AndConvert" methods to return null as converted message if no JMS message received

Package org.springframework.mock
* fixed "setAttribute" in MockServletContext/HttpSession/HttpServletRequest/PageContext to correctly handle null values
* changed "addParameter" methods in MockHttpServletRequest to check for existing values, adding given values to the list
* changed "addHeader" method in MockHttpServletRequest to check for existing values, adding given value to String array
* added "getHeaderNames" method to MockHttpServletResponse, returning a Set of Strings representing the header names
* fixed "getAttributeNames" in MockPageContext to correctly return attribute keys (rather than attribute values)

Package org.springframework.orm
* added "useTransactionAwareDataSource" flag to SqlMapClientFactoryBean, with default true (transactional lazy loading)
* added overloaded "update"/"delete" methods to SqlMapClientOperations/Template, with required number of affected rows
* marked SqlMapDaoSupport and SqlMapClientDaoSupport as abstract classes (analogous to all other DAO support classes)
* added "useTransactionAwareDataSource" flag to LocalSessionFactoryBean, with default false (for JDBC-based transaction)
* fixed NPE in SessionFactoryUtils' Session lookup code (when using both JTA synchronization and Spring synchronization)
* refined SessionFactoryUtils' JTA synchronization to unbind the Session as early as possible (earlier for a commit)
* refined AbstractLobType' JTA synchronization to close the LobCreator as early as possible (earlier for a commit)
* fixed NPE in HibernateTemplate's "iterate(queryString,value)" and "iterate(queryString,values)" methods
* added "saveOrUpdateAll" operation to HibernateOperations and HibernateTemplate, accepting a collection of entities
* added "alwaysUseNewSession" flag to HibernateTemplate, enforcing a new Session even in case of a pre-bound Session
* HibernateTemplate proxies exposed Sessions by default, applying query cache settings and transaction timeouts
* deprecated HibernateTemplate's "createQuery", "getNamedQuery" and "createCriteria" methods (in favor of Session proxy)
* JdoTemplate can proxy exposed PersistenceManagers ("exposeNativePersistenceManager"), applying transaction timeouts
* added TransactionAwareDataSourceConnectionFactory for OJB (JDBC-based transaction participation, transaction timeouts)
* added "getObjectById(entityClass, idValue)" method to PersistenceBrokerOperations/Template, for single primary keys

Package org.springframework.remoting
* added "prepare" methods and corresponding checks to all client interceptors, to allow for easier standalone usage
* added "isConnectFailure(RemoteException)" hook to (Jndi)RmiClientInterceptor, for customized connect failure checks
* added "registryHost", "registryClientSocketFactory", "registryServerSocketFactory" properties to RmiServiceExporter
* added JaxRpcServicePostProcessor interface, intended for reusable custom type mappings etc for a JAX-RPC service
* added "servicePostProcessors" property to LocalJaxRpcServiceFactory and subclasses (incl. JaxRpcPortProxyFactoryBean)
* reworked JaxRpcPortClientInterceptor to work with JAX-RPC dynamic calls when not given an RMI port interface
* JaxRpcPortClientInterceptor returns its own proxy description on "toString" (to avoid "toString" failure on Axis)
* added "proxyFactory" property to HessianClientInterceptor/FactoryBean, for passing in a HessianProxyFactory instance
* added "proxyFactory" property to BurlapClientInterceptor/FactoryBean, for passing in a BurlapProxyFactory instance

Package org.springframework.samples
* upgraded JPetStore's data access layer from iBATIS SQL Maps 1.3 (SqlMap API) to SQL Maps 2.0 (SqlMapClient API)
* reworked JPetStore's JAX-RPC support to avoid the RemoteOrderService RMI interface in favor of JAX-RPC dynamic calls

Package org.springframework.scheduling
* TimerFactoryBean accepts SchedulerTimerTasks with "period" <= 0 now, scheduling them for one-time execution
* added "schedulerListeners", "(global)JobListeners", "(global)TriggerListeners" bean properties to SchedulerFactoryBean
* added "jobListenerNames"/"triggerListenerNames" property to JobDetailBean, CronTriggerBean, SimpleTriggerBean (resp.)

Package org.springframework.test
* added "endTransaction" method to AbstractTransactionalSpringContextTests, to force an early end of the transaction

Package org.springframework.transaction
* reworked TransactionProxyFactoryBean to allow auto-detection of interfaces for a non-default TargetSource too

Package org.springframework.util
* reimplemented DefaultPropertiesPersister's Reader/Writer persistence, to remove copying-and-pasting of Sun source code

Package org.springframework.validation
* made BindException serializable, provided that the contained target object is serializable

Package org.springframework.web
* added "exposeRequestAttributes" method to WebUtils, exposing a given java.util.Map as request attributes
* changed WebUtils' "getParametersStartingWith" method to use a TreeMap, automatically sorting parameters by name
* Log4jConfigListener/Servlet supports "file:" URL as "log4jConfigLocation" (as alternative to ServletContext resource)
* Log4jConfigListener/Servlet and WebAppRootListener remove the web app root system property on shutdown
* ContextLoader can optionally load a (shared) parent application context to the root web application context
* added ServletContextFactoryBean, exposing the ServletContext for bean references (alternative to ServletContextAware)
* added ServletContextAttributeFactoryBean, exposing an existing ServletContext attribute for bean references
* added ServletContextAttributeExporter, taking Spring-defined objects and exposing them as ServletContext attributes
* added ServletContextPropertyPlaceholderConfigurer, a subclass that falls back to web.xml context-param entries
* changed HttpServletBean and GenericFilterBean to ignore unknown init-params that do not correspond to bean properties
* added "publishEvents" init-param to FrameworkServlet, allowing to turn off the publishing of RequestHandledEvents
* fixed DispatcherServlet to copy attribute names before iterating over them to restore original values after include
* factored out generic CookieGenerator from CookieLocaleResolver and CookieThemeResolver, adding cookie domain support
* reworked BeanName/SimpleUrlHandlerMapping to prefer more specific mappings in case of overlapping URL paths
* added overloaded "getFormSessionAttributeName" method with HttpServletRequest argument to AbstractFormController
* added overloaded "getPageSessionAttributeName" method with HttpServletRequest argument to AbstractWizardFormController
* RequestContext works outside DispatcherServlet too, falling back to root WebApplicationContext and JSTL/request locale
* added JspAwareRequestContext as subclass of RequestContext, populated from JSP PageContext (and aware of page scope)
* Spring JSP tags work outside DispatcherServlet too, falling back to root WebApplicationContext and JSTL/request locale
* AbstractJasperReportsView supports declarative configuration of sub-reports and sub-report data sources
* AbstractJasperReportsView allows for the response headers to be specified via the "headers" bean property
* AbstractJasperReportsView sets "Content-Disposition" header to inline (by default) to make IE play nice
* AbstractJasperReportsView sets "Content-Length" header for IE when writing to the OutputStream (like AbstractPdfView)


Changes in version 1.1.3 (12.12.2004)
-------------------------------------

Package org.springframework.aop
* introduced ProxyMethodInvocation interface, to let DelegatingIntroductionInterceptor access proxies in a clean fashion
* fixed bug in Cglib2AopProxy where proxy creation failed in case of unadvised target method calls during constructor

Package org.springframework.beans
* BeanWrapperImpl automatically registers a default ResourceArrayPropertyEditor
* fixed reported bean class in BeanWrapperImpl to always point to the root class at the top of the path
* deprecated setting of a nested path without specifying the root object in BeanWrapperImpl
* added CustomCollectionEditor, by default registered to convert between Set, SortedSet and List (when necessary)
* fixed TypeMismatchException constructor to avoid NullPointerException in case of null as required type
* added "getPropertyDescriptors" method to BeanUtils, as alternative to retrieving the descriptors via a BeanWrapper
* added "fileEncoding" and "propertiesPersister" properties to PropertyResourceConfigurer
* added hooks for custom conversion of read-in property values to PropertyResourceConfigurer (e.g. for decryption)
* fixed PropertyPlaceholderConfigurer to avoid StringBuffer.indexOf(String), which is just available on JDK >=1.4
* moved "ignoreDependencyType" method from ConfigurableBeanFactory interface down to ConfigurableListableBeanFactory
* moved management of ignored dependency types from AbstractBeanFactory down to AbstractAutowireCapableBeanFactory
* fixed AbstractAutowireCapableBeanFactory to not create prototype beans referenced by a "factory-bean" attribute twice
* factored out AbstractAutowireCapableBeanFactory's BeanWrapper creation into protected "createBeanWrapper" method
* fixed DefaultListableBeanFactory's "getBeansOfType" to ignore failures that contain a BeanCurrentlyInCreationException
* reworked DefaultListableBeanFactory's "getBeansOfType" to return FactoryBean instances when passed a FactoryBean type
* reworked StaticListableBeanFactory's "getBeansOfType" to return FactoryBean instances when passed a FactoryBean type
* moved "loadBeanDefinitions(Resource[])" method from XmlBeanDefinitionReader up to AbstractBeanDefinitionReader
* DefaultXmlBeanDefinitionParser resolves "set" tag as LinkedHashSet on JDK 1.4, falling back to HashSet on JDK 1.3

Package org.springframework.context
* ApplicationContext interface extends ResourcePatternResolver, offering "Resource[] getResources(locationPattern)" now
* AbstractApplicationContext passes the parent MessageSource to its fallback StaticMessageSource, if any
* factored out AbstractRefreshableApplicationContext as base class of AbstractXmlApplicationContext
* added "setResourceLoader" method to GenericApplicationContext, for overriding the default resource loading strategy
* added "isContextRequired" method to ApplicationObjectSupport, allowing to enforce running in an ApplicationContext

Package org.springframework.core
* added "contains" method to NestedRuntime/CheckedException, checking for a given exception class in the nested causes
* added "createLinkedSetIfPossible" to CollectionFactory, creating a JDK 1.4 LinkedHashSet or Commons ListOrderedSet
* added initial capacity check to CollectionFactory, to always pass a positive capacity number to Commons Collections
* added FileSystemResourceLoader, resolving paths as file system r