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 Spring Struts Plugin Changes in version 1.0 final (24.3.2004) ---------------------------------------- Package org.springframework.aop * upgraded to release 1.0 of the AOP Alliance interfaces * removed attachment feature on MethodInvocation * all Spring advices extend org.aopalliance.aop.Advice tag interface * introduced frozen flag on ProxyConfig, to be used to disable advice changes * deleted MethodAfterReturningAdvice, as AfterReturningAdvice superclass is sufficient * fixed too eager initialization of common interceptors in AbstractAutoProxyCreator, potentially causing circular refs * renamed AdvisorAutoProxyCreator to DefaultAdvisorAutoProxyCreator, to distinguish it from its abstract superclass * all pre-built Advisors implement the Ordered interface, offering a "order" bean property for specifying a value Package org.springframework.beans * added support for directly setting array, List and Map elements to BeanWrapperImpl * added support for fetching a Set element via an index to BeanWrapperImpl, applying the index to the Set Iterator * removed BeanWrapperImpl's "invoke" method which lacked sophistication like support for overloaded methods * fixed BeanWrapperImpl's custom editor detection for indexed and mapped properties * fixed BeanWrapperImpl's default editor registration to use classes rather than instances, for thread-safety * fixed BeanWrapperImpl's conversion of Lists to arrays to correctly convert to primitive arrays * fixed BeanWrapperImpl's population of an array when given a single value * added BeanDefinition interface, used by ConfigurableBeanFactory to return property and constructor argument values * adapted BeanDefinitionRegistry interface and AbstractBeanFactory base class to BeanDefinition interface * refined AbstractAutowireCapableBeanFactory's use of synchronization, particularly with custom editors * refined AbstractAutowireCapableBeanFactory's "destroyBean" implementation to detect "shutdown(boolean force)" methods * fixed type difference weight algorithm in AbstractAutowireCapableBeanFactory to ignore non-matching arguments * reworked DefaultListableBeanFactory's bean definition registry to respect the order of registration * fixed DefaultListableBeanFactory's "getBeanDefinitionNames" implementation to ignore directly registered singletons * CustomEditorConfigurer implements Ordered interface, to support ordered invocation of BeanFactoryPostProcessors * added "ignoreUnresolvablePlaceholders" property to PropertyPlaceholderConfigurer * reworked PropertiesFactoryBean to work with PropertiesPersister strategy * trim the text value of a "prop" tag to avoid unwanted whitespace caused by typical XML formatting Package org.springframework.context * ApplicationContext interface extends ResourceLoader interface * added "addBeanFactoryPostProcessor" method to ConfigurableApplicationContext interface * AbstractApplicationContext implements resource loading through extending DefaultResourceLoader * reworked AbstractXmlApplicationContext to use a "getConfigLocations" template method * ClassPathXmlApplicationContext extends AbstractXmlApplicationContext rather than FileSystemXmlApplicationContext * added "postProcessBeanFactory" hook to AbstractApplicationContext * added ResourceLoaderAware and MessageSourceAware interfaces, for expressing simpler dependencies * AbstractMessageSource supports resolution of message arguments that are MessageSourceResolvables themselves * renamed AbstractMessageSource's "resolve" method to "resolveCode" * refined ReloadableResourceBundleMessageSource's use of synchronization * reworked ReloadableResourceBundleMessageSource to work with ResourceLoader instead of ApplicationContext * reworked ReloadableResourceBundleMessageSource to work with PropertiesPersister strategy * added encoding support to ReloadableResourceBundleMessageSource, via "defaultEncoding" and "fileEncodings" Package org.springframework.core * added ResourceLoader interface, extended by the ApplicationContext interface * factored out default loading strategy from ResourceEditor into DefaultResourceLoader implementation * fixed CLASSPATH_URL_PREFIX check in ResourceEditor * log warning message rather than throw an exception if ResourceEditor cannot resolve a system property * decode URL file path before using it to construct a File in UrlResource and ClassPathResource Package org.springframework.jdbc * refined SimpleNativeJdbcExtractor's "getNativeConnectionFromStatement" implementation * added generic StatementCallback, PreparedStatementCallback and CallableStatementCallback interfaces * added SqlProvider interface, typically implemented by PreparedStatementCreators and CallableStatementCreators * added "execute" methods to JdbcTemplate and JdbcOperations, taking XxxStatementCallback implementations as actions * all "query" methods that take a RowCallbackHandler return a List, passing through a results List from a ResultReader * renamed "doWithResultSetFromStaticQuery" and "doWithResultSetFromPreparedStatement" to "query" * removed JdbcTemplate's "update" method that takes a PreparedStatementCreator array * added "queryForLong" methods to JdbcTemplate class and JdbcOperations interface * fixed number detection for JdbcTemplate's "queryForInt" and "queryForLong" * added ResultSet type support to PreparedStatementCreatorFactory, CallableStatementCreatorFactory, and SqlOperation Package org.springframework.jndi * added "jndiEnvironment" property to AbstractJndiLocator, for simplified configuration of JNDI environment settings * renamed ContextCallback interface to JndiCallback Package org.springframework.mail * added character encoding support to MimeMessageHelper, allowing to specify an encoding for the entire message * added overloaded "setTo"/"setCc"/"setBcc" methods to MimeMessageHelper, with InternetAddress arguments * added "addTo"/"addCc"/"addBcc" methods to MimeMessageHelper, supporting automatic encoding of personal names Package org.springframework.orm * reworked LocalSessionFactoryBean's schema support, providing "drop/create/updateDatabaseSchema" methods * LocalSessionFactoryBean keeps the Hibernate Configuration object, allowing access via the "getConfiguration" method * added "createCriteria" method to HibernateTemplate, for creating Criteria objects that respect transaction timeouts * added "loadAll(Class)" method to HibernateTemplate and HibernateOperations, for retrieving all instances of a class * added overloaded "findByNamedQuery" methods for named parameters to HibernateTemplate and HibernateOperations * added HibernateTemplate's "execute" and "executeFind" methods to HibernateOperations interface * allow for ClobStringType to be instantiated without LobHandler, for use with Hibernate's SchemaExport tool * adapted iBATIS SQL Maps 2 support to SQL Maps 2.0 RC1, calling the new SqlMapSession.close method * changed SqlMapClientCallback's "doInSqlMapSession(SqlMapSession)" method to "doInSqlMapClient(SqlMapExecutor)" Package org.springframework.scheduling * fixed SchedulerFactoryBean's JobDetail auto-registration when multiple triggers refer to the same JobDetail * added TimerTaskExecutionException to be thrown by TimerTask impls, analogous to Quartz' JobExecutionException Package org.springframework.transaction * AbstractPlatformTransactionManager does not attempt rollback when afterCompletion callback throws an exception * added "transactionAttributeSource" property to TransactionProxyFactoryBean, for specifying any attribute source * renamed TransactionAttributeSourceTransactionAroundAdvisor to TransactionAttributeSourceAdvisor * TransactionAttributeSourceAdvisor has default ordering behavior rather than an order value of 10 * JotmFactoryBean implements DisposableBean to stop a locally created JOTM instance on context shutdown Package org.springframework.ui * added SpringResourceLoader adapter that can load a Velocity resource via any Spring ResourceLoader * reworked Velocity resource loader path handling to automatically adapt to any kind of Spring resource location * added overloaded "mergeTemplate" methods that support file encodings to VelocityEngineUtils * removed "exposeModelAsContextAttributes" method from VelocityEngineUtils * added FreeMarker support (analogous to Velocity): FreeMarkerConfigurationFactory, FreeMarkerConfigurationFactoryBean Package org.springframework.util * added ObjectUtils class, containing the "nullSafeEquals" method formerly found in StringUtils * added PropertiesPersister interface, to factor out properties parsing strategies * added DefaultPropertiesPersister implementation, capable of loading properties files with a specific charset Package org.springframework.validation * added "getNestedPath" method to Errors interface * Errors allows paths that end with a dot as "setNestedPath" arguments Package org.springframework.web * updated HtmlUtils to more efficient implementation by Chris Wilson * added "getRequiredSessionAttribute" method to WebUtils * changed WebUtils' "getOrCreateSessionAttribute" signature from HttpServletRequest to HttpSession * added "defaultEncoding" property and "determineEncoding" method to UrlPathHelper * reworked CommonsMultipartResolver's "headerEncoding" property into "defaultEncoding" * added "determineEncoding" method to CommonsMultipartResolver, checking the request encoding with fallback to default * reworked CosMultipartResolver's "headerEncoding" property into "defaultEncoding" * added "determineEncoding" method to CosMultipartResolver, checking the request encoding with fallback to default * added ServletContextAware interface for application beans, to be detected by web application contexts * reworked CommonsMultipartResolver and CosMultipartResolver to implement ServletContextAware * added CharacterEncodingFilter, for specifying a character set for requests (typically not sent by current browsers) * reworked ContextLoader and WebApplicationContextUtils to remember exceptions thrown on root context initialization * added "bindEmptyMultipartFiles" setting to ServletRequestDataBinder * added "onBind" callback to BaseCommandController, for customized processing after binding but before validation * AbstractFormController invokes "formBackingObject" on submission rather than "getCommand", if no session form * added "setView" and "setViewName" mutators to ModelAndView, to allow for post-processing in a HandlerInterceptor * fixed AbstractCachingViewResolver's caching to use appropriate synchronization * added "contextRelative" flag to RedirectView, to automatically prepend the context path to a given URL * refactored TilesView to delegate to various protected methods, for easy subclassing * fetch DefinitionsFactory on initialization of TilesView, throwing a proper exception if not found * do not set content type in TilesView, not even if the response is not committed yet * do not try to send HTTP errors in TilesView but rather throw ServletExceptions * added support for path attribute to TilesView, for overriding the path of the layout page in a component controller * removed default config location from VelocityConfigurer (specify a custom config location instead) * removed unused "writerPoolSize" property from VelocityView * added "encoding" property to VelocityView, for specifying a view-specific file encoding * removed model attribute conversion of dots to underscores from VelocityView * added FreeMarker support (analogous to Velocity): FreeMarkerConfig, FreeMarkerConfigurer, FreeMarkerView Changes in version 1.0 RC2 (1.3.2004) ------------------------------------- Package org.springframework.aop * simplified Advisor interface hierarchy, reducing Advisor subinterfaces to PointcutAdvisor and IntroductionAdvisor * adapted metadata-driven auto-proxying support and tests to Commons Attributes snapshot from January 15th Package org.springframework.beans * fixed PropertyValue's "equals" implementation, added corresponding "hashCode" implementation * apply custom property editors to converted String array values in BeanWrapperImpl * CustomNumberEditor supports Short, BigInteger and BigDecimal too * refactored AbstractBeanFactory into AbstractBeanFactory and AbstractAutowireCapableBeanFactory * revised BeanFactoryLocator exception handling * renamed SimpleJndiBeanFactoryLocator to JndiBeanFactoryLocator * added "systemPropertiesMode" setting to PropertyPlaceholderConfigurer, with values "never", "fallback" and "override" * added PreferencesPlaceholderConfigurer, being able to resolve placeholders via J2SE 1.4 Preferences * added CustomEditorConfigurer, for registering custom PropertyEditors in a declarative way * reworked MethodInvocationFactoryBean to derive from org.springframework.util.MethodInvoker * added "null" tag to XML bean definition format, for denoting Java null values * added optional "type" attribute to "constructor-arg" tag, for resolving ambiguities when converting String values Package org.springframework.context * renamed JndiBeanFactoryLocator to ContextJndiBeanFactoryLocator * renamed DefaultBeanFactoryLocator to ContextSingletonBeanFactoryLocator * renamed LocatorFactory to DefaultLocatorFactory * fixed "useCodeAsDefaultMessage" fallback for multiple codes in a MessageSourceResolvable * renamed NestingMessageSource to HierarchicalMessageSource and AbstractNestingMessageSource to AbstractMessageSource * fixed bug in ReloadableResourceBundleMessageSource's filename caching that prevented loading from multiple basenames * added "clearCacheIncludingAncestors" method to ReloadableResourceBundleMessageSource * added "createBeanFactory" and "initBeanDefinitionReader" hooks to AbstractXmlApplicationContext Package org.springframework.core * added "getURL" method to Resource interface, supported by FileSystem/ClassPath/ServletContextResource * ClassPathResource returns a File on "getFile" if the classpath resource resides in the file system Package org.springframework.ejb * moved logger instance from AbstractEnterpriseBean to AbstractStatelessSession Bean and AbstractMessageDrivenBean * propagate BeansException in AbstractStatelessSessionBean's "ejbCreate" rather than wrapping it in a CreateException Package org.springframework.jdbc * moved CannotGetJdbcConnectionException and CannotCloseJdbcConnectionException to root jdbc package * added support for new SQL error code categories: DataRetrieval/OptimisticLocking/DataAccessResourceFailureException * added "execute(String sql)" method to JdbcTemplate, supporting static SQL and DDL statements * renamed JdbcTemplate's "execute(CallableStatementCreator csc, List declaredParameters)" method to "call" * added overloaded "query" methods to JdbcTemplate, allowing to pass in prepared statement arguments as Object array * added "queryForList"/"queryForObject"/"queryForInt" methods to JdbcTemplate class and JdbcOperations interface * allowed ResultSetExtractor's "extractData" and JdbcTemplate's "doWithResultSetXxx" to return a result object * removed "doWithResultSetXxx" methods from JdbcOperations interface * removed JdbcHelper and its helper classes ColumnExtractor and DefaultColumnExtractor * revised DataFieldMaxValueIncrementer implementation hierarchy, removed NextMaxValueProvider inner classes * factored out AbstractSequenceMaxValueIncrementer from OracleSequenceMaxValueIncrementer, with no value cache * added PostgrSQLSequenceMaxValueIncrementer as subclass of AbstractSequenceMaxValueIncrementer Package org.springframework.jndi * renamed the "inContainer" property to "resourceRef", and changed the default value from "true" to "false" Package org.springframework.mail * added "javaMailProperties" to JavaMailSender, for creating a Session with specific JavaMail properties Package org.springframework.orm * reworked LocalSessionFactoryBean's "configLocation" into Resource * added "mappingLocations" and "mappingDirectoryLocations" to LocalSessionFactoryBean, each taking a Resource array * reworked LocalSessionFactoryBean's "mappingResourceJars" property into "mappingJarLocations" Resource array * auto-detect DataSource in HibernateTransactionManager if configured with LocalDataSourceConnectionProvider * flush Hibernate sessions when using JtaTransactionManager with pre-bound Sessions (e.g. with Open Session in View) * added "dataSource" property to LocalPersistenceManagerFactoryBean, for specifying a DataSource as connection factory * auto-detect DataSource in JdoTransactionManager if PersistenceManagerFactory has a DataSource as connection factory * added support for the SqlMapClient API of iBATIS SQL Maps 2 (SqlMapClientFactoryBean/Template/Callback/Operations) * added SqlMapClientDaoSupport class for DAOs that work with iBATIS SQL Maps 2 Package org.springframework.remoting * added support for custom RMI socket factories to RmiServiceExporter * unbind RMI object from RMI registry on shutdown of RmiServiceExporter * renamed RemoteInvocationHandler/RemoteInvocationWrapper to RmiInvocationHandler/RmiInvocationWrapper * RmiInvocationHandler uses RemoteInvocation class as argument, allowing for custom subclasses with additional params Package org.springframework.samples * added optional SendOrderConfirmationEmailAdvice to JPetStore, illustrating MethodAfterReturningAdvice and MailSender * added scheduling demo to Image Database sample app, illustrating Quartz and Timer, also showing MailSender usage Package org.springframework.scheduler * added Quartz support, for setting up Schedulers, JobDetails and Triggers in a Spring context * added QuartzJobBean, a convenience class that applies the Quartz job data map as bean properties * added MethodInvocationJobDetailFactoryBean, a convenience class for delegating a job to a business method * added J2SE Timer support, for setting up Timers and ScheduledTimerTasks * added MethodInvocationTimerTaskFactoryBean, a convenience class for delegating a task to a business method Package org.springframework.transaction * consider a JTA transaction with STATUS_MARKED_ROLLBACK as existing transaction in JtaTransactionManager Package org.springframework.ui * renamed NestingThemeSource to HierarchicalThemeSource * removed AbstractXmlUiApplicationContext and StaticUiApplicationContext base classes (use UiApplicationContextUtils) Package org.springframework.util * removed package path utility methods from ClassLoaderUtils * added MethodInvoker, a base class for MethodInvocationFactoryBean and MethodInvocationJobDetailFactoryBean Package org.springframework.validation * added "allowedFields" property to DataBinder, to avoid unwanted modifications when binding request parameters * added overridable "isAllowed" method to DataBinder Package org.springframework.web * added "defaultMethod" property to ParameterMethodNameResolver * added "numberToolAttribute" to VelocityView, for exposing a locale-aware NumberTool (from Velocity Tools 1.1) * added "velocityFormatter" property to VelocityView, for exposing a VelocityFormatter (part of standard Velocity) * relaxed exceptions for null models/null root tag name in AbstractXsltView * added stylesheet parameters to AbstractXsltView which subclasses can create * AbstractPdfView now sets the content type correctly on the response Changes in version 1.0 RC1 (11.2.2004) -------------------------------------- Package org.springframework.aop * Overhauled advice manipulation methods on AdvisedSupport * SimpleIntroductionAdvisor -> DefaultInterceptionIntroductionAdvisor * added AfterReturning advice to complete AOP advice types * RegexpMethodPointcut can handle multiple patterns * added NameMatchMethodPointcut and NameMatchMethodPointcutAroundAdvisor for simple "xxx*"/"*xxx" name matches * changed AbstractAutoProxyCreator's "interceptors" property to "interceptorNames" to handle prototypes correctly * added ConcurrencyThrottleInterceptor, blocking invocations if a specified concurrency limit is reached Package org.springframework.beans * removed PropertyEditorManager registration from BeanWrapper, purely relying on local registration now * removed PropertyValuesValidator support from BeanWrapper * removed newWrapperInstance method from BeanWrapper * removed AbstractVetoableChangeListener from beans package * simplified BeanWrapperImpl's PropertyAccessException handling * improved BeanWrapperImpl's TypeMismatchException message in case of list or array entries * moved SortDefinition classes to new beans.support package * moved PagedListHolder classes from util package to beans.support, to remove cyclic package dependency * reworked BeanPostProcessor interface into postProcessBeforeInitialization and postProcessAfterInitialization * revised order of BeanFactory lifecycle methods, now invoking setBeanFactory etc before afterPropertiesSet * added BeanCreationException, thrown on any error during bean creation (property setting, lifecycle methods) * added "autodetect" autowire mode that chooses either "constructor" or "byType" through introspection of the class * reworked AutowireCapableBeanFactory's "autowire" and "autowireConstructor" into a generic "autowire" method * moved AutowireCapableBeanFactory interface to package beans.factory.config * added SetFactoryBean class to package beans.factory.config, with "setClass" property for target class * reworked ListFactoryBean and MapFactoryBean to support "listClass" respectively "mapClass" properties * moved ConstructorArgumentValues and RuntimeBeanReference to package beans.factory.config * PropertyPlaceholderConfigurer resolves placeholders in constructor arguments * PropertyPlaceholderConfigurer supports resolution of system properties * moved BeanFactoryBootstrap and BootstrapException to package beans.factory.access * moved BeanFactoryUtils from package beans.factory.support to beans.factory * added "getAliases" method to BeanDefinitionRegistry interface (same as in BeanFactory) * allow for FactoryBeans as inner bean definitions * redesigned RootBeanDefinition and DefaultXmlBeanDefinitionParser to alternatively work with plain class names * load "spring-beans.dtd" via class loader of BeansDtdResolver instead of thread context class loader * removed deprecated "ref external" support from XML bean definition format (use "ref bean" instead) * added new "idref" tag to XML bean definition format, for referencing a bean ID as string (allowing for validation) * added support for "autodetect" autowire mode to XML bean definition format * added "set" tag to XML bean definition format, analogous to "list" and "map" * fixed "constructor-arg" detection in DefaultXmlBeanDefinitionParser to not interfere with inner bean definitions * reworked BeanFactoryLoader interface into org.springframework.beans.factory.access.BeanFactoryLocator * added SingletonBeanFactoryLocator class, for use by glue code needing to access a BeanFactory/ApplicationContext * added SimpleJndiBeanFactoryLocator class, for example for use in Spring's EJB support classes Package org.springframework.context * ApplicationContext interface does not extend AutowireCapableBeanFactory anymore (use ConfigurableApplicationContext) * ApplicationContext's "getResource" method does not throw IOException anymore * always interpret file paths as relative in AbstractApplicationContext's "getResourceByPath" implementation * MessageSource's NoSuchMessageException is unchecked rather than checked, as it reflects a configuration error * renamed MessageSourceResolvable's "getArgs" method to "getArguments" * reworked internal structure of AbstractNestingMessageSource and ResourceBundleMessageSource * added ReloadableResourceBundleMessageSource, supporting hot reloading of message definition files * added "useCodeAsDefaultMessage" property to AbtractNestingMessageSource, to ease development and debugging * added DefaultBeanFactoryLocator class, for use by glue code needing to access a BeanFactory/ApplicationContext * added JndiBeanFactoryLocator class, for example for use in Spring's EJB support classes Package org.springframework.core * removed HasRootCause, InternalErrorException, ParameterizableErrorCoded, and Timestamped * added JdkVersion class for easy detection of JDK 1.3 and 1.4 * moved Constants and ControlFlow classes from util package to core * added InputStreamSource interface to package core.io, as super-interface of Resource * added "equals" and "hashCode" implementations to AbstractResource, based on descriptions strings * allow for ${...} placeholders in resource locations parsed by ResourceEditor, replacing them with system properties Package org.springframework.dao * TypeMismatchException extends InvalidDataAccessResourceUsageException Package org.springframework.ejb * replaced BeanFactoryLoader interface with BeanFactoryLocator, to load a BeanFactory or ApplicationContext for EJBs * removed XmlBeanFactoryLoader, superseded by JndiBeanFactoryLocator/SimpleJndiBeanFactoryLocator Package org.springframework.jdbc * added support for transaction suspension to DataSourceTransactionManager * added "isNativeConnectionNecessaryForNativePreparedStatements/CallableStatements" methods to NativeJdbcExtractor * added XAPoolNativeJdbcExtractor for ObjectWeb's XAPool * added CLOB handling to LobHandler, with BlobCreator reworked into LobCreator that covers both BLOBs and CLOBs * revised OracleLobHandler to work with all Oracle 9i drivers (classes12 and ojdbc14) * fixed handling of null values in DefaultLobHandler and OracleLobHandler * added getExceptionTranslator convenience method to JdbcDaoSupport * added JdbcOperations interface for JdbcTemplate, to ease unit testing Package org.springframework.mail * added MimeMessageHelper to package mail.javamail, providing simple access to a MimeMessage including attachments Package org.springframework.orm * added support for transaction suspension to HibernateTransactionManager and JdoTransactionManager * added HibernateOperations and SqlMapOperations interfaces for HibernateTemplate respectively SqlMapTemplate * added convertHibernateAccessException convenience method to HibernateDaoSupport * added convertJdoAccessException convenience method to JdoDaoSupport * revised Hibernate-JTA synchronization to close the Session early in case of a Hibernate TransactionManagerLookup * added "jtaTransactionManager" property to LocalSessionFactoryBean, for driving Hibernate's TransactionManagerLookup * added ClobStringType for mapping Strings to LobHandler-managed CLOBs with Hibernate * added "lobHandler" property to LocalSessionFactoryBean, for driving ClobStringType * added "evict", "saveOrUpdateCopy" and overloaded "delete" and "update" methods to HibernateTemplate * changed the argument of JdoDialect's "flush" from Transaction to PersistenceManager * JdoTransactionManager uses JdoDialect's "translateException" in case of flushing failure on commit Package org.springframework.remoting * made RemoteExporter's "serviceInterface" property required * added skeleton class check to Hessian/BurlapServiceExporter, to make them work with both Hessian/Burlap 2.x and 3.x * fixed exception handling in BurlapClientInterceptor Package org.springframework.samples * introduced Image Database sample application, illustrating LobHandler and HTTP multipart file uploads Package org.springframework.transaction * added propagation behaviors "REQUIRES_NEW", "NOT_SUPPORTED" and "NEVER" to TransactionDefinition * refactored TransactionStatus into minimal interface, with DefaultTransactionStatus as default implementation * rollback on Error in TransactionInterceptor, via DefaultTransactionAttribute's "rollbackOn" implementation * added "readOnly" argument to TransactionSynchronization's "beforeCommit" method * added ResourceHolderSupport class to package transaction.support, based on the former ExpiringObject util class * reworked TransactionSynchronizationManager to move callback triggering to AbstractPlatformTransactionManager * added support for transaction suspension (including synchronization) to AbstractPlatformTransactionManager * added support for transaction suspension to JtaTransactionManager, via the JTA TransactionManager interface * added JotmFactoryBean for exposing a JOTM instance (implementing UserTransaction and TransactionManager) * added WebSphereTransactionManagerFactoryBean for exposing a WebSphere 4/5's JTA TransactionManager * allow advisors for TransactionProxyFactoryBean's "preInterceptors" and "postInterceptors" properties * removed AbstractTransactionAttributeSource, moved isMatch implementation to concrete subclasses Package org.springframework.ui * added VelocityEngineUtils utility class for convenient merging of a Velocity template with a model Package org.springframework.util * removed ObjectArrayUtils and ReflectionUtils Package org.springframework.validation * apply custom editor on Errors.getFieldValue to manually rejected field values too Package org.springframework.web * removed "getUrlToApplication" from WebUtils * fixed check for existing "webAppRootProperty" in WebUtils to allow for same value on web app redeployment * moved TagUtils helper class from package web.servlet.tags to web.util, renamed scope constants * removed "publishWebApplicationContext" and "parseContextConfigLocation" from WebApplicationContextUtils * moved ServletContextResource from package web.util to web.context.support * removed Servlet 2.3 "getServletContextName" call from ServletContextResource, for Servlet 2.2 compatibility * fixed ServletContextResource's "exists" check (to allow for relative directory paths e.g. in VelocityEngineFactory) * added "getAlreadyFilteredAttributeName" method to OncePerRequestFilter, for custom identification of the filter * renamed MultipartFile's "getOriginalFileName" method to "getOriginalFilename" * allow for existing multipart request in DispatcherServlet even if MultipartResolver configured (for forwards) * invoke HandlerInterceptor.afterCompletion even if a later HandlerInterceptor aborts processing * pass request and response into HandlerExceptionResolver's "resolveException" method * removed "setName" method from View interface, making AbstractView implement BeanNameAware instead * added "contentType" propert to UrlBasedViewResolver, for setting the content type of all resolved views * apply ContextResourceEditor to bean factories created by XmlViewResolver and ResourceBundleViewResolver * refactored URL path matching into UrlPathHelper, used by AbstractUrlHandlerMapping and AbstractMethodNameResolver * added "urlDecode" property to UrlPathHelper, for URL-decoding request URI and context path (if required) * renamed FileNameViewController to UrlFilenameViewController * removed deprecated "beanName" property from AbstractCommandController (use "commandName" instead) * SimpleFormController's default "onSubmit" forwards to success view with full Errors model instead of just command * turned AbstractWizardFormController's "getCurrentPage" method non-final, to be overridden if determined by request * removed experimental ValidatableThrowawayController * re-evaluate EL expressions on each tag rendering instead of on tag instance initialization in all Spring tags Building * replaced use-case-specific JARs with module-specific JARs (spring-core, spring-aop, spring-dao, spring-web, etc) * added "xdoclet/xjavadoc.jar" to "release" target in the framework build script (needed for building with attributes) * put Commons Attributes and XDoclet JARs in Ant classpath instead of expecting them in Ant's lib directory * renamed all "ant.bat" files in the samples to "build.bat" * added "build.bat" and "warfile.bat" files to "samples/jpetstore/attributes" directory * added "build.bat" file to framework root Changes in version 1.0 M4 (4.1.2004) ------------------------------------ Package org.springframework.aop * moved auto proxy creator implementations into new org.springframework.aop.framework.autoproxy package * introduced ProxyConfig base class for ProxyFactoryBean etc, specifying common AOP proxy settings * introduced Before and Throws advice, in addition to interception Around advice * replaced InvokerInterceptor and ProxyInterceptor interface by TargetSource interface * removed "exposeInvocation" option in proxy factories * significantly reduced overhead of AOP framework * added aop.framework.adapter package to allow for new Advisor/advice types without changing the basic AOP framework Package org.springframework.beans * removed event propagation support in BeanWrapper * added FileEditor to standard PropertyEditors, for creating java.io.File instances from String representations * added URLEditor to standard PropertyEditors, for creating java.net.URL instances from String representations * added "registerCustomEditor(Class, PropertyEditor)" convenience method to the BeanWrapper interface * added "registerCustomEditor(Class, PropertyEditor)" method to the ConfigurableBeanFactory interface * added "setParent" method to ConfigurableBeanFactory interface * added "preInstantiateSingletons" method to ConfigurableListableBeanFactory interface * added "containsBeanDefinition" method to ListableBeanFactory interface (same as in BeanDefinitionRegistry) * introduced AutowireCapableBeanFactory interface, allowing for autowiring of externally managed bean instances * dissolved PropertyValuesProviderFactoryBean interface and AbstractFactoryBean convenience base class * fixed ManagedList and ManagedMap resolution for prototypes in AbstractBeanFactory * fixed potential multithreading issue on nested prototype resolution in AbstractBeanFactory * dependent beans (with corresponding "depends-on") are destroyed first in AbstractBeanFactory's "destroySingletons" * consider arrays of primitive wrappers as "simple" properties in the sense of dependency-check="simple" * added support for inner bean definitions, at the same level as bean references and values * added generic autowire method to AutowireCapableBeanFactory, for guessing an appropriate autowiring strategy * factored out bean definition format reading logic into Properties/Xml/JdbcBeanDefinitionReader * added "beanClassLoader" property to AbstractBeanDefinitionReader, to override the thread context class loader * removed bean definition reading methods in DefaultListableBeanFactory, reduced them in XmlBeanFactory * added "allowBeanDefinitionOverriding" property in DefaultListableBeanFactory * separated XML bean definition reading into XmlBeanDefinitionReader plus (Default)XmlDefinitionParser * enabled more specific error messages on XML bean definition parse failures through use of location parameter * added optional "description" element in XML bean definition documents to allow for user documentation * added "default-lazy-init" attribute for XML bean definitions * allow for "bean/"list"/"map"/"props" as sub-element of "list" and "entry" in XML bean definitions * added two "beanOfType" convenience methods to BeanFactoryUtils * added ListFactoryBean and MapFactoryBean to beans.factory.config Package org.springframework.context * ApplicationContext interface extends AutowireCapableBeanFactory * removed ContextOptions support in ApplicationContext and AbstractApplicationContext * moved ApplicationEventMulticaster interface to package context.event * fixed "lazy-init" support in AbstractApplicationContext, delegating to the factory's "preInstantiateSingletons" * reworked ApplicationContext's "InputStream getResourceAsStream" method into "Resource getResource" * removed ApplicationContext's "getResourceBasePath" method, as its functionality is covered by the new "getResource" * added support for pseudo URL prefix "classpath:" in AbstractApplicationContext's "getResource" * added ContextResourceEditor to package context.config, for populating Resource bean properties via the context * added ContextResourceFactoryBean, for configuring Resource instances via ApplicationContext's "getResource" * added "getBeanFactory" method to ConfigurableApplicationContext, for access to the internal bean factory * moved PropertyResourceConfigurer/PropertyOverrideConfigurer/PropertyPlaceholderConfigurer to beans.factory.config Package org.springframework.core * introduced Resource interface in core.io package, for specifying resource locations in a generic way * added ClassPathResource, FileSystemResource, UrlResource, and InputStreamResource implementations * added ResourceEditor for automatic conversion of Strings to bean properties of type Resource Package org.springframework.ejb * SimpleRemoteSlsbInvokerInterceptor/SimpleRemoteStatelessSessionProxyFactoryBean support non-RMI business interfaces * SimpleRemoteSlsbInvokerInterceptor/SimpleRemoteStatelessSessionProxyFactoryBean's "inContainer" default set to false * support for multiple paths as "BeanFactoryPath" in XmlBeanFactoryLoader, separated by any number of commas or spaces Package org.springframework.jdbc * moved JDBC-specific DataAccessException subclasses from jdbc.core to root jdbc package * moved SQLExceptionTranslator interface plus implementations from package jdbc.core to jdbc.support * moved DataFieldMaxValueIncrementer interface plus implementations from jdbc.core.support to jdbc.support.incrementer * reworked QueryExecutor interface into NativeJdbcExtractor in package jdbc.support * reworked CommonsDbcpQueryExecutor implementation into CommonsDbcpNativeJdbcExtractor for DBCP 1.1 * added JBossNativeJdbcExtractor for the JBoss 3.2 connection pool * added SimpleNativeJdbcExtractor for any pools that just wrap Connections but not Statements * introduced LobHandler and BlobCreator interfaces in package jdbc.support.lob * added DefaultLobHandler for any standard JDBC compliant driver * added OracleLobHandler implementation for the peculiar requirements of Oracle's JDBC driver * added DatabaseStartupValidator that allows to defer the initialization of database-dependent components * removed setExceptionTranslator from RdbmsOperation, set an appropriately configured JdbcTemplate instead Package org.springframework.orm * introduced support for iBATIS Database Layer, in package org.springframework.orm.ibatis * added "get" and "lock" convenience methods to HibernateTemplate * added OpenSessionInViewInterceptor and OpenSessionInViewFilter to org.springframework.orm.hibernate.support * LocalSessionFactoryBean's "executeSchemaUpdate" uses plain executeUpdate calls now instead of a batch * changed type of LocalPersistenceManagerFactoryBean's "configLocation" property from String to Resource Package org.springframework.remoting * reworked RemoteProxySupport into RemoteAccessor plus UrlBasedRemoteAccessor * removed AuthorizableRemoteProxyFactorySupport, deferred authorization properties to concrete implementations * RmiClientInterceptor/RmiProxyFactoryBean and RmiServiceExporter can work with conventional RMI services * RmiClientInterceptor/RmiProxyFactoryBean supports non-RMI business interfaces for conventional RMI services * renamed RmiServiceExporter's "name" to "serviceName" and "port" to "registryPort" * added "servicePort" property to RmiServiceExporter, for specifying the port that the exported object uses * introduced JAX-RPC service and port access classes in org.springframework.remoting.jaxrpc * added ServletEndpointSupport classes for implementing JAX-RPC-based services that access a Spring context Package org.springframework.samples * introduced JPetStore sample application, an adapted version of Clinton Begin's JPetStore * added "jdbc.properties" file with PropertyPlaceholderConfigurer in Petclinic and JPetStore * commented out "resource-ref" entries in Petclinic, Countries, and JPetStore for simpler deployment * removed support for JBoss' internal HSQL instance from Petclinic and Countries, for simpler deployment Package org.springframework.transaction * reworked transaction synchronization, allowing for synchronization even on "empty" transactions * removed TransactionProxyFactoryBean's "proxyInterfacesOnly" property in favor of ProxyConfig's "proxyTargetClass" * TransactionInterceptor now keeps TransactionStatus in its own ThreadLocal, not MethodInvocation * merged TransactionFactoryProxyBean's parsing into NameMatchTransactionAttributeSource * added TransactionAttributeSourceTransactionAroundAdvisor to allow pointcut to be used for transaction interception Package org.springframework.ui * replaced "appRootMarker" mechanism in VelocityEngineFactory with "resourceLoaderPath" property Package org.springframework.validation * removed event propagation support in DataBinder * added "getValuesForProperty" and "toCodeForProperty" methods to Constants helper class Package org.springframework.web * added attribute-driven Controller mapping, in org.springframework.web.servlet.handler.metadata package * added "getOrCreateSessionAttribute" helper method to WebUtils, for on-demand state objects in a web tier * introduced GenericFilterBean and OncePerRequestFilter base classes in package org.springframework.web.filter * reworked MultipartFilter to extend GenericFilterBean/OncePerRequestFilter * added "isEmpty" method to MultipartFile interface, for checking whether a file has been chosen in a multipart form * renamed CommonsMultipartResolver's "maximumFileSize"/"maximumInMemorySize" to "maxUploadSize"/"maxInMemorySize" * renamed CosMultipartResolver's "maximumFileSize" to "maxUploadSize" * reworked CommonsMultipartResolver's/CosMultipartResolver's "uploadTempDir" from String to core.io.Resource * fixed multipart cleanup with a local MultipartResolver in DispatcherServlet * added "getRequiredWebApplicationContext" method to WebApplicationContextUtils * dissolved support for exposing "config" objects as ServletContext attributes * introduced ConfigurableWebApplicationContext configuration interface instead of constructor requirements * reworked initialization workflow of XmlWebApplicationContext and StaticWebApplicationContext * allowed for overriding context creation in ContextLoader (now a full object) and FrameworkServlet * added "contextConfigLocation" property to FrameworkServlet, analogous to ContextLoader's * DispatcherServlet's default exception handling lets RuntimeExceptions straight through * HandlerMappings, HandlerInterceptors, ViewResolvers, and Views are allowed to throw any Exception * allowed for on-demand fetching of prototype handlers in SimpleUrlHandlerMapping and BeanNameUrlHandlerMapping * removed UrlHandlerAware support in AbstractUrlHandlerMapping * added ModelAndView argument to HandlerInterceptor's "postHandle" method, for exposing additional model objects * added "afterCompletion" method to HandlerInterceptor, invoked on any outcome for proper resource cleanup * added HandlerInterceptorAdapter for simplified implementation of pre-only/post-only interceptors * changed ServletExceptions in RequestContextUtils to IllegalStateExceptions * InternalResourceViewResolver and XmlViewResolver override getCacheKey for more efficient non-locale-aware caching * moved SimpleMappingExceptionResolver from package org.springframework.web.servlet.support to web.servlet.handler * added "defaultErrorView" property to SimpleMappingExceptionResolver * moved UserRoleAuthorizationInterceptor from package org.springframework.web.servlet.support to web.servlet.handler * moved WebContentGenerator from package org.springframework.web.servlet.mvc to web.servlet.support * introduced WebContentInterceptor for applying request/response checks and preparations to a set of controllers * MultiActionController extends AbstractController, for applying checks and preparation to all handle methods * AbstractWizardFormController overrides "handleInvalidSubmit" to show the initial page of a new wizard form * added additional "referenceData(request,page)" method to AbstractWizardFormController * added additional "getTargetPage(request,command,errors,currentPage)" method to AbstractWizardFormController * introduced ThrowawayController and ValidatableThrowawayController for WebWork/Maverick-style controllers * added AbstractUrlBasedView and UrlBasedViewResolver base classes, for consistent handling of view URLs * renamed VelocityView's "templateName" property to "url" for consistency, deriving from AbstractUrlBasedView now * added VelocityViewResolver convenience class, deriving from UrlBasedViewResolver * removed "exposeDateFormatter" and "exposeCurrencyFormatter" properties in VelocityView * added "dateToolAttribute" to VelocityView, for exposing a locale-aware DateTool (from Velocity Tools 1.0) * renamed org.springframework.web.servlet.view.velocity.VelocityConfiguration to VelocityConfig New package org.springframework.metadata plus supporting packages * providing a facade to source-level and other attribute metadata * integration with Jakarta Commons Attributes as default backend implementation * added metadata-driven autoproxying to allow for .NET-style attribute-driven declarative services See the org.springframework.aop.framework.autoproxy.metadata package for tests illustrating this, using Commons Attributes to drive declarative transaction management, pooling, and other services. Changes in version 1.0 M3 (25.11.2003) -------------------------------------- Package org.springframework.aop * major AOP API changes: see changes-M2-M3.txt for further details * added "targetClass" argument to StaticMethodPointcut.applies() * CGLIB proxies support introductions now * can force CGLIB proxying using new "proxyTargetClass" property on DefaultProxyConfig * introduced various invoker interceptors like Prototype-, CommonsPooling-, and ThreadLocalInvokerInterceptor Package org.springframework.beans * fixed empty-value-on-primitive-property check in BeanWrapperImpl to allow a custom editor to modify the value first * added support for indexed and mapped properties to BeanWrapperImpl, with "beanName.indexedProperty[index]" syntax * log value when setting property value in case of simple properties, at debug lebel * ClassEditor and other framework classes use the thread context class loader now, consistent within the framework * introduced "containsBean" method in BeanFactory, checking for the existence of a bean without creating it * BeanFactory's "isSingleton" method now checks singleton status of created object in case of a FactoryBean * introduced "getBeansOfType" method in ListableBeanFactory, retrieving both normal beans and FactoryBean-created beans * introduced "getObjectType" method in FactoryBean, to avoid unnecessary bean creation on autowire checks * reworked BeanFactoryUtils' "beanNamesIncludingAncestors" and "beansOfTypeIncludingAncestors" methods * added "beanOfTypeIncludingAncestors" method to BeanFactoryUtils, expecting a single matching bean * introduced FactoryBeanCircularReferenceException and refined circular reference handling with a FactoryBean involved * introduced BeanNameAware interface to be implemented by beans that want to be aware of their bean factory name * introduced ConfigurableBeanFactory and ConfigurableListableBeanFactory interfaces in beans.factory.config package * reworked BeanPostProcessor and BeanFactoryPostProcessor interfaces and moved them to beans.factory.config package * renamed ListableBeanFactoryImpl to DefaultListableBeanFactory, reflecting its role in the reworked factory hierarchy * reworked AbstractBeanDefinition/RootBeanDefinition/ChildBeanDefinition, introduced "validate" method * check for invalid bean definitions: "lazy-init" attribute and FactoryBean classes only allowed for singletons * fixed RootBeanDefinition bug that caused an unnecessary additional invocation of the constructor of the defined bean * added support for lazy initialization of singleton beans in AbstractBeanFactory and subclasses * redefined autowiring to ignore if no matching bean found but still complain in case of more than one matching bean * ignore specified dependency types on autowiring, like BeanFactory and ApplicationContext * added ConstructorArgumentValues support to RootBeanDefinition, for resolving arguments to specific beans or values * added autowire="constructor" mode for PicoContainer-style Type 3 IoC, resolving constructor arguments by type * made "id" attribute of "bean" tag in XML bean definition format optional, using the first given name as primary name * allow for "bean" tags with neither "id" nor "name", using the bean class name as implicit id (PicoContainer-style) * added "lazy-init" attribute to "bean" tag in XML bean definition format, default being "false" * added "depends-on" attribute to "bean" tag in XML format, expressing initialization dependencies on other beans * added "constructor-arg" tag to "bean" tag in XML format, analogous to "property" tag, with optional "index" attribute * added "default-dependency-check" and "default-autowire" attributes to root tag in XML bean definitions * reworked PropertiesFactoryBean to allow for loaded and local properties and moved into beans.factory.config package * added CommonsLogFactoryBean to beans.factory.config package, for setting up shared Log instances * added MethodInvocationFactoryBean to beans.factory.config package, for exposing an object from any static method call Package org.springframework.context * split ApplicationContext interface into ApplicationContext client interface and ConfigurableApplicationContext SPI * ApplicationContextException extends BeansException, to enable consistent catching of exceptions thrown by a context * ApplicationContextAware and ApplicationObjectSupport throw BeansException now instead of ApplicationContextException * moved ResourcePropertiesFactoryBean to beans.factory.config package * added "ignoreResourceNotFound" property to PropertyResourceConfigurer, default is "false" (throwing an exception) * added support for placeholders in bean reference names to PropertyPlaceholderConfigurer * added support for cross-referencing placeholders in placeholder values to PropertyPlaceholderConfigurer Package org.springframework.jdbc * added setter methods for data access templates and convenience methods for resource opening/closing to JdbcDaoSupport * refactored JDBC core package so that SQLErrorCodeExceptionTranslator can be subclassed by and passed into JdbcTemplate * refactored JDBC object package so that one JdbcTemplate can be used to configure multiple RdbmsOperations * reworked JdbcBeanFactory to extend DefaultListableBeanFactory instead of using a refreshable delegate Package org.springframework.mail * added "port" bean property to JavaMailSenderImpl, for setting a non-default mail server port * added "session" bean property to JavaMailSenderImpl, for setting a custom JavaMail Session (possibly pulled from JNDI) Package org.springframework.orm * added setter methods for data access templates to HibernateDaoSupport/JdoDaoSupport * added convenience methods for resource opening/closing to HibernateDaoSupport/JdoDaoSupport * reworked HibernateAccessor/HibernateTemplate/HibernateInterceptor flush handling * throw HibernateObjectRetrievalFailedException on Hibernate's ObjectDeletedException * added "mappingResourceJars" property to LocalSessionFactoryBean, allowing to load mapping resources from jar files * added "jdbcExceptionTranslator" property to HibernateTemplate, allowing to set a SQLExceptionTranslator for SQL ex's * added "jdbcExceptionTranslator" property to HibernateTransactionManager, applied to flushing failures on commit * added "jdbcExceptionTranslator" parameter to SessionFactoryUtils.getSession, applied to transaction synchronizations * added "save(entity, id)" convenience method to HibernateTemplate * introduced JdoAccessor as common base class for JdoTemplate and JdoInterceptor * introduced JdoDialect interface with getJdbcConnection and flush methods * added support for JdoDialect in JdoTransactionManager and JdoAccessor/JdoTemplate/JdoInterceptor Package org.springframework.samples * switched Countries and Petclinic to auto-detection of spring.tld in META-INF of spring.jar * switched Countries and Petclinic to ContextLoaderServlet for maximum compatibility * Tiles Example uses package org.springframework.samples.tiles now * added warfile.bat, readme.txt, and redirecting index.jsp to Tiles Example Package org.springframework.transaction * moved commit exception handling from concrete implementations up to the generic AbstractPlatformTransactionManager * added "rollbackOnCommitFailure" bean property to AbstractPlatformTransactionManager * added "cleanupAfterCompletion" template method to AbstractPlatformTransactionManager * reworked commit exception handling in HibernateTransactionManager and JdoTransactionManager * reworked cleanup code in DataSourceTransactionManager/HibernateTransactionManager/JdoTransactionManager * fixed PROPAGATION_SUPPORTS handling in DataSourceTransactionManager/HibernateTransactionManager/JdoTransactionManager * added "cacheUserTransaction" property to JtaTransactionManager, caching the looked-up UserTransaction by default * dissolved ThreadObjectManager and put resource binding (for JDBC/JDO/Hibernate) in TransactionSynchronizationManager * added transaction synchronization support for JDBC and JDO to always return the same resources in a JTA transaction Package org.springframework.ui * reworked VelocityEngineFactory to allow VelocityEngineFactoryBean to run outside of application context Package org.springframework.util * reworked ClassLoaderUtils' "getResourceAsStream" to load from the class path root with or without leading slash * "PagedListHolder" and its contained "MutableSortDefinition" implement Serializable now, for distributed sessions * added convenience methods "previousPage" and "nextPage" to PagedListHolder Package org.springframework.web * reworked DataBinder and ServletRequestDataBinder to contain a BindException instead of derive from it * interfaces HandlerAdapter, HandlerMapping, and ViewResolver do not require ApplicationContextAware anymore * interface View does not require addStaticAttribute and getName methods anymore * HandlerAdapter and Controller can throw any Exception now, instead of just ServletException and IOException * introduced HandlerExceptionResolver interface, for resolution of specific exceptions to error page ModelAndViews * added SimplerMappingExceptionResolver implementation, for mapping exception class names/messages to view names * introduced ModelAndViewDefiningException, to be thrown during handler processing to forward to a specific error page * renamed BaseCommandController's "setBeanName" method to "setCommandName", keeping "setBeanName" deprecated * renamed BaseCommandController's "userObject" method to "getCommand" * check both ".x" and ".y" as submit image suffixes in AbstractWizardFormController * moved FileNameViewController from Tiles Example to package org.springframework.web.servlet.mvc * view bean factories of XmlViewResolver and ResourceBundleViewResolver are now children of the application context * added "attributesMap" property to AbstractView, for setting attribute values like bean references via a Map * renamed InternalResourceView's "exposeModelsAsRequestAttributes" method to "exposeModelAsRequestAttributes" * if in included request, examine the include paths for handler mappings instead of the original request paths * if already in included request, perform another include instead of forward in InternalResourceView * fixed potential NPE in debug log statement of VelocityView * added taglib URI "http://www.springframework.org/tags" for auto-detection of spring.tld in META-INF of spring.jar Changes in version 1.0 M2 (23.10.2003) -------------------------------------- * added optional dependency checking for bean factories, ensuring that all bean properties have been set before use * added non-default "autowire" functionality so that bean factories can optionally configure dependencies automatically * added PropertyValuesProviderFactoryBean instead of having getPropertyValues() in the FactoryBean interface * added BeanPostProcessor interface and support for it in AbstractBeanFactory and AbstractApplicationContext * moved BeanFactoryPostProcessor from context.support to beans.factory.support package * reworked AbstractBeanFactory's circular reference detection into eager singleton caching * redefined XmlBeanFactory "ref" tag: "local" for local bean ids, "bean" for any bean name ("external" deprecated now) * reworked XmlBeanFactory's alias handling to allow for multiple aliases in the "name" attribute of the bean tag * allowed nested maps in XML bean definitions, i.e. a "map" tag as child of an "entry" tag of a surrounding "map" tag * reworked AopUtils and AOP ProxyFactory configuration options * introduced auto proxy creator classes in org.springframework.aop.framework.support, implementing BeanPostProcessor * restructured org.springframework.context.support package into support, event, and config packages * removed "shared object" support in ApplicationContext as part of API simplification * reworked AbstractXmlApplicationContext's "getInputStreamForBeanFactory" into "loadBeanDefinitions(BeanFactory)" * added support for multiple file paths in FileSystemXmlApplicationContext and ClassPathXmlApplicationContext * added support for multiple basenames in a ResourceBundleMessageSource, getting checked sequentially * introduced MessageSourceAccessor helper class for easy message access, available via ApplicationObjectSupport * reworked PropertyResourceConfigurer into PropertyOverrideConfigurer and PropertyPlaceholderConfigurer * introduced generic mail infrastructure in org.springframework.mail package, around the MailSender interface * introduced JavaMailSender and JavaMailSenderImpl in org.springframework.mail.javamail package * introduced CosMailSenderImpl in org.springframework.mail.cos, using the MailMessage class from Jason Hunter's COS * added preInterceptors/postInterceptors support to TransactionProxyFactoryBean * added support for returning result sets from a stored procedure * allow HibernateCallback to throw SQLException on direct JDBC access * refined data access exceptions with new ORM-specific and additional Hibernate-specific subclasses * reworked Hessian/Burlap/RMI remoting proxies into interceptors with proxy factory bean subclasses * reworked (Authorizable)RemoteProxyFactoryBean into (Authorizable)RemoteProxySupport * introduced generic multipart handling aka file upload in org.springframework.web.multipart * introduced multipart implementation for Jakarta Commons FileUpload * introduced multipart implementation for Jason Hunter's COS (com.oreilly.servlet) * added support for multiple file paths in XmlWebApplicationContext's "contextConfigLocation" context-param * added support for automatic multipart resolution to DispatcherServlet * fixed context/servlet path detection in WebUtils and AbstractUrlHandlerMapping * moved LastModified interface to org.springframework.web.servlet.mvc * reworked DispatcherServlet's revalidation support to leverage HttpServlet.getLastModified * added "synchronizeOnSession" support to AbstractController, available to all command and form controllers * renamed AbstractFormController's "processSubmit" method to "processFormSubmission" * added overloaded "getInitialPage(request,command)" method to AbstractWizardFormController * added spring:transform tag, providing support for transforming reference data * refactored Velocity support into generic VelocityEngineFactory and web-specific VelocityConfigurer for views * Velocity support in web framework uses VelocityEngine now to allow for different Velocity configs in same web app * fixed TilesView content type handling * added tiles-example showing how to use Tiles in conjunction with Spring * added documentation on tags in docs/taglib * added build scripts and directory structure to webapp-minimal skeleton to allow use as a kickstart for user projects * combined webapp-typical/hibernate/aop skeletons into one single webapp-typical with multiple context definitions * introduced alternative Hibernate implementation of Petclinic, now shipping as the default configuration Changes in version 1.0 M1 (30.8.2003) ------------------------------------- * changed package structure from com.interface21 to org.springframework * revised distribution jar files (spring-beans, spring-context, spring-jdbc, spring) * introduced DisposableBean interface * introduced "destroy-method" attribute for XML bean definitions * support for CSV as XML bean "name" to be able to define multiple aliases * revised bean factory exception messages to include line numbers * fixed typeMismatch reporting for nested bean properties * added PropertiesFactoryBean as alternative to properties file loading * added getValues and toCode methods to Constants utility class * DynamicMethodPointcut now takes method, args and AttributeRegistry arguments instead of MethodInvocation * JndiObjectFactoryBean does not prepend container prefix if scheme is given * fixed Statement and ResultSet handling to work for all kinds of JDBC drivers * dissolved ReadOnlyResultSet to make JdbcTemplate return the underlying ResultSet * removed getSql method from PreparedStatementCreator interface * introduced QueryExecutor interface for retrieval of underlying driver ResultSets * added CommonsDbcpQueryExecutor implementation for Jakarta Commons DBCP * revised RdbmsOperation hierarchy to allow for all of JdbcTemplate's options * SingleConnectionDataSource implements DisposableBean * SingleConnectionDataSource does not override auto-commit anymore * renamed XxxExtracter to XxxExtractor and XxxTranslater to XxxTranslator * support for returning Types.ARRAY from stored procedure * LocalSessionFactoryBean implements DisposableBean * added HibernateTemplate.deleteAll for batch deletes * support for overlapping method name patterns in transaction attribute source definitions * support for specifying timeouts via TransactionAttributeEditor * added TransactionProxyFactoryBean for simplified transaction proxies * removed support for non-transactional execution from AbstractPlatformTransactionManager * added support for transaction timeouts via JDBC statement timeouts to DataSourceTransactionManager * added support for transaction timeouts via Hibernate query timeouts to HibernateTransactionManager * fixed RMI registry detection in RmiServiceExporter * fixed custom editor usage for rejected field values * introduced WebApplicationObjectSupport convenience base class * refined cache control options in WebContentGenerator * revised initHandler method in AbstractUrlHandlerMapping * added "urlMap" property to SimpleUrlHandlerMapping * revised exception behavior of RequestContext and BindErrorsTag * re-added deprecated ContextLoaderServlet for Servlet 2.2 containers * refactored Log4jConfigListener into Log4jWebConfigurer and listener * introduced deprecated Log4jConfigServlet for Servlet 2.2 containers * introduced Tiles support through TilesView and TilesConfigurer * introduced support for Spring-aware Tiles component controller * added customization in AbstractPdfView Changes in version 0.9.1 (8.8.2003) ----------------------------------- * revised distribution jar files (spring-beans, spring-jdbc, spring-full) * fixed error logging in XmlBeanFactory * support for XML bean definition includes via XML entities * Spring bean definition DTD allows map entries to be lists now * introduced "init-method" attribute for XML bean definitions * new BeanFactoryPostProcessor hook to override bean definition values * revised PropertyResourceConfigurer based on BeanFactoryPostProcessor * revised simple JNDI implementation * support for execution context in SqlQuery hierarchy * eager initialization of exception translator in JdbcTemplate * fixed StoredProcedure transaction participation * moved DataSourceTransactionManager to jdbc.datasource package * revised JDO LocalPersistenceManagerFactoryBean with bean-defined settings * revised Hibernate LocalSessionFactoryBean with bean-defined settings * ability to use Spring-configured DataSource for Hibernate * support for Hibernate entity interceptors * fixed Hibernate transaction exception logging * new HibernateTemplate convenience methods for single-step actions * new convenience base classes for JDBC/Hibernate/JDO DAOs * support for read-only transactions * revised TransactionInterceptor configuration options * TransactionInterceptor does not have a default strategy anymore * updated AOP framework to current AOP Alliance interfaces * optional CGLIB support in the AOP framework (to proxy classes as well as interfaces) * distinction between static and dynamic method pointcuts * new regular expression pointcut * revised EJB support classes with BeanFactory access * new BindInitializer support in BindUtils * revised VelocityConfigurer with bean-defined settings * support for Ant-style path matching in the web framework * support for JSP expression language in tag implementations * recommended "spring:" as tag prefix instead of "i21:" * turned sample "PagedList" into full-fledged "Countries" * new Petclinic tutorial * new MVC-step-by-step tutorial * new article "The Spring Framework - A Lightweight Container" * new article "Container Resources vs Local Resources" Changes in version 0.9 (25.6.2003) ---------------------------------- * first public release since the version that came with the book "Expert One-on-One J2EE Design and Development" * following various unofficial 0.8 CVS snapshots * general tightening and polishing * log via Commons Logging * Log4J configuration support * revised bean definition XML format with DTD * support for lists, maps, and props in XML bean definitions * support for hierarchical bean factories * support for custom property editors * various new out-of-the-box editors for dates, numbers, etc * new FactoryBean interface instead of custom bean definitions * FactoryBean-based resource definitions for JDBC DataSource etc * revised simple DataSource implementations * new JDBC error code exception translater * new DataFieldMaxValueIncrementer support for JDBC * new generic transaction management * new JDO support: resource definition, transaction strategy, template, interceptor * new Hibernate support: resource definition, transaction strategy, template, interceptor * new support for remoting via Hessian and Burlap * new AOP framework aligned with AOP Alliance * revised EJB access classes based on AOP * resource access from application contexts * support for MessageSourceResolvable * revised validation framework * support for global validation errors * revised web framework * refactored form controller hierarchy * new handler interception mechanism * locale and theme resolution * support for HTML escaping * revised JSP tag implementations * new sample application "Petclinic" * new sample application "PagedList" * application skeletons as configuration showcases * MutableSortDefinition accepts now NO_CHANGE for setProperty and does nothing in this case * (many new convenience classes and methods) * (too many minor improvements to list) * (lots of minor bugfixes)