SPRING FRAMEWORK CHANGELOG ========================== http://www.springframework.org 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 resources rather than as class path resources * fixed AbstractPathResolvingPropertyEditor to avoid StringBuffer.indexOf(String), which is just available on JDK >=1.4 * PathMatchingResourcePatternResolver supports path matching in jar files now (for both "classpath:" and "classpath*:") Package org.springframework.jdbc * added "execute(ConnectionCallback)" method to JdbcTemplate, allowing any kind of operation on a given Connection * added DB2SequenceMaxValueIncrementer, implementing the DataFieldMaxValueIncrementer interface for a DB2 sequence Package org.springframework.jndi * added optional "proxyInterface" property to JndiObjectFactoryBean, for exposing a proxy rather than the plain object * added "lookupOnStartup" and "cache" properties to JndiObjectFactoryBean, allowing for lazy lookup on first access etc Package org.springframework.mock * implemented "getResourcePaths" in MockServletContext, to allow for pattern matching via the ServletContext Package org.springframework.orm * fixed Hibernate/JTA synchronization to also work with EJB remote transaction propagation (with >1 thread involved) * fixed HibernateTransactionManager to not pre-initialize the SQLExceptionTranslator, lazily creating a specific one * SqlMapClientFactoryBean forces the iBATIS ExternalTransactionConfig to always keep the original auto-commit value * SqlMapClientFactoryBean lets lazy loading and direct SqlMapClient access participate in Spring-managed transactions * added "transactionConfigClass" and "transactionConfigProperties" customization properties to SqlMapClientFactoryBean Package org.springframework.remoting * added "codebaseUrl" property to HttpInvokerClientInterceptor, specifying a URL for dynamic class download * added support for dynamic class downloading to AbstractHttpInvokerRequestExecutor and its subclasses * added hooks for decorating input/output streams to AbstractHttpInvokerRequestExecutor and HttpInvokerServiceExporter Package org.springframework.scheduling * reworked LocalDataSourceConnectionProvider to register Quartz ConnectionProviders, for proper helper thread shutdown Package org.springframework.ui * activated caching by default in VelocityEngineFactory, with file timestamp check for resources in the file system * added "preferFileSystemAccess" property to VelocityEngineFactory, to be able to suppress file system access * added "preferFileSystemAccess" property to FreeMarkerConfigurationFactory, to be able to suppress file system access * added JasperReportsUtils to allow for convenient rendering of CSV/HTML/PDF/XLS reports with Jasper Reports Package org.springframework.util * changed Log4jConfigurer's "initLogging" to only do config file refresh checks in case of explicit refresh interval * factored out LocaleEditor's string parsing into the "parseLocaleString" method of StringUtils Package org.springframework.validation * added "setIgnoreUnknownFields" method to DataBinder, enforcing request parameters to match fields when turned "false" Package org.springframework.web * changed Log4jConfigListener/Servlet to only do config file refresh checks with explicit "log4jRefreshInterval" param * factored out AbstractRefreshableWebApplicationContext as base class of XmlWebApplicationContext * StaticWebApplicationContext registers ServletContextAwareProcessor and ServletContextResourcePatternResolver * WebApplicationObjectSupport overrides "isContextRequired" to enforce running in an ApplicationContext * DispatcherServlet by default cleans up request attributes after include request (configurable via "cleanupOnInclude") * AbstractFormControllers and its subclasses use "cacheSeconds" default of 0 (-> no caching for all form controllers) * turned AbstractFormController's "getFormSessionAttributeName" method non-final, to allow for specifying the name * turned AbstractWizardFormController's "getPageSessionAttributeName" method non-final, to allow for specifying the name * changed AbstractWizardFormController's "validatePagesAndFinish" to show the offending page for global errors too * changed SimpleMappingExceptionResolver's "exceptionMappings" to support exception patterns (similar to rollback rules) * changed SimpleMappingExceptionResolver's "mappedHandlers" property from List to Set (reflecting its actual role) * changed CookieLocaleResolver's cookie value separator from space to underscore, for Resin and Tomcat 5.5 compatibility * added overloaded "getMessage" methods to RequestContext, taking a List of arguments (as alternative to Object array) * added overloaded "getThemeMessage" methods to RequestContext, taking a List of arguments (alternative to Object array) * fixed BindStatus to look for plain target object in model map first (to also work in Velocity and FreeMarker views) * UrlBasedViewResolver supports a "forward:" prefix too, for forwards to other controllers through special view names * added "attributes" (Properties) and "attributesMap" (Map) properties to UrlBasedViewResolver, for static attributes * InternalResourceView performs an include if the response has already been committed (-> forward not possible anymore) * JstlView and TilesJstlView respect a JSTL "localizationContext" config in web.xml, checking those messages first * added overloaded "createVelocityContext" and "exposeHelpers" methods to VelocityView, with passed-in servlet response * added "toolAttributes" property to VelocityView, taking attribute name / tool class name pairs for tools to expose * added VelocityToolboxView subclass, supporting Velocity Tools toolboxes and special ViewTools (part of Velocity Tools) * factored out "doRender" and "getTemplate(name)" methods in VelocityView, for easy subclassing (multiple templates etc) * factored out "doRender" and "getTemplate(name, Locale)" methods in FreeMarkerView, for easy subclassing * changed value for "selected" attribute from "true" to "selected" in Velocity and FreeMarker macros (spring.vm/ftl) * added JasperReportsXxxView to allow for convenient rendering of CSV/HTML/PDF/XLS web views with Jasper Reports * added "getModuleConfig" method to the Struts ContextLoaderPlugIn, to allow access to the ModuleConfig in subclasses * added MappingDispatchActionSupport class, as convenience subclass of Struts 1.2's MappingDispatchAction Changes in version 1.1.2 (14.11.2004) ------------------------------------- General * fixed compilation on JDK 1.5 with "-source 1.5" (renamed "enum" variables, fixed "getMethod"/"invoke" ambiguities) * renamed all remaining "*TestSuite" class to "*Tests", for consistent naming of test cases Package org.springframework.aop * added "setExposeProxy" method to Advised interface * deprecated Adviced's "getExposeProxy" and "getProxyTargetClass" in favor of "isExposeProxy" and "isProxyTargetClass" * deprecated ProxyConfig's "getOptimize" and "getOpaque" in favor of "isOptimize" and "isOpaque" * DelegatingIntroductionInterceptor now massages return type, returning the proxy if a delegate method returns "this" * reworked ProxyFactoryBean and AbstractPrototypeBasedTargetSource to leverage BeanFactory's "getType" method * moved "invokeJoinpointUsingReflection" method from aop.framework.AopProxyUtils to aop.support.AopUtils * JdkDynamicAopProxy handles "hashCode" method locally too, in addition to "equals" (mainly for remoting proxies) * factored out AbstractPointcutAdvisor class from DefaultPointcutAdvisor, extended by RegexpMethodPointcutAdvisor now * added "perl5" flag to RegexpMethodPointcutAdvisor: on uses ORO (the default), off uses the JDK 1.4 regexp package * reworked DebugInterceptor to log to Commons Logging at debug level rather than to the console Package org.springframework.beans * added support for multi-dimensional collections to BeanWrapperImpl (e.g. "map[myKey][0]" or "map[myKey][0].name") * allow arbitrary bean types passed into BeanUtils' "copyProperties" method (as long as the bean properties match) * added "getType(name)" method to BeanFactory interface, checking the type of object that "getBean" would return * added "getBeansOfType(type)" convenience method to ListableBeanFactory interface, without explicit filters * clarified FactoryBean's "getObjectType" behavior: should avoid initialization of its singleton (if possible) * moved "FACTORY_BEAN_PREFIX" constant from AbstractBeanFactory superclass up to BeanFactory interface * refactored AbstractBeanFactory's "getBean" implementation to do more aggressive upfront type checking * moved "destroyBean" implementation from AbstractAutowireCapableBeanFactory up to AbstractBeanFactory * refined internal structure and visibilities of AbstractBeanFactory and AbstractAutowireCapableBeanFactory * AbstractAutowireCapableBeanFactory properly supports custom "destroy-method" for inner bean definitions now * fixed DefaultListableBeanFactory's "getBeansOfType" implementation to correctly work with debug level logging * reworked DefaultListableBeanFactory's "getBeansOfType" implementation, always detecting FactoryBeans correctly now * added "hashCode, "equals" and "toString" implementations to ManagedMap (delegating to the target map) * PropertyPlaceholderConfigurer does not try to parse its own bean definition (ignoring unresolvable locations there) * added PropertyPathFactoryBean, allowing to evaluate the property path of a target bean and expose the result * FieldRetrievingFactoryBean considers its bean name as static field expression if no other properties specified * fixed PropertiesBeanDefinitionReader to allow bean names that contain dots * deprecated constructing an XmlBeanFactory with InputStream, in favor of using Resource which retains location info * DefaultXmlBeanDefinitionParser allows unnamed child bean definitions too (using class or parent as bean name) * DefaultXmlBeanDefinitionParser throws an exception in case of multiple "property" definitions for the same name * allow "bean*" rather than "bean+" in XML bean definitions, i.e. no bean definitions in a file (just imports) Package org.springframework.context * ConfigurableApplicationContext's "getBeanFactory" method throws an IllegalStateException if context not initialized * AbstractApplicationContext automatically registers a context-aware URLEditor now (delegating to the ResourceLoader) * AbstractApplicationContext automatically registers a context-aware ResourceArrayPropertyEditor for Resource arrays * AbstractApplicationContext publishes ContextClosedEvent before destroying singleton beans rather than afterwards * added GenericApplicationContext class, allowing for arbitrary definition formats (via a single internal BeanFactory) * StaticApplicationContext derives from GenericApplicationContext now, reusing the DefaultListableBeanFactory instance * (Reloadable)ResourceBundleMessageSource resolves messages without arguments more efficiently (i.e. no MessageFormat) * ResourceBundleMessageSource's performance significantly increased through caching ResourceBundle references * ReloadableResourceBundleMessageSource merges properties per locale for more efficient lookup (when caching forever) Package org.springframework.core * ResourceEditor resolves all placeholders in a path as system properties now, not just the first one * PathMatchingResourcePatternResolver handles "classpath:*-context.xml" style patterns now too (without leading slash) * added ResourceArrayPropertyEditor, converting location patterns to Resource arrays (via a ResourcePatternResolver) Package org.springframework.dao * deprecated IncorrectUpdateSemanticsDataAccessException's "getDataWasUpdated" method in favor of "wasDataUpdated" * added "objectResult(collection,type)" and "intResult"/"longResult(collection)" convenience methods to DataAccessUtils Package org.springframework.ejb * AbstractRemoteSlsbInvokerInterceptor treats RMI's ConnectIOException and NoSuchObjectException as connect failure too Package org.springframework.jdbc * added "extractDatabaseMetaData(dataSource,methodName)" method to JdbcUtils, performing specific DatabaseMetaData calls * reworked DataSourceTransactionObject into an inner class of DataSourceTransactionManager * deprecated JdbcTemplate's "getIgnoreWarnings" in favor of "isIgnoreWarnings" Package org.springframework.mail * added "equals" and "hashCode" implementations to SimpleMailMessage * added "setText(plainText, htmlText)" method to MimeMessageHelper, for alternative texts in the same mail * explicitly check for null values in all of MimeMessageHelper's methods, to avoid ugly NPEs (potentially in JavaMail) Package org.springframework.orm * reworked Hibernate/Jdo/PersistenceBrokerTransactionObject into inner classes of HibernateTransactionManager and co * added support for pre-bound Sessions (e.g. OpenSessionInViewFilter/Interceptor) with JTA and TransactionManagerLookup * Hibernate Session gets cleared on rollback in case of a pre-bound Session (for both Hibernate and JTA transactions) * fixed LocalSessionFactoryBean to call "configure" after "setNamingStrategy" (in case of a specified "configLocation") * added "load(entity, id)" method to HibernateOperations and HibernateTemplate * added "initialize" and "closeIterator" methods to HibernateOperations/Template, following "Hibernate.initialize/close" * added "queryCacheRegion" property to HibernateTemplate, specifying the cache region used for queries Package org.springframework.remoting * HttpInvokerClientInterceptor and RmiClientInterceptor handle "toString" method locally now, returning proxy info * (Jndi)RmiClientInterceptor treats RMI's ConnectIOException and NoSuchObjectException as connect failure too Package org.springframework.scheduling * moved "configTimeDataSourceHolder" from LocalDataSourceJobStore to SchedulerFactoryBean * fixed LocalDataSourceJobStore to suppress a shutdown attempt on a Spring-provided DataSource * added "setMisfireInstruction" to the CronTriggerBean (same as with SimpleTriggerBean) Package org.springframework.util * introduced Assert class, mainly for checking method parameters and invariants within the framework Package org.springframework.validation * DataBinder does not accept an empty String (without text content) as value for a required field * DataBinder logs a warning when suppressing a non-allowed field (i.e. a field not specified in "allowedFields") Package org.springframework.web * added convenience methods to RequestUtils for extracting and converting request parameters that are arrays * added ServletContextResourcePatternResolver, to find matching resources within a web app even in an unexpanded WAR * fixed UrlPathHelper to check for request URIs that do not start with the application's context path (rather unusual) * fixed FrameworkServlet to use "doGet"/"doPost"/"doHead" etc, to reenable proper LastModified support in controllers * fixed DispatcherServlet's HandlerExceptionResolver fallback in case of "detectAllHandlerExceptionResolvers"=false * DispatcherServlet caches chosen HandlerExecutionChain in "getLastModified", for reuse in "doService" * fixed ModelAndView to always allow adding to the model Map, even if initialized with null as model * added "addAllObjects" method to ModelAndView, for adding model objects in bulk (equivalent to getModel().putAll) * added "defaultStatusCode" property to SimpleMappingExceptionResolver, specifying the HTTP status code for error views * added "autowireMode(Name)" and "dependencyCheck" properties (for autowired handlers) to AbstractPathMapHandlerMapping * RedirectView just prepends context path if URL starts with a slash (in case of "contextRelative"=true) * UrlBasedViewResolver supports a "redirect:" prefix now, for convenient redirects through special view names * added "redirectContextRelative" and "redirectHttp10Compatible" flags to UrlBasedViewResolver, applying to "redirect:" * added "createVelocityContext" hook to VelocityView, for using a different impl of Velocity's Context interface * added "springMessage"/"springMessageText" macros for Velocity and "message"/"messageText" macros for FreeMarker * fixed AbstractExcelView to not hold the HSSFWorkbook instance in an instance variable (avoiding concurrency issues) * deprecated AbstractPdfView's "getDocument" method in favor of "newDocument" (strengthening the necessary creation) Changes in version 1.1.1 (30.9.2004) ------------------------------------ Package org.springframework.aop * modified Cglib2AopProxy to prevent protected methods from being proxied (fix for SPR-357) * introduced new IntroductionInfo interface, allowing introduction without an IntroductionAdvisor * DelegatingIntroductionInterceptor lets unchecked exceptions thrown by introduction delegates through without wrapping * HashMapCachingAdvisorChainFactory uses Commons Collections IdentityMap (if available, on JDK <= 1.4) for method cache * deprecated PoolingConfig's "getActive"/"getFree" in favor of "getActiveCount"/"getIdleCount", for consistent naming Package org.springframework.beans * MutablePropertyValues's "addPropertyValues" methods return MutablePropertyValues, for invocation chains in 1 statement * AbstractAutowireCapableBeanFactory uses Commons Collections LinkedMap (if available, on JDK <= 1.4) for managed maps * AbstractAutowireCapableBeanFactory is able to create non-public classes and invoke non-public init and destroy methods * AbstractAutowireCapableBeanFactory regards bean references for correct destruction order (not requiring "depends-on") * AbstractAutowireCapableBeanFactory regards bean references and "depends-on" for destruction order of inner beans too * removed "getDependentBeanNames" hook and implementation from AbstractAutowireCapable/DefaultListableBeanFactory * fixed DefaultListableBeanFactory's "getBeansOfType" implementation to correctly ignore abstract FactoryBeans * added "import" element for XML bean definitions, to allow for loading further bean definitions from relative paths * modified SingletonBeanFactoryLocator to work in environments where class loader resources are not on file system Package org.springframework.cache * added explicit support for EHCache via EhCacheManagerFactoryBean and EhCacheFactoryBean in the "ehcache" subpackage Package org.springframework.context * factored out the "publishEvent" method into the ApplicationEventPublisher interface, extended by ApplicationContext * added ApplicationEventPublisherAware and MessageSourceAware interfaces, to be implemented by application objects * reworked EventPublicationInterceptor to implement ApplicationEventPublisherAware rather than ApplicationContextAware * AbstractApplicationContext uses the internal MessageSource as "parentMessageSource", if the parent context allows to * AbstractMessageSource delegates to the parent's "getMessageInternal" method, to avoid "useCodeAsDefaultMessage" trap * ContextSingletonBeanFactoryLocator resource handling modified in similar fashion as for SingletonBeanFactoryLocator Package org.springframework.core * added CollectionFactory helper, abstracting linked/identity map creation (detecting JDK 1.4 and Commons Collections) * fixed "createRelative" implementation in ClassPathResource to correctly handle relative subdirectories * allow for explicit ClassLoader in ClassPathResource, DefaultResourceLoader, PathMatchingResourcePatternResolver Package org.springframework.ejb * fixed AbstractSlsbInvokerInterceptor's "create" to invoke on correct Method reference in case of "cacheHome"=false Package org.springframework.jdbc * deprecated DataSourceUtils' "getDataSourceFromJndi" methods, in favor of fetching from JNDI via JndiObjectFactoryBean * SingleConnectionDataSource and TransactionAwareDataSourceProxy do not use thread context class loader for proxies * clarified that LobHandler's getters are supposed to return Java null in case of SQL NULL (following the JDBC spec) * OracleLobHandler's getter implementations return null rather than an empty array/stream in case of SQL NULL * JdbcTemplate uses Commons Collections LinkedMap (if available, on JDK <= 1.4) for mapping result rows in lists Package org.springframework.jms * added SimpleMessageConverter102 subclass which handles BytesMessage without JMS 1.1's "getBodyLength" method * added "sessionAcknowledgeModeName" property to JmsTemplate, for specifying a JMS Session acknowledge constant by name * added acknowledge mode check to JmsTemplate and JmsTemplate102 before calling "acknowledge" on a received message * added JmsGatewaySupport convenience base class, for setting up a JmsTemplate instance via a ConnectionFactory Package org.springframework.mock * fixed MockServletContext's "getResource" implementation to correctly determine URL via Resource's "getURL" method * added full support for scoped attributes to MockPageContext, properly regarding request/session/application scope Package org.springframework.orm * LocalSessionFactoryBean exposes a config-time JTA TransactionManager before mapping resources get registered * pre-bound Hibernate Session gets set to FlushMode.AUTO for transaction synchronization, to enforce flush at commit * added "checkWriteOperations" flag to HibernateTemplate, to be able to suppress read-only check on save/update/delete * BlobSerializableType properly converts between Java null and SQL NULL, and properly handles null in its "deepCopy" * added "deepCopy" implementation to BlobSerializableType, serializing and deserializing the given value * added "applyQueryTimeout" method to JdoDialect interface, called by JdoTemplate for each created JDO query object Package org.springframework.remoting * added "addAttribute" and "getAttribute" methods to RemoteInvocation, for key-based additional invocation context Package org.springframework.test * included new "test" package in mock JAR, offering superclasses for tests requiring Spring contexts Package org.springframework.web * fixed "createRelative" implementation in ServletContextResource to correctly handle relative subdirectories * turned protected getter methods in controller implementations to public, for introspection and testing purposes * added ServletForwardingController, forwarding to a named servlet (e.g. to apply Spring HandlerInterceptors) * added ServletWrappingController, wrapping a servlet instance (e.g. to apply Spring HandlerInterceptors to Struts) * added "exposeHelpers" hook to InternalResourceView, for use by JstlView by TilesJstlView (to avoid super calls) * call ServletRequest's "removeAttribute" if a model attribute is null in InternalResourceView (e.g. for includes) * fixed resetting of previous nested path in NestedPathTag, properly working in request scope (rather than page scope) * BindStatus and BindTag can be created without Errors instance in the request too, falling back to plain value * changed MessageTag's "arguments" attribute to Object, allowing for either a String (EL/plain), Object array or Object * added "javaScriptEscape" attribute to MessageTag, to apply JavaScript escaping to output texts * added EscapeBodyTag class aka "spring:escapeBody", allowing to HTML- and/or JavaScript-escape enclosed body content * added JavaScriptUtils class to util package, containing generic code for JavaScript escaping Changes in version 1.1 final (5.9.2004) --------------------------------------- Package org.springframework.aop * ProxyFactoryBean returns full target class as object type in case of a singleton * ProxyFactoryBean avoids unnecessary creation of prototype bean just for advisor chain initialization * reworked AbstractPrototypeBasedTargetSource's target class check to look for bean class on BeanDefinition first * deprecated ThreadLocalTargetSourceStats "getObjects"/"getHits" etc in favor of "getObjectCount"/"getHitCount" etc * renamed Jdk14RegexpMethodPointcut to JdkRegexpMethodPointcut, for consistent class naming throughout the framework Package org.springframework.beans * reworked BeanWrapperImpl's property-specific custom editor handling to allow registration for uninitialized subpaths * refined BeanWrapperImpl's "findCustomEditor" to consider editors registered for all path variations without index/key * CustomDateEditor, CustomNumberEditor, StringTrimmerEditor implement "getAsText" to return empty String for null value * deprecated PagedListHolder's "getNrOfPages" in favor of "getPageCount" (for consistent method naming) * deprecated ConstructorArgumentValues' "getNrOfArguments" in favor of "getArgumentCount" (for consistent method naming) * added "applyBeanPropertyValues" method to AutowireCapableBeanFactory, for populating an existing bean instance * moved "getBeanDefinition" method from ConfigurableBeanFactory down to ConfigurableListableBeanFactory interface * added "getBeanClass", "isAbstract", "isSingleton", "isLazyInit" methods to BeanDefinition interface * added "(abstract)" marker for properties bean definitions, for parent beans that are not meant to be instantiated * added "abstract" attribute for XML bean definitions, for marking parent beans that are not meant to be instantiated Package org.springframework.ejb * reworked AbstractSlsbInvokerInterceptor's "cacheHome" feature to not hold a proxy as instance variable if not caching * added "lookupHomeOnStartup" flag to AbstractSlsbInvokerInterceptor, to be turned off for lazy fetching of home object * added "refreshHomeOnConnectFailure" to AbstractRemoteSlsbInvokerInterceptor, for automatic retry if connect failed * changed AbstractRemoteSlsbInvokerInterceptor's abstract method to "doInvoke" (warning: not backwards-compatible!) * factored out "getSessionBeanInstance" and "releaseSessionBeanInstance" methods in SimpleRemoteSlsbInvokerInterceptor Package org.springframework.jdbc * added support for SqlReturnType interface which allows us to return custom types from stored procedures * StatementCreatorUtils uses specific PreparedStatement parameter setter methods, as far as possible * added auto-conversion of java.util.Calendar to java.sql.Date/Time/Timestamp, for SQL types DATE/TIME/TIMESTAMP * added auto-conversion of java.util.Date and java.util.Calendar to java.sql.Timestamp, in case of an unknown SQL type * DataSourceTransactionObject implements the SmartTransactionObject interface, exposing an "isRollbackOnly" method * added support for WebSphere 4 to WebSphereNativeJdbcExtractor, auto-detecting WebSphere 5 and 4 now Package org.springframework.jms * JmsTransactionObject implements the SmartTransactionObject interface, exposing an "isRollbackOnly" method * reworked DynamicDestinationResolver to work with both JMS 1.1 and JMS 1.0.2 * reworked JndiDestinationResolver to delegate for dynamic destinations, by default to a DynamicDestinationResolver * added "cache" flag to JndiDestinationResolver, to allow for turning off the caching of Destination objects from JNDI * added support for ObjectMessage to SimpleMessageConverter, converting between Serializable objects and ObjectMessages Package org.springframework.jndi * added "rebind" operation to JndiTemplate, analogous to the existing "lookup", "bind" and "unbind" operations * factored out JndiAccessor base class from JndiLocatorSupport, holding "jndiTemplate" and "jndiEnvironment" properties * deprecated AbstractJndiLocator base class in favor of new JndiObjectLocator base class with explicit "lookup" method * added JndiObjectTargetSource which performs a fresh JNDI lookup for each call, allowing for hot redeployment in JNDI Package org.springframework.mail * added "createMimeMessage(InputStream)" method to JavaMailSender, building a MimeMessage from raw MIME content * allow MimeMessagePreparator implementations to throw any Exception, auto-converting them to MailPreparationExceptions * MimeMessageHelper creates "multipart/related" now, to make mails with inline images compatible with Outlook Express * added "validateAddresses" property to MimeMessageHelper (off by default), delegating to JavaMail 1.3's "validate" Package org.springframework.orm * added overloaded constructors that take a "persistentClassName" String to ObjectOptimisticLockingFailureException * added overloaded constructors that take a "persistentClassName" String to ObjectRetrievalFailureException * fixed SessionFactoryUtils' synchronization for JtaTransactionManager with a Hibernate TransactionManagerLookup * added support for direct JTA synchronization to AbstractLobType, as alternative to Spring transaction synchronization * lazily check for existing LobHandler in AbstractLobType, to allow for plain initialization during hbm2java execution * added BlobSerializableType for Hibernate, for serializing arbitrary property values to BLOBs and vice versa * added "flush" method to HibernateOperations/HibernateTemplate and JdoOperations/JdoTemplate, for eager flushing * added "autodetectDataSource" flag to Hibernate/JdoTransactionManager, to suppress automatic DataSource detection * added "getReportQueryIteratorByQuery" method to OJB PersistenceBrokerOperations and PersistenceBrokerTemplate * HibernateTransactionObject, JdoTransactionObject, PersistenceBrokerTransactionObject implement SmartTransactionObject Package org.springframework.remoting * added RemoteConnectFailureException and RemoteLookupFailureException as specialized RemoteAccessException subclasses * changed RemoteInvocationResult's exception holder to Throwable, to also transport errors thrown during reflection * factored out RMI invocation logic into RmiClientInterceptorUtils, handling both RMI and non-RMI service interfaces * renamed RmiClientInterceptor's "createRmiProxy" and "getRmiProxy" methods to "lookupStub" respectively "getStub" * added "lookupStubOnStartup", "cacheStub" and "refreshStubOnConnectFailure" flags to RmiClientInterceptor * added JndiRmiServiceExporter, for exposing PortableRemoteObject RMI services to JNDI (e.g. RMI-IIOP resp. CORBA) * added JndiRmiClientInterceptor and JndiRmiProxyFactoryBean, for fetching PortableRemoteObject RMI services from JNDI * redesigned JaxRpcPortClientInterceptor's "postProcessPortProxy(Remote)" method as "postProcessPortStub(Stub)" Package org.springframework.transaction * introduced SmartTransactionObject interface, allowing to determine an internal rollback-only marker of a transaction * DefaultTransactionStatus always retrieves current rollback-only flag, either local or from SmartTransactionObject * removed "isRollbackOnly" method from AbstractPlatformTransactionManager (superseded by SmartTransactionObject) * removed dependency on AOP Alliance AspectException from AbstractPlatformTransactionManager and JtaTransactionManager * introduced JtaTransactionObject for JtaTransactionManager, implementing the SmartTransactionObject interface * added "autodetectTransactionManager" flag to JtaTransactionManager, to suppress the UserTransaction instanceof check * added WebLogicServerTransactionManagerFactoryBean, to be used with WebLogicJtaTransactionManager on WebLogic 7.0 Package org.springframework.validation * fixed BindException to apply "getAsText" of a custom PropertyEditor even in case of a null value Package org.springframework.web * added special parsing of original filenames to CommonsMultipartFile, detecting both Unix- and Windows-style paths * made CommonsMultipartFile implement Serializable (the underlying FileItem from Commons FileUpload is serializable) * reworked AbstractPathMapHandlerMapping's "getClassesWithPathMapAttributes" to return a Class array rather than names * deprecated AbstractWizardFormController's "getNrOfPages" in favor of "getPageCount" (for consistent method naming) * fixed MessageTag to write "null" to the JspWriter in case of a null value as message * added "http10Compatible" flag to RedirectView, to be turned off for sending HTTP 1.1 status code 303 rather than 302 * added "allowRequestOverride" and "allowSessionOverride" properties to AbstractTemplateView (off by default) * added "buildPdfMetadata" callback to AbstractPdfView, for adding meta fields like author to the iText PDF Document * added LookupDispatchActionSupport class to Struts support, analogous to ActionSupport but for LookupDispatchActions Changes in version 1.1 RC2 (19.8.2004) -------------------------------------- Package org.springframework.aop * added "customizeProxyFactory" hook method in AbstractAutoProxyCreator * renamed AbstractAutoProxyCreator's "getInterceptorsAndAdvisorsForBean" method to "getAdvicesAndAdvisorsForBean" * AbstractAutoProxyCreator's "getAdvicesAndAdvisorsForBean" method takes a TargetSource as third argument now * added Jdk14RegexpMethodPointcut, building on the java.util.regex package, as alternative to Perl5RegexpMethodPointcut Package org.springframework.beans * set getter/setter methods accessible if the declaring class is not public (e.g. in case of a non-public base class) * fixed BeanWrapperImpl to always pass the original value into a TypeMismatchException, rather than a converted one * fixed "getBeansOfType" check (as used by autowiring) and "isSingleton" for parent bean definitions without class * factory methods no longer only static: an instance method can be called on a bean named by the factory-bean attribute * removed "getMethodOverrides" method from BeanDefinition interface, to avoid cyclic package dependencies * moved BeanDefinitionHolder class from factory.support to factory.config, to avoid cyclic package dependencies * CustomEditorConfigurer and ClassEditor delegate to same ClassUtils.forName method, understanding array class names * added FieldRetrievingFactoryBean, for retrieving static fields (and also non-static field values of target objects) * fixed AbstractBeanFactory's "getSingletonNames" implementation to properly synchronize on the singletonCache Map * a constructor argument value without index will now just be considered once, rather than matched multiple times * introduced BeanDefinitionReader interface, implemented by AbstractBeanDefinitionReader and subclasses * reworked XmlBeanDefinitionParser SPI (warning: not backwards-compatible!) to receive a bean definition reader Package org.springframework.context * eagerly load ContextClosedEvent class in AbstractApplicationContext, to avoid issues with WebLogic 8.1 on shutdown Package org.springframework.core * added "getFilename" and "createRelative" methods to Resource interface, with corresponding implementations * provided more efficient "equals" and "hashCode" implementations for all concrete Resource classes * ResourceEditor trims resource locations before passing them to ResourceLoader's "getResource" method Package org.springframework.jdbc * added explicit "query" methods that accept a RowMapper parameter to JdbcOperations and JdbcTemplate * added special Date checks in StatementCreatorUtils, to automatically convert to java.sql.Date/Time/Timestamp * fixed JdbcTemplate's check for parameter placeholders in plain statements, to ignore question marks in literals Package org.springframework.jms * fixed JmsTemplate's "doReceive" implementation to not try to acknowledge message if null returned after timeout * fixed JmsTemplate102's "doSend" implementation to properly work with a JMS 1.0.2 API jar in the classpath Package org.springframework.mail * added "isMultipart" method and "getMimeMultipart" accessor to MimeMessageHelper * added "addInline" methods to MimeMessageHelper, for adding inline elements with content IDs (referenced via "cid:xxx") Package org.springframework.orm * renamed HibernateOperations/HibernateTemplate's "find" methods for named parameters to "findByNamedParam" * deprecated Hibernate "findByNamedQuery" methods for named parameters in favor of "findByNamedQueryAndNamedParam" * added "entityInterceptorBeanName" property to HibernateTransactionManager, allowing to refer to a prototype bean * added "entityInterceptorBeanName" property to HibernateInterceptor, allowing to refer to a prototype bean * LocalSessionFactoryBean trims "mappingResources" locations before passing them to the ClassPathResource constructor * factored out AbstractLobType from ClobStringType, as common base class for Hibernate LOB types based on LobHandler * added BlobByteArrayType for Hibernate, mapping a BLOB to a byte array via a LobHandler (analogous to ClobStringType) * OpenSessionInViewFilter/Interceptor participate in existing thread-bound single session or deferred close mode * OpenPersistenceManagerInViewFilter/Interceptor participate in existing thread-bound single persistence manager Package org.springframework.remoting * added RemoteInvocationResult class, for convenient serialization of a method invocation result * factored out RemoteInvocationFactory and RemoteInvocationExecutor interfaces, for custom invocation contexts * added RemoteInvocationBasedAccessor and RemoteInvocationBasedExporter base classes for accessors resp. exporters * RmiClientInterceptor/ProxyFactoryBean and RmiServiceExporter support RemoteInvocationFactory/Executor interfaces * added HTTP invoker remoting strategy, providing HTTP-bases remoting via Java serialization * HttpInvokerClientInterceptor/ProxyFactoryBean and HttpInvokerServiceExporter support RemoteInvocationFactory/Executor * HttpInvokerClientInterceptor/ProxyFactoryBean support HttpInvokerRequestExecutor interface * added SimpleHttpInvokerRequestExecutor implementation that uses J2SE's HttpURLConnection class * added CommonsHttpInvokerRequestExecutor implementation that uses Jakarta Commons HttpClient Package org.springframework.scheduling * SchedulerFactoryBean reschedules triggers in case of "overwriteExistingJobs", to update triggers of persistent jobs * SchedulerFactoryBean auto-detects Quartz 1.4 vs 1.3, invoking the appropriate "addCalendar" method via reflection Package org.springframework.transaction * fixed TransactionAspectSupport's after-returning behavior to always call commit even if transaction is not new * TransactionSynchronizationManager returns a synchronization list copy (to allow a sync to register another sync) * added WebLogicJtaTransactionManager which can resume a WebLogic JTA transaction even if it was marked rollback-only Package org.springframework.validation * added "pushNestedPath"/"popNestedPath" methods to Errors interface, for convenient handling of temporary nested paths * fixed BindException's "getFieldValue" implementation to correctly apply nested paths to field error checks Package org.springframework.web * DispatcherServlet looks for handler adapters, handler mappings, exception res., view res. in ancestor contexts as well * WebContentGenerator throws RequestMethodNotSupportedException / SessionRequiredException rather than ServletException * MultiActionController logs NoSuchRequestHandlingMethodException and sends HTTP code 404, rather than rethrowing it * consider explicit finish and cancel request as form submissions in AbstractWizardFormController, even if not POST * turned AbstractWizardFormController's "validatePage" and "processCancel" non-abstract with empty implementations * added overloaded "validatePage" method with "finish" flag to AbstractWizardFormController * fixed TransformTag to derive from HtmlEscapingAwareTag and actually HTML-escape results (matching the TLD now) * fixed AbstractXsltView to apply the response encoding for XSLT transformation (doTransform takes encoding param now) * added form simplification macros for Velocity and FreeMarker, providing HTML input macros etc for easy form building * introduced JSF support in the form of a DelegatingVariableResolver that can resolve variable names as Spring beans Changes in version 1.1 RC1 (28.7.2004) -------------------------------------- Package org.springframework.aop * deprecated addInterceptor, addThrowsAdvice and other methods taking Advice subtype on Advised: use addAdvice etc * added "opaque" property to ProxyConfig as an option to prevent proxies being cast to Advised, securing configuration * fixed debug log statements to avoid invocation of "toString" method on target (not supported e.g. by Axis proxy) * AOP proxies are now Serializable if all Advisors and the TargetSource are Serializable * most framework pointcuts, advice and advisors are now Serializable * added invocableClone() method to ReflectiveMethodInvocation to allow proceed to be called more than once * added SETTERS and GETTERS constants to org.springframework.aop.support.Pointcuts * improved NameMatchMethodPointcut for programmatic use * deprecated RegexpMethodPointcut to allow for other regexp syntaxes besides Perl5: use Perl5RegexpMethodPointcut Package org.springframework.beans * BeanUtils' "instantiateClass" methods try to set the constructors accessible if given non-accessible constructors * factored out PropertyAccessor base interface from BeanWrapper * BeanWrapperImpl supports dots in keys, for example "map[my.key]" * BeanWrapperImpl's "isReadableProperty" and "isWritableProperty" properly check indexed/mapped properties * fixed BeanWrapperImpl to check for changed property values when caching nested BeanWrappers * refined BeanWrapperImpl to apply a custom editor strictly either to an array/Collection or to each of their elements * refined BeanWrapperImpl to automatically convert a value to an array with a single component when necessary * refined BeanWrapperImpl to support converting any Collection into an array rather than just a List * fixed PropertiesEditor's support for converting a Map to Properties * added ArgumentConvertingMethodInvoker subclass of MethodInvoker, converting given arguments via BeanWrapperImpl * MethodInvokingFactoryBean derives from ArgumentConvertingMethodInvoker to inherit argument conversion * fixed MethodInvokingFactoryBean's singleton initialization to properly allow for circular reference detection * fixed PropertyPlaceholderConfigurer's circular reference detection to allow repeated placeholder in single value * fixed PropertyPlaceholderConfigurer's parsing to detect all inner bean definitions (including BeanDefinitionHolder) * PropertyPlaceholderConfigurer detects and parses placeholders in map keys, rather than just in map values * PropertyPlaceholderConfigurer and PropertiesFactoryBean respect the defaults of a given Properties instance * added check to avoid stack overflow if autowiring constructor with argument that matches the currently created bean * AbstractAutowireCapableBeanFactory's "autowireConstructor" regards all constructors, just preferring public ones * reworked root/child bean definition concept, allowing to override any settings in a child (including class name) * introduced InstantiationStrategy interface, with SimpleInstantiationStrategy and CglibSubclassingInstantiationStrategy * added support for static factory methods to RootBeanDefinition and AbstractAutowireCapableBeanFactory * added support for abstract lookup methods to AbstractBeanDefinition and AbstractAutowireCapableBeanFactory * added "factory-method" attribute and "lookup-method" element to "bean" tag in spring-beans.dtd * added "parent" option to "ref" tag in spring-beans.dtd, allowing to explicitly reference a bean in the parent factory * fixed "value" parsing to also detect text nodes in case of additional comment nodes Package org.springframework.context * reworked ApplicationEventMulticaster to have a "multicastEvent" method rather than derive from ApplicationListener * renamed ApplicationEventMulticasterImpl to SimpleApplicationEventMulticaster, indicating alternative implementations * AbstractApplicationContext auto-detects an "applicationEventMulticaster" bean, using it instead of the default * added overloaded constructors with refresh flag to ClassPathXmlApplicationContext and FileSystemXmlApplicationContext Package org.springframework.core * fixed UrlResource to correctly return the underlying URL on "getURL" * defined "classpath*:" prefix in ResourcePatternResolver interface, for retrieving all matching class path resources * PathMatchingResourcePatternResolver can retrieve multiple class path resources with the same name Package org.springframework.dao * added ConcurrencyFailureException and subclasses CannotAcquireLockException and CannotSerializeTransactionException * changed OptimisticLockingFailureException to inherit from ConcurrencyFailureException * fixed DataAccessUtils' "requiredUniqueResult" method, to correctly throw an IncorrectResultSizeDataAccessException Package org.springframework.ejb * added explicit proxy type checks to LocalSlsbInvokerInterceptor and AbstractRemoteSlsbInvokerInterceptor Package org.springframework.jdbc * added support for wildcard match on database product name like "DB2*", "*DB2" or "*DB2*" for SQLErrorCodesFactory * added support for retrieving JDBC 3.0 auto-generated keys to JdbcTemplate and SqlUpdate, via a passed-in KeyHolder * added translation category for CannotAcquireLockException to SQLErrorCodeSQLExceptionTranslator and sql-error-codes * allow for defining custom translations using CustomSQLErrorCodesTranslation defined in the sql-error-codes.xml file * DataSourceUtils' "closeConnectionIfNecessary" logs error on SQLException rather than rethrowing an exception * removed CannotCloseJdbcConnectionException, as it is not used anymore * added TransactionAwareDataSourceProxy, to allow for participating in Spring transactions with plain JDBC API code * DataSourceTransactionManager closes JDBC Connection if "doBegin" fails * DataSourceTransactionManager manages nested transactions via JDBC 3.0 Savepoints * DataSourceTransactionObject implements SavepointManager to allow for savepoint management via TransactionStatus * refactored Prepared/CallableStatement.setXxx method invocations into JdbcUtils.setParameters utility method * added SqlTypeValue interface with callback method "setTypeValue" that will handle all database-specific code * added AbstractSqlTypeValue implementation with callback method "createTypeValue", avoiding statement handling * added SqlLobValue implementation of SqlTypeValue, for holding BLOB/CLOB parameter values * added support for BLOB/CLOB parameter values via SqlLobValue to JdbcTemplate, SqlUpdate and StoredProcedure * JdbcTemplate always passes SQL string to SQLExceptionTranslator, even for static queries and updates * moved "resultSetType" and "updatableResults" properties from SqlOperation up to RdbmsOperation * added BatchSqlUpdate class to jdbc.object package, for convenient execution of batch updates * adapted CommonsDbcpNativeJdbcExtractor for Commons DBCP 1.2, to support both DBCP 1.1 and 1.2 * rewrote JBossNativeJdbcExtractor with reflection, to also support ResultSet unwrapping for JBoss >= 3.2.4 * added WebSphereNativeJdbcExtractor, using WSJdbcUtil's "getNativeConnection" method (tested with WLS 5.1.0) Package org.springframework.jms * introduced an unchecked JmsException hierarchy that mirrors checked JMSExceptions * introduced JmsTemplate which allows convenient JMS access via callbacks and convenience operations * introduced MessageConverter strategy, for translating Java objects to JMS messages and back * introduced DestinationResolver strategy, for resolving destination names to JMS destinations * introduced JmsTransactionManager, for performing local transactions on a single JMS ConnectionFactory Package org.springframework.mail * added MailPreparationException, to be thrown by user code e.g. when a template cannot be rendered for mail text * added "replyTo" and "sentDate" bean properties to SimpleMailMessage, understood by JavaMailSenderImpl * added "setReplyTo" and "setSentDate" methods to MimeMessageHelper, analogous to SimpleMailMessage * added accessors for "session", "protocol", "host", "port", "username", "password" to JavaMailSenderImpl Package org.springframework.mock * MockServletContext uses JVM temp dir as ServletContext temp dir, e.g. to work with Commons/CosMultipartResolver Package org.springframework.orm * HibernateTransactionManager and JdoTransactionManager close Session resp. PersistenceManager if "doBegin" fails * HibernateTransactionManager and JdoTransactionManager allow to manage nested transactions via JDBC 3.0 Savepoints * SessionFactoryUtils and PersistenceManagerFactoryUtils log error on cleanup failure rather than rethrowing it * added "contains", "clear", "delete", "iterate" to HibernateOperations/HibernateTemplate, analogous to Session * added further overloaded "find" versions to HibernateTemplate, for direct HQL with named parameters * added "cacheQueries" property to HibernateTemplate, for marking all executed queries as cacheable * check whether flush mode is not FLUSH_NEVER before all save/update/delete operations in HibernateTemplate * HibernateTransactionManager and HibernateAccessor use SQLErrorCodeSQLExceptionTranslator if DataSource available * added deferred close option to OpenSessionInViewFilter/Interceptor, as alternative to a single session per request * removed "dataSource" property from LocalPersistenceManagerFactoryBean, as it won't work with proper JDO impls * added JdoObjectRetrievalFailureException and JdoOptimisticLockingFailureException * refined PersistenceManagerFactoryUtils' "convertJdoAccessException" implementation to become more fine-granular * reworked JdoDialect SPI (warning: not backwards-compatible!), to support more JDBC connection handling strategies * added DefaultJdoDialect implementation, used by JdoTransactionManager and JdoAccessor as default * DefaultJdoDialect uses SQLErrorCodeSQLExceptionTranslator for exception translation if DataSource if available * JdoTransactionManager supports isolation levels and timeouts via JdoDialect's "beginTransaction" method * JdoTransactionManager passes "readOnly" flag to JdoDialect's "getJdbcConnection" and invokes "releaseJdbcConnection" * introduced JdoOperations interface, with convenience methods for load, save, delete and find * JdoTemplate implements JdoOperations' convenience methods to allow for one-line data access operations * fixed JdoDaoSupport's "closeSessionIfNecessary" method to be named "closePersistenceManagerIfNecessary" * added OpenPersistenceManagerInViewInterceptor and OpenPersistenceManagerInViewFilter * introduced "orm.ojb" package, for Apache OJB support (configuration in Spring, DAO support, transactions) * introduced PersistenceBrokerTemplate/Callback, to support Apache OJB's PersistenceBroker API as DAO strategy * introduced PersistenceBrokerTransactionManager, a transaction strategy for Apache OJB's PersistenceBroker Package org.springframework.samples * added OJB data access layer to Petclinic, as alternative to the existing Hibernate and Spring JDBC strategies Package org.springframework.scheduling * removed deprecated TimerTaskExecutionException * MethodInvokingJobDetail/TimerTaskFactoryBean derive from ArgumentConvertingMethodInvoker to inherit arg conversion * added "jobSchedulingDataLocation" property to SchedulerFactoryBean, supporting Quartz 1.3's job definition XML files * added "dataSource" property to SchedulerFactoryBean, for using a Spring-managed DataSource as Quartz job store * added "overwriteExistingJobs" property to SchedulerFactoryBean, to control overwriting of persistent jobs * added "autoStartup" property to SchedulerFactoryBean, to allow for manual startup of the scheduler * added "concurrent" property to MethodInvokingJobDetailFactoryBean, to support stateful jobs if needed Package org.springframework.transaction * added "PROPAGATION_NESTED" to TransactionDefinition, for specifying a nested transacton * added SavepointManager interface as superinterface of TransactionStatus, for generic savepoint management * DefaultTransactionStatus delegates to transaction object if the latter implements the SavepointManager interface * AbstractPlatformTransactionManager applies "PROPAGATION_NESTED", invoking "doBegin" within an active transaction Package org.springframework.util * deprecated ResponseTimeMonitorImpl's "getUptime" method in favor of "getUptimeMillis" * deprecated StopWatch'sgetLastInterval"/"getTotalTime" in favor of "getLastTaskTimeMillis"/"getTotalTimeMillis" Package org.springframework.validation * added "rejectIfEmptyOrWhitespace" method to ValidationUtils, for rejecting if empty or just containing whitespace Package org.springframework.web * added IntrospectorCleanupListener to web.util package, for cleaning up JavaBeans Introspector leaks on shutdown * fixed UrlPathHelper to return servlet path for lookup if request URI does not contain servlet path (e.g. index page) * added "getContextLoader" accessor to ContextLoaderListener and ContextLoaderServlet * deprecated RequestHandledEvent's getURL/getTimeMillis/getIpAddress -> getRequestUrl/getProcessingTime/getClientAddress * added optional "sessionId" and "userName" fields to RequestHandledEvent, for easier session and user tracking * added "fieldMarkerPrefix" support to ServletRequestDataBinder, for auto-resetting via "_fieldName" marker parameters * support multiple delimited URLs in ResourceServlet, including them one by one (and taking the latest file timestamp) * added FixedLocaleResolver implementation, returning a given "defaultLocale" for any request * removed unused (and misleading) "makeThemeNameAvailable" method from AbstractThemeResolver * added "suppressValidation" callback to BaseCommandController, for suppressing validation for certain requests * added "isFormChangeRequest" callback to SimpleFormController, to enforce suppressing validation and showing form * added "getPages" method to AbstractWizardFormController, for accessing the view names in subclasses * made BindStatus class more generic, moving it to support package, keeping a deprecated subclass in tags package * added "createBindStatus" methods to RequestContext, available for JSP scriptlets and template macros * added NestedPathTag for JSP, specifying a nested path (e.g. "customer.address") that BindTag will participate in * added "getAttributesMap" method to AbstractView, to allow for "attributesMap[key]" overrides in child view definitions * added "removeFromCache" method to AbstractCachingViewResolver to make removal of cached views possible at runtime * added "exposeBindMacroHelpers" property to AbstractTemplateView, exposing a special RequestContext instance * added AbstractTemplateViewResolver for convenient setting of AbstractTemplateView's properties for all views * added FreeMarkerViewResolver as convenience subclass of AbstractTemplateViewResolver * added initial bind macro library for Velocity ("spring.vm"), automatically registered by VelocityConfigurer * added initial bind macro library for FreeMarker ("spring.ftl"), automatically registered by FreeMarkerConfigurer * reworked AbstractExcelView to be able to load a document from any Spring resource location * adapted AbstractExcelView's localization to conform to ResourceBundle conventions ("_en_US" rather than "_enUS") * added overloaded "getParameters(request)" method to AbstractXsltView, delegating to "getParameters()" by default * reworked AbstractXsltView's "doTransform" method into 2 methods to allow for specifying a custom transform result * reworked ContextLoaderPlugIn and DelegationActionProxy/RequestProcessor to support a context per Struts module Changes in version 1.0.2 (3.6.2004) ----------------------------------- Package org.springframework.aop * fixed AbstractAutoProxyCreator to not check singleton status for inner beans, avoiding NoSuchBeanDefinitionException * reworked GlobalAdvisorAdapterRegistry to hold and return a DefaultAdvisorAdapterRegistry * added "advisorAdapterRegistry" property to ProxyFactoryBean and co, with global AdvisorAdapterRegistry as default * removed unused MethodInvocationFactory interface and the corresponding bean property in the AdvisedSupport class Package org.springframework.beans * CachedIntrospectionResults uses weak references to non-cache-safe Classes that were loaded by a child classloader * CachedIntrospectionResults flushes the JavaBeans Introspector cache for each given class, for proper GC on shutdown * PropertyValue and MutablePropertyValues implement java.io.Serializable * added "addPropertyValues(PropertyValues)" and "addPropertyValues(Map)" methods to MutablePropertyValues * refined BeanWrapperImpl's use of exceptions, adding InvalidPropertyException and NotReadablePropertyException * BeanWrapperImpl registers default PropertyEditors per instance and applies them to non-String values too * BeanWrapperImpl registers default editors for Boolean and all Number classes (not allowing empty values) * fixed BeanWrapperImpl's custom editor detection to avoid potential NPE in case of indexed/mapped properties * BeanWrapperImpl properly ignores unknown indexed properties too (if told to ignore unknown properties) * ClassEditor properly handles "java.lang.String[]"-style array class names, converting them to array classes * fixed CustomBooleanEditor, CustomDateEditor and CustomNumberEditor to properly handle null values in "getAsText" * reworked CustomNumberEditor to alternatively work with default "valueOf"/"toString" methods instead of NumberFormat * PropertiesEditor supports population of java.util.Properties from a java.util.Map, for example from an XML "map" tag * PagedListHolder supports setting of both "page" and "pageSize" in same request, without interference * added AbstractFactoryBean class as superclass for FactoryBeans that are capable of both singletons and prototypes * reworked List/Map/Set/PropertiesFactoryBean to extend from AbstractFactoryBean * renamed PropertiesFactoryBean's "charset" property to "fileEncoding", for consistency with other encoding properties * added ObjectFactory interface and ObjectFactoryCreatingFactoryBean, for non-intrusive creation of prototype beans * added BeanDefinitionHolder class to beans.factory.support package, holding a BeanDefinition plus name and aliases * AbstractAutowireCapableBeanFactory detects BeanDefinitionHolder, applying its name to a BeanNameAware inner bean * AbstractAutowireCapableBeanFactory catches Throwable on bean creation, rethrowing as meaningful BeanCreationException * AbstractAutowireCapableBeanFactory cleans up eagerly cached singletons in case of bean creation failure * DefaultListableBeanFactory cleans up already created singletons in case of preInstantiateSingletons failure * DefaultXmlBeanDefinitionParser registers BeanDefinitionHolder for inner bean definition, including name and aliases * DefaultXmlBeanDefinitionParser resolves "map" tag as LinkedHashMap on JDK 1.4, falling back to HashMap on JDK 1.3 Package org.springframework.context * added ResourceMapFactoryBean class to context.support, for resolving properties into a Map with Resource values * fixed AbstractMessageSource's parent checks to correctly respect the child's "useCodeAsDefaultMessage" setting * fixed (Reloadable)ResourceBundleMessageSource to correctly cache MessageFormats for a specific Locale * added overloaded DefaultMessageSourceResolvable constructor that takes a single "codes" argument * AbstractApplicationContext uses ResourceEditor with ResourceLoader argument rather than former ContextResourceEditor * removed AbstractApplicationContext's "resolveConfigLocations" method, superseded by ResourcePatternResolver mechanism * added "getResourcePatternResolver" callback to AbstractXmlApplicationContext, for resolving config location patterns * AbstractXmlApplicationContext uses default PathMatchingResourcePatternResolver for Ant-style config location patterns * ResourceEntityResolver URL-decodes systemId to allow for proper matching with unencoded system root URL in any case Package org.springframework.core * reworked ResourceEditor to take ResourceLoader argument in overloaded constructor * added ResourcePatternResolver strategy interface, for resolving a location pattern into Resource objects * added PathMatchingResourcePatternResolver implementation, supporting Ant-style path patterns via PathMatcher utility Package org.springframework.dao * added IncorrectResultSizeDataAccessException, thrown when a result was not of the expected size (e.g. <>1) * added DataAccessUtils class to support package, providing "uniqueResult" and "requiredUniqueResult" helper methods Package org.springframework.ejb * added "cacheHome" property to AbstractSlsbInvokerInterceptor, for refetching the EJB home on each method invocation * invoke "remove" on EJB proxy after invocation in LocalSlsbInvokerInterceptor and SimpleRemoteSlsbInvokerInterceptor Package org.springframework.jdbc * added UserCredentialsDataSourceAdapter, for transparently appying username and password to target DataSource calls * fixed a NPE in SQLErrorCodeSQLExceptionTranslator for custom error translator that did not have DataSource set * added NativeJdbcExtractorAdapter as convenient base class for NativeJdbcExtractor implementations * reworked SimpleNativeJdbcExtractor to use DatabaseMetaData.getConnection() rather than Statement.getConnection() * added WebLogicNativeJdbcExtractor, using WLConnection's "getVendorConnection" method (tested in WLS 8.1 SP2) * added "query(sql, args, resultSetExtractor)"-style methods to JdbcOperations interface and JdbcTemplate class * changed JdbcTemplate's "queryForList" to return List of LinkedHashMap if JDK version >=1.4 (to preserve column order) * refactored SqlParameter's inner ResultReaderStoredProcImpl class into reusable RowMapperResultReader adapter * JdbcTemplate's "call" method and the StoredProcedure class support ResultSetExtractors for out parameters * added LobRetrievalFailureException, typically wrapping an IOException thrown by stream access methods * added AbstractLobStreamingResultSetExtractor, offering conversion of IOException to LobRetrievalFailureException * added AbstractLobCreatingPreparedStatementCallback, offering convenient usage of a LobCreator for LOB updates * changed visibility of JdbcDaoSupport's resource factory accessors to public Package org.springframework.jndi * added protected "lookup" method to AbstractJndiLocator, for refetching the cached JNDI object on demand Package org.springframework.mock * factored out JNDI mock objects from org.springframework.jndi.support (source tree) to separate mock source tree * factored out Servlet API mock objects from org.springframework.web.mock (test tree) to separate mock source tree * reworked Servlet API mock objects to provide comprehensive support for request/response-driven testing * reworked framework test suite to solely use Spring-provided mocks rather than ones from the MockObjects project Package org.springframework.orm * added "namingStrategy" property to LocalSessionFactoryBean, for specifying a custom Hibernate NamingStrategy * SessionFactoryUtils autodetects JTA TransactionManager with Hibernate JCA Connector too, for Session synchronization * changed visibility of HibernateDaoSupport's and JdoDaoSupport's resource factory accessors to public * changed visibility of SqlMapDaoSupport's and SqlMapClientDaoSupport's resource factory accessors to public * added "dataSource" property to SqlMapClientFactoryBean, as alternative to specifying per-DAO DataSource references * added "queryWithRowHandler" method to SqlMapClientOperations/Template, following iBATIS SQL Maps 2.0 RC4 * added "queryForPaginatedList" method to SqlMapClientOperations/Template, enabled through SqlMapClient DataSource Package org.springframework.remoting * exposed "overloadEnabled" property in HessianClientInterceptor and BurlapClientInterceptor * factored out proxy creation into "createHessianProxy"/"createBurlapProxy" method in Hessian/BurlapClientInterceptor Package org.springframework.samples * changed JPetStore's Axis namespace to "urn:JPetStore" (also made namespace configurable at client side) * reworked DefaultImageDatabase implementation to leverage new convenience classes for row mapping and LOB handling Package org.springframework.scheduling * changed MethodInvokingTimerTaskFactoryBean to log an invocation exception at error level rather than rethrowing it * deprecated TimerTaskExecutionException, as it's generally recommendable to not throw an exception from a TimerTask * QuartzJobBean applies SchedulerContext entries as bean properties, just like it also does for JobDataMap entries * added "schedulerContextAsMap" property to SchedulerFactoryBean, for specifying parameter entries for all Jobs * added "applicationContextSchedulerContextKey" property to SchedulerFactoryBean, for exposing the ApplicationContext Package org.springframework.transaction * added "transactionAttributes" property to TransactionInterceptor, analogous to TransactionProxyFactoryBean * reworked TransactionSynchronizationManager to completely remove the ThreadLocal resource Map if no resource bound Package org.springframework.ui * added "velocityPropertiesMap" property to VelocityEngineFactory, to allow for passing non-String values to Velocity Package org.springframework.util * fixed MethodInvoker's handling of null arguments, to properly allow for any null values * added "copy(String, Writer)" and "copyToString(Reader)" methods to FileCopyUtils * added "cleanPath" and "pathEquals" methods to StringUtils Package org.springframework.validation * added support for "xxx*" field patterns to BindException's "getFieldErrors" and "getFieldError" methods * added "getArgumentsForBindingError" method to DataBinder, for missing required fields and for type mismatches * default argument for DataBinder binding errors is MessageSourceResolvable with "objectName.field"/ "field" as codes * fixed DefaultMessageCodesResolver to check whether field type is null (e.g. in case of an empty map entry) Package org.springframework.web * WebUtils' "setWebAppRootSystemProperty" method uses StringUtils.pathEquals when checking an existing property value * fixed MultipartFile.isEmpty implementation for both Commons FileUpload and COS, also checking the file size * fixed ServletRequestDataBinder to correctly check for required fields in case of a multipart request * added public "setFilterConfig"/"getFilterConfig" methods to GenericFilterBean, for compatibility with WebLogic 6.1 * reworked FilterConfigPropertyValues into inner class of GenericFilterBean * added implicit registration of context-specific ResourceEditor to GenericFilterBean and HttpServletBean * added "initBeanWrapper" callbacks to GenericFilterBean and HttpServletBean, to allow for registering custom editors * refined ViewResolver's "resolveViewName" to expect null return value if not found, to allow for ViewResolver chaining * DispatcherServlet detects ViewResolvers by type to allow for ViewResolver chaining (respecting order values) * added "detectAllHandlerMappings"/"...HandlerExceptionResolvers"/"...ViewResolvers" properties to DispatcherServlet * XmlViewResolver, ResourceBundleViewResolver and BeanNameViewResolver implement Ordered to allow for order values * XmlViewResolver and ResourceBundleViewResolver clean up their view bean factories on context shutdown * added AbstractTemplateView, allowing request and session attributes to be exposed in FreeMarker and Velocity views * refined HttpSession checks in WebContentGenerator and AbstractController to allow for easier mocking * added "cacheMappings" property to WebContentInterceptor, for overriding cache seconds for specific URL paths * added "throws Exception" to ParameterizableViewController's "handleRequestInternal" method, for easier subclassing * added "validators" property to BaseCommandController, allowing to specify multiple Validators per controller * removed final marker from SimpleFormController's "showForm" implementation, allowing to override it for special cases * added "doSubmitAction" template method to SimpleFormController, for submit actions without caring about ModelAndView * changed AbstractFormController's "getFormSessionAttributeName" to use class name rather than Class.toString * changed AbstractWizardFormController's "getPageSessionAttributeName" to use class name rather than Class.toString * AbstractWizardFormController's checks for page-specific binding errors, showing the corresponding page again * AbstractWizardFormController's "getCurrentPage" method can be invoked from "processFinish" implementations * AbstractWizardFormController optionally supports "_page" request parameter, for proper handling of back button usage * added "getNrOfPages" method to AbstractWizardFormController, for determining whether last page has been reached * reworked JSP tag implementations to implement the TryCatchFinally interface for eager resource cleanup * added support for "person.na*"/"person.address.*"-style field patterns to BindTag's "path" attribute * factored out common Struts Action delegation code from DelegationActionProxy to DelegatingActionUtils * added Struts DelegatingRequestProcessor and DelegatingTilesRequestProcessor as alternatives to DelegatingActionProxy Changes in version 1.0.1 (22.4.2004) ------------------------------------ Package org.springframework.aop * added "addBeforeAdvice"/"addAfterReturningAdvice"/"addThrowsAdvice" methods to Advised, available on all AOP proxies * added "addAfterReturningAdvice" method to AdvisedSupport * refined usage of AopConfigException, to avoid cyclic dependencies between org.springframework.aop subpackages * moved internal class AopUtils from package aop.framework.support to aop.support, to avoid cyclic package dependencies * renamed AbstractPrototypeTargetSource to AbstractPrototypeBasedTargetSource * renamed AbstractPrototypeTargetSourceCreator to AbstractPrototypeBasedTargetSourceCreator * fixed interface implementation check in DelegatingIntroductionInterceptor to also detect super-interfaces Package org.springframework.beans * added "getPropertyType" method to BeanWrapper/BeanWrapperImpl, capable of checking indexed/mapped elements * BeanWrapperImpl allows registration of custom editors for array/List/Map properties * BeanWrapperImpl allows registration of custom editors for specific elements of array/List/Map properties * fixed CustomBooleanEditor, CustomDateEditor and CustomNumberEditor to parse null texts as null values * added InputStreamEditor to standard PropertyEditors, for creating java.io.InputStream instances from String locations * added ByteArrayPropertyEditor to standard PropertyEditors, for turning Strings into their byte representations * added DestructionAwareBeanPostProcessor subinterface, adding a before-destruction callback * AbstractBeanFactory overrides parent bean if child name equals parent name (rather than causing a stack overflow) * AbstractAutowireCapableBeanFactory throws more expressive exceptions if a custom init-method failed * AbstractAutowireCapableBeanFactory throws an exception if a BeanPostProcessor returns null as bean instance Package org.springframework.core * added check whether cause is "this" to NestedRuntime/CheckedException, to avoid stack overflow in obscure scenarios Package org.springframework.context * AbstractXml/StaticApplicationContext use internal bean factory of parent context as parent for their bean factory * AbstractXml/StaticApplicationContext properly check parent context for referenced parent beans (bean parent="...") * removed unused default constructor and protected setters from DefaultMessageSourceResolvable * AbstractMessageSource returns default message if passed-in message code is null * AbstractMessageSource just falls back to message code as message if no default message given * AbstractMessageSource's "getMessageInternal" method returns null instead of throwing NoSuchMessageException * added "resolveConfigLocations" method to AbstractApplicationContext, resolving file patterns via PathMatcher * AbstractXmlApplicationContext resolves its config locations via "resolveConfigLocations" to allow for file patterns * EventPublicationInterceptor implements ApplicationContextAware rather than extending ApplicationObjectSupport Package org.springframework.jdbc * fixed JdbcTemplate's "queryForList" to correctly handle a single row with a single column as result * added "setSqlReadyForUse" method to StoredProcedure, for indicating that the SQL should be used as provided * SQLErrorCodesFactory caches database product name in a Map based on DataSource to avoid unnecessary metadata lookups * added property "useSqlStateForTranslation" to SQLErrorCodes to allow for translation of PostgreSQL state codes * added "extractDatabaseMetaData" method to JdbcUtils, using the DatabaseMetaDataCallback interface as parameter Package org.springframework.orm * fixed Hibernate Session unbinding in case of JtaTransactionManager with flush failure im beforeCommit synchronization * added support for transaction-scoped Sessions with plain JTA or EJB CMT, without JtaTransactionManager being involved * added explicit auto-commit handling to LocalSessionFactoryBean's "executeSchemaScript" method * SqlMapClientTemplate closes the SqlMapSession even if JDBC Connection retrieval or closing failed Package org.springframework.remoting * refined exceptions thrown by RmiClientInterceptor's "createRmiProxy" and RmiProxyFactoryBean's "afterPropertiesSet" * added "getApplicationContext" method to ServletEndpointSupport, as alternative to "getWebApplicationContext" Package org.springframework.scheduling * added "applicationContextJobDataKey" property to JobDetailBean, for exposing the ApplicationContext in the JobDataMap Package org.springframework.transaction * fixed AbstractPlatformTransactionManager's handling of beforeCompletion callbacks in case of beforeCommit failures * added WebSphere 5.1 check to WebSphereTransactionManagerFactoryBean (covering versions 5.1, 5.0 and 4 now) Package org.springframework.util * added "retrieveMatchingFiles" method to PathMatcher, retrieving matching files from a directory tree * added "isPattern" method to PathMatcher, checking whether a given string has to be matched via the "match" method Package org.springframework.validation * fixed bug where DataBinder would choke on null values of required fields, resulting in an NPE * factored out message code resolution into MessageCodesResolver strategy, with DefaultMessageCodesResolver impl * DefaultMessageCodesResolver generates codes for specific elements and the whole collection in case of array/List/Map * DefaultMessageCodesResolver generates code for the type of a field, e.g. "typeMismatch.java.lang.String" * DefaultMessageCodesResolver generates code for the object name in case of an ObjectError, e.g. "myError.myForm" Package org.springframework.web * WebApplicationObjectSupport applies lazy WebApplicationContext type check to facilitate easier unit testing * added MaxUploadSizeExceededException to multipart package, as a specific subclass of MultipartException * CommonsMultipartResolver and CosMultipartResolver throw MaxUploadSizeExceededException when appropriate * fixed HttpServletBean's support for required properties, renaming "setRequiredProperty" to "addRequiredProperty" * apply HandlerExceptionResolvers also if multipart resolution of handler mapping failed (passing in null as handler) * added "messageCodesResolver" property to BaseCommandController, available to all command and form controllers * added overloaded "onBind" method with an additional BindException parameter to BaseCommandController * added overloaded "onSubmit" method with just command and BindException parameters to SimpleFormController * added "getThemeMessage" methods to RequestContext, for easy access to theme-specific messages in non-JSP views * added "arguments" property to MessageTag, allowing to specify a comma-delimited list of String message arguments * activated MessageTag's and ThemeTag's "var" and "scope" properties in Tag Library Descriptor (spring.tld) * reworked ComponentControllerSupport class for Tiles to be compatible with both Struts 1.1 and Struts 1.2 * added Struts ActionSupport and DispatchActionSupport base classes, for easy access to a Spring context from Actions * added Struts ContextLoaderPlugIn and DelegatingActionProxy, superseding Don Brown's S