SPRING FRAMEWORK CHANGELOG ========================== http://www.springframework.org Changes in version 2.5.6 (2008-10-31) ------------------------------------- General * removed outdated EAR support from sample applications * upgraded to AspectJ 1.6.2 (retaining compatibility with AspectJ 1.5.x and 1.6.x) * upgraded to EHCache 1.5.0 (retaining compatibility with EHCache 1.2 and higher) * upgraded to TestNG 5.8 (retaining compatibility with TestNG 5.5 and higher) * upgraded to OpenJPA 1.1.0 (retaining compatibility with OpenJPA 1.0.x as well as 1.2.0) * upgraded to EclipseLink 1.0.1 (EclipseLinkJpaVendorAdapter requires EclipseLink 1.0.0+ now) Package org.springframework.aop * AbstractAutoProxyCreator (as used by "aop:config") correctly ignores null bean instances * "aop:aspect" doesn't insist on aspect bean reference to be specified when just containing declare-parents elements * "bean" pointcut matches exposed FactoryBean products only; "&..." syntax supported for matching FactoryBean itself Package org.springframework.beans * BeanUtils skips conventional editor check for array classes (in order to not break AspectJ weaving) * BeanWrapper's introspection resolves bridge methods to find setter method for getter method with covariant return type * TypeMismatchException message differentiates between editor with inappropriate value returned versus no editor at all * containing bean definition is exposed to ParserContext for BeanDefinitionDecorators as well * BeanDefinition objects are considered equal even if their originating resource objects are different * AbstractFactoryBean's early singleton proxy handles equals, hashCode and toString calls locally (avoiding eager init) * PropertyPathFactoryBean logs a warning if the target bean is still in creation at the time of obtaining the property * exposed public "copyRegisteredEditorsTo" method on ConfigurableBeanFactory interface * fixed corner case in AbstractBeanDefinition where a ClassCastException could arise in "getBeanClass(Name)" * DefaultSingletonBeanRegistry eagerly cleans up cached dependency information when destroying a bean * AbstractBeanFactory rejects getBean request with arguments in case of a pre-existing singleton of same name as well * AbstractAutowireCapableBeanFactory preserves possible matches hint in property exception * SmartInstantiationAwareBeanPostProcessor's "determineCandidateConstructors" is only invoked for non-null bean Class * ServiceLocatorFactoryBean handles equals and hashCode based on proxy object identity * factored out "createBeanDefinition" template method in BeanDefinitionParserDelegate * turned visibility of BeanDefinitionParserDelegate's "checkNameUniqueness" method to protected * XML list/set/map elements (in both the beans and the util namespace) support nested description element Package org.springframework.cache * EhCacheFactoryBean obtains decorated Ehcache instead of raw Cache, honoring pre-configured cache decorators * removed useless "diskStorePath" property from EhCacheFactoryBean (ignored by all current EHCache versions anyway) Package org.springframework.context * DefaultMessageSourceResolvable and FieldError implement "equals" and "hashCode" such that all fields are respected * ClassPathBeanDefinitionScanner performs trace/debug logging during class resource introspection * ClassPathBeanDefinitionScanner ignores same class found multiple times in the classpath (i.e. equal bean definition) * component-scan preserves original source of scanned bean definitions, for silently ignoring already scanned classes * annotation-config registers PersistenceAnnotationBeanPostProcessor independent from client bundle's class loader * added CUSTOM value to FilterType enumeration Package org.springframework.core * ClassPathResource uses cleaned path for relative resources as well * PathMatchingResourcePatternResolver considers URL protocol "vfszip" as jar file (to search JBoss-managed jars) * GenericCollectionTypeResolver correctly resolves collection element type even when target bean is a collection itself Package org.springframework.ejb * SpringBeanAutowiringInterceptor calls "InvocationContext.proceed()" in order to invoke subsequent interceptors as well Package org.springframework.instrument * ShadowingClassLoader excludes "net.sf.cglib." package from shadowing by default Package org.springframework.jdbc * provided Jdbc4SqlXmlHandler as default implementation of the SqlXmlHandler interface * added SqlValue class to "jdbc.support" package, with SqlXmlValue derived from SqlValue instead of SqlTypeValue * SQLErrorCodesFactory always loads its "sql-error-codes.xml" files from Spring's class loader (-> static singleton) * added "transientDataAccessResourceCodes" category to "sql-error-codes.xml", with default codes for DB2 and Sybase * SQLErrorCodeSQLExceptionTranslator applies default SQLExceptionSubclassTranslator after error code translation only * SQLErrorCodeSQLExceptionTranslator is able to work without fallback SQLState translation as well * SQLExceptionSubclassTranslator translates SQLFeatureNotSupportedException to InvalidDataAccessApiUsageException * SQLStateSQLExceptionTranslator returns TransientDataAccessResourceException for well-known vendor-specific SQL states * factored out AbstractFallbackSQLExceptionTranslator base class for consistent "fallbackTranslator" capabilities * CallableStatementCreatorFactory strictly honors "SqlParameter.isInputValueProvided" (allowing for statement caching) * JdbcTemplate passes full Calendar argument to JDBC driver even in case of no SQL type specified * JdbcTemplate does not call the costly "Statement.getWarnings()" unless ignoreWarnings=false or debug logging is on * added "checkFullyPopulated" setting to BeanPropertyRowMapper, for validating that all bean properties have been mapped Package org.springframework.jms * JmsException message and logged JMSException message explicitly includes linked exception now if not already contained * SingleConnectionFactory only calls "Connection.stop()" on reset when the shared Connection has actually been started * SingleConnectionFactory explicitly creates Queue/TopicConnection when first call is createQueue/TopicConnection method * CachingConnectionFactory explicitly creates Queue/TopicSession when first call is createQueue/TopicConnection method * CachingConnectionFactory's JMS Session proxies implement SessionProxy interface, allowing for access to target Session * CachingConnectionFactory rolls back cached transacted JMS Sessions on logical close if no commit/rollback was issued * CachingConnectionFactory explicitly closes cached JMS Sessions on Connection close * CachingConnectionFactory's cached producers pass on "disableMessageID" and "disableMessageTimestamp" properties * CachingConnectionFactory also caches MessageConsumers (controlled through "cacheConsumers" property) * AbstractJmsListeningContainer eagerly clears shared JMS Connection after releasing, avoiding repeated close exceptions * revised DefaultMessageListenerContainer to correctly work with non-JMS transaction manager and CACHE_CONNECTION level * DefaultMessageListenerContainer supports a stop notification callback for unlimited maxMessagesPerTask as well now * introduced SubscriptionNameProvider interface for message listener objects suggesting default subscription names * "jms:listener-container" uses actual message listener object's class name as default subscription name Package org.springframework.jmx * fixed NotificationListenerHolder to correctly handle multiple specified object names * added "allowEagerInit" property to MBeanExporter, for autodetecting lazy-init beans and FactoryBean-produced objects * added "environment" property to MBeanClientInterceptor and NotificationListenerRegistar, allowing for JMX env entries * added "refreshOnConnectFailure" property to MBeanClientInterceptor, allowing for reconnect in case of I/O failure Package org.springframework.mail * ConfigurableMimeFileTypeMap explicitly closes the InputStream that it uses for "mime.types" resource reading Package org.springframework.mock * SimpleNamingContextBuilder supports "deactivate()"+"activate()", with the standard JNDI provider exposed inbetween Package org.springframework.orm * HibernateTemplate detects Spring-managed transactional Session even with SessionFactory proxy and allowCreate=false * HibernateTemplate's "loadAll" operation selects distinct root entities (avoiding duplicate entries in result list) * HibernateTemplate translates Hibernate's DataException into a Spring DataIntegrityViolationException (for consistency) * fixed HibernateTransactionManager's "earlyFlushBeforeCommit" feature to apply to the outermost transaction only * added "packagesToScan" property to Hibernate AnnotationSessionFactoryBean, for autodetection of @Entity classes * HibernateJpaDialect checks "EntityManager.getDelegate()" as well to find Hibernate Session (for Seam compatibility) * added "persistenceXmlLocation" property to DefaultPersistenceUnitManager, as alternative to "persistenceXmlLocations" * @PersistenceContext of type TRANSACTION allows returned Query objects to be parameterized and executed as well * @PersistenceContext for default EntityManagerFactory lookup works even in an @Configurable Hibernate entity Package org.springframework.remoting * added "interceptors" property to RemoteExporter, allowing for registering custom AOP interceptors before the endpoint * RmiClientInterceptor always logs connect failure at warn level, even when debug logging (incl. stacktrace) is active * JndiRmiClientInterceptor skips narrowing for RmiInvocationHandler stubs (fixing a regression in 2.5.4) * Hessian/Burlap service exporters explicitly close input and output streams now (not relying on servlet container) * Simple/CommonsHttpInvokerRequestExecutor set the current locale according to LocaleContextHolder as HTTP lang header * JaxWsPortProxyFactoryBean exposes the JAX-WS BindingProvider interface in the Spring-generated proxy as well Package org.springframework.scheduling * SchedulerFactoryBean populates scheduler context first before satisfying SchedulerContextAware on a given JobFactory * SchedulerFactoryBean uses bean name as default scheduler name (when "schedulerName" property not explicitly specified) * SchedulerFactoryBean does not accept a pre-registered Scheduler instance in the Quartz SchedulerRepository anymore * SchedulerFactoryBean does not expose the Spring-created/managed Scheduler to the Quartz SchedulerRepository anymore * added "exposeSchedulerInRepository" flag to SchedulerFactoryBean, for explicit exposure to the SchedulerRepository * introduced SchedulerAccessorBean for registering jobs/triggers/listeners on an existing Quartz Scheduler instance * ScheduledExecutorFactoryBean uses Runnable decorator for logging exceptions that lead to termination of execution Package org.springframework.test * SpringJUnit4ClassRunner skips execution of test classes with non-matching @IfProfileValue annotation completely Package org.springframework.transaction * AbstractPlatformTransactionManager resumes after any kind of inner begin failure (not just after TransactionException) * TransactionSynchronizationManager interaction gets logged at trace level only (minimizing debug log per transaction) * JotmFactoryBean sets "defaultTimeout" value as actual JOTM default (even if no transaction timeout specified at all) Package org.springframework.util * fixed "StringUtils.delete" to prevent an eternal loop in case of the pattern being empty * "StringUtils.cleanPath" preserves leading slash if given in original path * "FileSystemUtils.copyRecursively" ignores 'special' files (i.e. neither a regular file nor a directory) Package org.springframework.web * HttpRequestHandlerServlet propagates HTTP request locale into Spring's LocaleContextHolder * revised "WebUtils.extractFilenameFromUrlPath" to search actual URI part only even when given a URL with query string * Log4jNestedDiagnosticContextFilter/Interceptor explicitly remove the NDC stack if depth=0 after the "NDC.pop()" call * fixed FacesWebRequest's "getParameterValues" implementation to use "ExternalContext.getRequestParameterValuesMap" * PortletContextResource cleans given path (analogous to ServletContextResource) * Servlet/PortletContextResource accept path with leading "/../" part as well (as accepted by most servlet containers) * DispatcherServlet removes error-view-driven servlet request attributes after rendering (for Tomcat compatibility) * exposed "getParamName()" method on LocaleChangeInterceptor and ThemeChangeInterceptor * added "cacheSecondsForSessionAttributeHandlers" property to Servlet/Portlet AnnotationMethodHandlerAdapter * AnnotationMethodHandlerAdapter exposes special ModelMap that removes BindingResult if target attribute gets replaced * Servlet AnnotationMethodHandlerAdapter always takes first exact @RequestMapping path match as best path match * @MVC handler methods, model attribute methods and init binder methods allow for overriding a generic superclass method * @ModelAttribute annotated handler method arguments can resolve to a null value as well (when contained in the model) * standard method argument subtypes (such as a Principal subclass) fail with a descriptive exception if incompatible * Portlet AbstractCommandController falls back to lazy command creation if session timed out after action phase * ByteArray/StringMultipartFileEditor do not log warning but rather include root cause in IllegalArgumentException * InternalResourceView's "preventDispatchLoop" checks against the same request's URI only (for Portlet compatibility) * made RedirectView's "renderMergedOutputModel" implementation non-final * VelocityConfigurer exposes ServletContext as VelocityEngine attribute (analogous to the standard VelocityViewServlet) * revised XsltView to specify full resource URI as StreamSource system id, for properly resolving relative paths * officially deprecated AbstractXsltView in favor of XsltView and its more flexible "locateSource" mechanism * revised error logging during XSLT processing to properly log compilation errors before an eventual fatal exception * moved internal TransformerUtils helper class to generic "org.springframework.util.xml" package Changes in version 2.5.5 (2008-06-23) ------------------------------------- General * fixed SCM URL in Maven POMs * "-with-dependencies" distribution includes "jarcontent" folder now (needed for building from the source) * upgraded to Quartz 1.6.1 (includes a fix for the Spring trigger persistence problem that was introduced in 1.6.0) * upgraded to Hibernate 3.3.0 (while retaining compatibility with Hibernate 3.1/3.2) * upgraded to iBATIS SQL Maps 2.3.2 (while retaining compatibility with iBATIS 2.3.0) Package org.springframework.aop * added "proxyClassLoader" property to ProxyFactoryBean, AbstractSingletonProxyFactoryBean and AbstractAutoProxyCreator * CustomizableTraceInterceptor hides proxy class names even in log replacement strings (if hideProxyClassNames=true) * CustomizableTraceInterceptor properly escapes all "\" and "$" symbols in replacement values Package org.springframework.beans * revised GenericTypeAwarePropertyDescriptor for compatibility with IBM's JDK 1.6 (avoiding NPE) * TypeMismatchException shows type description for mismatching JDK proxy values (listing their implemented interfaces) * CustomNumberEditor explicitly removes all inline whitespace from input Strings (for compatibility with French locales) * added "getDescription()" method to BeanDefinition interface (exposing the value of the XML bean description element) * AbstractFactoryBean uses bean ClassLoader for the generation of early singleton proxies * PropertyPlaceholderConfigurer correctly manages resolution of set entries and map keys with modified hash code * fixed DefaultSingletonBeanRegistry's singleton exposure to remove singleton factory after creation of singleton object * DefaultSingletonBeanRegistry only exposes related causes on outermost creation exception (avoiding excessive logging) * DefaultSingletonBeanRegistry only registers same related cause (i.e. same message, same chained cause) once * DefaultListableBeanFactory only registers causes during constructor resolution when resolution eventually fails * DefaultListableBeanFactory checks primary attribute in bean definitions of parent factory as well * fixed DefaultListableBeanFactory to use a post-processing lock (for proper synchronization of annotation scanning) * dependency check "simple" accepts Number, Date, URI, URL and Locale as well (consistent with simple MVC value types) * UnsatisfiedDependencyException preserves full nested exception stacktrace in case of a BeansException * added overloaded BeanComponentDefinition constructor with aliases argument * GenericBeanFactoryAccessor's "getBeansWithAnnotation" performs deep search (including interfaces and target class) * added "findAnnotationOnBean" method to GenericBeanFactoryAccessor, performing a deep search on a specific bean * BeanConfigurerSupport (@Configurable processing) includes type of bean in warn log when called in unconfigured state * restored BeanConfigurerSupport's silent skipping in case of no BeanFactory configured yet Package org.springframework.context * factored out MessageSourceSupport base class from AbstractMessageSource, providing common MessageFormat handling * DelegatingMessageSource resolves message arguments in default messages even if there is no parent MessageSource * MessageSourceResourceBundle exposes Spring-specified locale through overridden "ResourceBundle.getLocale()" method * revised CommonAnnotationBeanPostProcessor's "getResource" method to allow for proper overriding in subclasses * ClassPathBeanDefinitionScanner always accepts explicit bean definition of same name as override for scanned bean * added type="custom" expression="" option to component-scan's "include-filter"/"exclude-filter" * component-scan's "include-filter"/"exclude-filter" entries are validated individually (for Spring IDE) Package org.springframework.core * added assertions to GenericTypeResolver (avoiding NPEs) * factored out generic ConfigurableObjectInputStream class from CodebaseAwareObjectInputStream in RMI support * re-enabled PathMatchingResourcePatternResolver's JarURLConnection handling (accidentally disabled in 2.5.4) Package org.springframework.ejb * "jee:local/remote-slsb" accepts plain object returned from EJBHome create method (for JBoss 4.2 EJB3 compatibility) * added "exposeAccessContext" flag to AbstractSlsbInvokerInterceptor, for WebLogic resource factories with authorization * added "expose-access-context" flag to "jee:local-slsb", "jee:remote-slsb" and "jee:jndi-lookup" Package org.springframework.jdbc * added SimpleDriverDataSource alternative to DriverManagerDataSource, avoiding class loading and synchronization issues * BeanPropertySqlParameterSource uses specific integer/decimal SQL types by default now (e.g. TINYINT, BIGINT, DOUBLE) * introduced SqlXmlHandler abstraction (for the XML support in the Advanced Pack for Oracle Database) * added further SQL error code mapping for MS SQL Server Package org.springframework.jms * SingleConnectionFactory and TransactionAwareConnectionFactoryProxy use JMS API ClassLoader for proxy generation * JmsTemplate properly allows for overriding "getDefaultDestination()" and "getDefaultDestinationName()" * AbstractJmsListeningContainer sets Connection to null on shutdown, allowing for smooth reinitialization * DefaultMessageListenerContainer performs lazy setup in case of any connection exception (also JNDI lookup failure) * DefaultMessageListenerContainer is able to recover all cases where the provider is not available on startup * fixed DefaultMessageListenerContainer to avoid race condition when stopping through lock on unified monitor * added "container-class" attribute to "jms:listener-container" element, for specifying a custom implementation class * MessageListenerAdapter and JmsInvokerServiceExporter use message id as correlation id if no request correlation id set Package org.springframework.jmx * MBeanExporter performs default MBeanServer lookup even when registering notification listeners only Package org.springframework.jndi * added "exposeAccessContext" flag to JndiObjectFactoryBean, for WebLogic resource factories with authorization Package org.springframework.mail * removed overlapping "application/x-pointplus" MIME type for "css" extension from MimeMessageHelper's default mappings Package org.springframework.orm * improved HibernateTransactionManager's InvalidIsolationLevelException exception message (-> SpringTransactionFactory) * added "hibernateManagedSession" flag to HibernateTransactionManager, for working with a custom CurrentSessionContext * documented use of Hibernate StatelessSession with Spring's DataSourceTransactionManager/HibernateTransactionManager * added support for Derby and H2 through Hibernate/OpenJpa/TopLink/EclipseLinkJpaVendorAdapter's "database" property * Hibernate/TopLink/JDO/JPA proxy classes are generated in the ORM provider's ClassLoader (for full visibility in OSGi) * Spring-enriched JPA proxies are created in the application's ClassLoader (making any vendor interfaces work in OSGi) * fixed AbstractEntityManagerFactoryBean's EMF proxy to handle equals/hashCode locally (for correct equals behavior) * iBATIS SqlMapClientFactoryBean supports multiple sql-map-config files and also patterns ("configLocations" property) * iBATIS SqlMapClientFactoryBean supports Spring resource/pattern lookup of sql-map files ("mappingLocations" property) Package org.springframework.remoting * RemoteAccessException explicitly declares serialVersionUID (for serialization compatibility on WebLogic) * (Simple)HttpInvokerServiceExporter uses the ClassLoader of the containing BeanFactory for deserialization * fixed JaxWsClientInterceptor to throw a RemoteConnectFailureException (if applicable) instead of returning it * added support for "username"/"password"/"maintainSession"/"useSoapAction"/etc properties to JaxWsClientInterceptor * added SimpleHttpServerJaxWsServiceExporter, allowing for exposure through a fully configurable Sun JDK 1.6 HttpServer * added "filters" and "authenticator" property to SimpleHttpServerFactoryBean for Sun's JDK 1.6 HttpServer * revised HessianExporter's "debug" feature to work on Hessian 3.0.20+ as well (with input debugging only) Package org.springframework.scheduling * SchedulerFactoryBean's "jobSchedulingDataLocation" feature is compatible with Quartz 1.6.1 now (requiring 1.6.1+) Package org.springframework.scripting * ScriptFactoryPostProcessor ignores any "predictBeanType" failure (in particular reference to currently created bean) * GroovyScriptFactory also converts CompilationFailedException to ScriptCompilationException during type determination Package org.springframework.test * added "prepareApplicationContext(GenericApplicationContext)" template method to AbstractSingleSpringContextTests * added "prepareContext(GenericApplicationContext)" template method to AbstractGenericContextLoader * removed unnecessary "throws Exception" declarations from ReflectionTestUtils * added "getField" and "invokeGetterMethod" methods to ReflectionTestUtils Package org.springframework.transaction * transactional resource synchronization works even for operations triggered during commit (e.g. by JPA PostUpdate) * strengthened warning regarding @Transactional use on interfaces versus classes * "tx:annotation-driven" registers revised TransactionAttributeSourceAdvisor, initializing TransactionInterceptor lazily Package org.springframework.util * publicly exposed "isVisible" method on ClassUtils * added "getField" and simple "findField" method to ReflectionUtils * NumberUtils avoids overflow when converting from BigDecimal to BigInteger * NumberUtils automatically supports JDK 1.5+ localized BigDecimal parsing * added various overloaded methods with a CharSequence argument (as alternative to a String argument) to StringUtils * removed Commons Log usage from SystemPropertyUtils, ClassUtils, FileCopyUtils (avoiding early Log4J initialization) * revised CachingMapDecorator to expose all state representations in a thread-safe manner, even for pure introspection * revised CachingMapDecorator to use weak references for caching only (not losing a value from get) Package org.springframework.validation * fixed DefaultBindingErrorProcessor to register correct "missing field" errors within specified nested path Package org.springframework.web * revised RequestAttributes access from child threads in order to not touch the request object after request completion * DispatcherServlet exposes the Servlet spec's error attributes to error views (for JSP error page compatibility) * HandlerMethodInvoker does not eagerly copy entire model Map in order to avoid lazy initialization of attribute values * Servlet AnnotationMethodHandlerAdapter throws ambiguity exception in case of equivalent mappings with same method name * Portlet AbstractMapBasedHandlerMapping sorts predicates before checking them (according to their natural order) * Portlet DefaultAnnotationHandlerMapping checks default mappings last, independent from order of controller definition * RedirectView uses request's encoding (default ISO-8859-1) if no encoding scheme specified (previous default was UTF-8) * RedirectView considers arrays and collections with eligible values, turning them into multi-value request parameters * RedirectView accepts StringBuffers, StringBuilders, Numbers, Dates, URIs, URLs and Locales as eligible values as well * factored out common temporary byte array handling from AbstractPdfView etc into AbstractView base class * added AbstractPdfStamperView as alternative to AbstractPdfView, operating on an existing document with an AcroForm * fixed AbstractJasperReportsView to fully isolate a model-specified JDBC DataSource (not setting it as view DataSource) * AbstractJasperReportsView gives specified JDBC DataSource precedence over implicit report data value in model * AbstractJasperReportsView proceeds without report data value in case of multiple collections or object arrays * added "autocomplete" attribute to JSP FormTag (for a form-wide setting, as alternative to InputTag's "autocomplete") * JSF DelegatingVariableResolver and SpringBeanFacesELResolver log resolution success at trace level only Changes in version 2.5.4 (2008-04-28) ------------------------------------- General * upgraded to AspectJ 1.6 (while retaining compatibility with AspectJ 1.5.x) * fixed spring-core.jar's manifest to contain correct OSGi Import-Package declaration * removed superfluous DynamicImport-Package declarations from OSGi manifests * all decorator proxies are using identity hash code of the proxy instead of the InvocationHandler hash code now Package org.springframework.aop * fixed various AspectJ expression evaluation bugs through upgrading aspectjweaver.jar to AspectJ 1.6 Package org.springframework.beans * added CharsetEditor for JDK 1.4's "java.nio.charset.Charset" class to default property editors * BeanWrapper explicitly finds default PropertyEditor according to "Editor" suffix convention * deprecated BeanWrapper's fallback to the global JavaBeans PropertyEditorManager * DirectFieldAccessor registers Spring's common default PropertyEditors (like BeanWrapperImpl does) * fixed AbstractBeanDefinition to properly include qualifiers and primary flag in equals comparison * AbstractAutowireCapableBeanFactory's handling of lazy-init singletons is thread-safe again * AbstractAutowireCapableBeanFactory only invokes "predictBeanType" post-processor method for non-null bean Class Package org.springframework.core * introduced InfrastructureProxy interface for resource proxies to be implemented if supposed to be considered as equal * DefaultResourceLoader's ClassPathContextResource also returns ClassPathContextResource from "createRelative" * PathMatchingResourcePatternResolver resolves encoded jar URIs before creating JarFiles (for WebSphere compatibility) * PathMatchingResourcePatternResolver catches NoClassDefFoundError when looking for presence of Equinox classes * SimpleMetadataReaderFactory uses ResourceLoader's ClassLoader for loading annotation classes (for OSGi compatibility) Package org.springframework.jdbc * JdbcTemplate explicitly detects and skips null ResultSets returned from CallableStatement * BeanPropertySqlParameterSource avoids default use of JDBC 3.0's Types.BOOLEAN (for compatibility with MySQL) Package org.springframework.jms * fixed CachedMessageProducer to initialize its deliveryMode, priority and timeToLive fields with the target's settings Package org.springframework.orm * fixed Hibernate 3.2 support to flush updates before queries even within purely Spring-managed JTA transactions * Hibernate3 LocalSessionFactoryBean sets new SpringTransactionFactory as default in case of no JTA TransactionManager Package org.springframework.remoting * JndiRmiClientInterceptor/ProxyFactoryBean work for JNDI objects which do not implement the Remote interface as well Package org.springframework.test * "executeSqlScript" (as in SimpleJdbcTestUtils) allows for multi-line statements, each separated by a semicolon Package org.springframework.transaction * TransactionSynchronizationManager automatically unwraps InfrastructureProxy objects for raw key comparisons * AbstractFallbackTransactionAttributeSource uses concurrent Map for attribute cache in order to avoid lock contention Package org.springframework.validation * AbstractPropertyBindingResult's "formatFieldValue" finds PropertyEditor according to "Editor" suffix convention too * DefaultBindingErrorProcessor registers "missing field" errors within specified nested path (if any) Package org.springframework.web * added "findParameterValue" convenience method to WebUtils * ContextLoader uses its own ClassLoader for loading the default strategy (XmlWebApplicationContext) * added "contextAttribute" property (for WebApplicationContext retrieval) to DelegatingFilterProxy and FrameworkServlet * RequestContext does not fail when WebApplicationContext's ServletContext is null (like in a plain Portlet environment) * HandlerMethodInvoker does not copy whole model Set for session attribute exposure anymore (avoiding lazy value init) * fixed JSP form tags to properly return SKIP_BODY instead of the non-defined EVAL_PAGE (for WebLogic compatibility) Changes in version 2.5.3 (2008-04-06) ------------------------------------- General * replaced junit-4.4.jar in with-dependencies distribution with official JUnit 4.4 jar * spring.jar does not include InstrumentationSavingAgent class anymore (for parent-last class loaders) * spring-context.jar includes optional OSGi imports for "context:annotation-config"'s autodetection purposes * Spring reference documentation covers JSF 1.2 and contains updated Struts 2.0 and Tapestry references * Spring reference documentation covers annotation-based controllers in Portlet chapter Package org.springframework.aop * deprecated ProxyFactoryBean's support for a target as last element in "interceptorNames" in favor of "targetName" * ProxyFactoryBean assumes a target bean if type cannot be determined for last element in "interceptorNames" list * AbstractAutoProxyCreator predicts proxy class as bean type if known already (instead of predicting the target class) * AbstractAutoProxyCreator exposes early singleton proxies (for resolving circular reference between proxied beans) * "bean(...)" pointcut designator matches against bean name aliases as well, not just against the canonical bean name Package org.springframework.beans * CharacterEditor's "allowEmpty" only translates empty String to null, keeping a single space String as space character * CustomNumberEditor treats number with leading zeros as decimal (removed unwanted octal support while preserving hex) * GenericTypeAwarePropertyDescriptor respects "propertyEditorClass" specified on original PropertyDescriptor * renamed ListableBeanFactory's "includePrototypes" flag to "includeNonSingletons" (affects javadoc only) * added "getEarlyBeanReference" hook to SmartInstantiationAwareBeanPostProcessor interface * AbstractBeanFactory does not log full exception stack trace (at debug level) on FactoryBean type check anymore * AbstractAutowireCapableBeanFactory allows for resolving circular reference between beans wrapped by BeanPostProcessors * DefaultListableBeanFactory passes full inherited AccessControlContext to the AccessController for bean creation * DefaultListableBeanFactory does not eagerly initialize target beans when autowiring a PriorityOrdered post-processor * PropertyPlaceholderConfigurer supports nested keys in placeholder keys as well (e.g. "${db.${environment}}") * PropertyPlaceholderConfigurer works properly even in case of default-autowire="byType" with FactoryBeans involved * fixed PropertyPlaceholderConfigurer's "nullValue" handling to avoid NPE for nested value * added "ignoreUnresolvableEditors" property to CustomEditorConfigurer, allowing to ignore type/editor classes not found * XmlBeanDefinitionReader's "getValidationModeForResource" method is protected now in order to allow for overriding * AbstractSimpleBeanDefinitionParser properly ignores namespace declaration attributes ("xmlns"/"xmlns:") * AutowiredAnnotationBeanPostProcessor processes @Autowired annotation on most specific method only (when overriding) * AutowiredAnnotationBeanPostProcessor marks @Autowired bean properties as processed (for @Required to accept them) Package org.springframework.context * ReloadableResourceBundleMessageSource is able to detect updates for a properties file stored in a jar/zip as well * AbstractApplicationContext's temporary ClassLoader explicitly excludes types to match (for OSGi LTW compatibility) * restored support for null location array argument in ClassPathXmlApplicationContext (for Apache CXF compatibility) * added "registration" attribute to mbean-export element, accepting "failOnExisting"/"ignoreExisting"/"replaceExisting" * CommonAnnotationBeanPostProcessor processes @Resource annotation on most specific method only (when overriding) * revised default annotation post-processor ordering to apply most specific processors first Package org.springframework.core * Conventions detects special generated subclasses (e.g. by OpenJPA) and derives the variable name from the superclass * revised LocalVariableTableParameterNameDiscoverer to avoid potential NPE in case of no parameter names found on Java 5 * revised DefaultValueStyler (and deprecated ReflectiveVisitorHelper) for better performance and no class loader leaks * StaticLabeledEnumResolver uses weak references to LabeledEnum class in order to avoid class loader leaks * added "lastModified()" method to Resource interface, for abstract access to the last-modified timestamp * ClassPathResource and UrlResource use the last-modified timestamp of the archive file for jar/zip contents * PathMatchingResourcePatternResolver sets "useCaches=false" on any JarURLConnection that it opens for path matching * PathMatchingResourcePatternResolver detects WebSphere 6.1 "bundleresource:" URLs and resolves them for path matching Package org.springframework.ejb * added "cacheSessionBean" flag to SimpleRemoteStatelessSessionProxyFactoryBean, for caching the session bean object * added "cache-session-bean" attribute to "jee:remote-slsb" configuration element * Spring 2.5 "jee:*" config elements use resource-ref="true" by default (non-resource-ref names will still work as well) Package org.springframework.jdbc * JndiDataSourceLookup uses "resourceRef"=true by default (being able to resolve J2EE "jdbc/myDb" ENC names by default) * NativeJdbcExtractorAdapter only processes DatabaseMetaData Connection if non-null (for WebLogic cluster compatibility) * fixed SQLException translation for IBM DB2 and MS SQL to operate on error codes first, just falling back to SQL state * added MySQL NDB error codes and further DB2 error codes to default "sql-error-codes.xml" file * factored out common AbstractColumnMaxValueIncrementer base class from Derby/Hsql/MySQLMaxValueIncrementer * added DB2MainframeSequenceMaxValueIncrementer for DB2/390 and DB2/400 (differing from DB2 UDB for Unix and Windows) * added "wrapAsLob" property to DefaultLobHandler, for passing Blob/Clob instances to the JDBC driver (for PostgreSQL) * DefaultLobHandler's "streamAsLob" setting (requires JDBC 4.0) applies to byte array and String arguments as well * JdbcTemplate creates LinkedHashMap (instead of plain HashMap) as default results Map returned from "call" operation * JdbcDaoSupport does not override specified JdbcTemplate on subsequent "setDataSource" call for same DataSource * NamedParameterJdbcTemplate ignores Postgres-style "::" casting operator (i.e. not treated as named parameter) * SimpleJdbcInsert supports "autoGeneratedKey" simulation using "insert ... returning" for PostgreSQL 8.2 and later * SimpleJdbcCall supports metadata lookup of procedure columns for PostgreSQL (requires JDBC driver 8.3 or later) Package org.springframework.jms * SingleConnectionFactory accepts "Connections.setClientID" calls with the same client ID as specified on the factory * SingleConnectionFactory accepts further "Connection.setExceptionListener" calls in "reconnectOnException" mode * introduced CachingConnectionFactory (as subclass of SingleConnectionFactory) for JMS 1.1 session and producer pooling * SimpleMessageListenerContainer registers itself as ExceptionListener for automatic Connection recovery * added "runningAllowed()" template method to DefaultMessageListenerContainer, allowing subclass to temporarily suspend * DefaultMessageListenerContainer scales concurrent invokers eagerly in case of a sudden burst (revised idle handling) * DefaultMessageListenerContainer uses a "maxMessagesPerTask" default of 10 when associated with a ScheduledTaskExecutor * DefaultMessageListenerContainer propagates JMSExceptions thrown from a listener, potentially triggering recovery * MessageListenerAdapter propagates JMSExceptions thrown from listener method as-is (no wrapping in runtime exception) * MessageListenerAdapter invokes target (SessionAware)MessageListener immediately, not extracting the content upfront * added "cache" attribute to "jms:listener-container" configuration element, for customizing the resource cache level Package org.springframework.jmx * MBeanExporter's autodetection does not cause CannotLoadBeanClassException for lazy-init beans (Spring 2.0 compatible) Package org.springframework.jndi * JndiLocatorSupport tries fallback lookup for originally specified JNDI name if resource-ref adapted name wasn't found * JndiObjectFactoryBean exposes the bean ClassLoader as thread context ClassLoader (if necessary) Package org.springframework.mock * MockHttpServletResponse's "encodeURL" allows for central overriding in subclasses (affecting "encodeRedirectURL" too) * SimpleNamingContext's "createSubcontext" works correctly for given subcontext names without trailing slash as well Package org.springframework.orm * XxxDaoSupport does not override specified XxxTemplate on subsequent "setZzzFactory" call for same factory * added "executeWithNewSession" and "executeWithNativeSession" methods to HibernateTemplate * revised EntityManagerFactoryInfo handling to autodetect all EntityManager interfaces if no JpaVendorAdapter specified * PersistenceAnnotationBeanPostProcessor processes annotations on most specific method only (when overriding) Package org.springframework.remoting * revised (Simple)Hessian/BurlapServiceExporter's handling of non-POST requests (avoiding unnecessary warnings) Package org.springframework.scheduling * added "waitForTasksToCompleteOnShutdown" property to ThreadPoolTaskExecutor * changed ThreadPoolTaskExecutor's default behavior to shutdown immediately, not waiting for scheduled tasks * ThreadPoolTaskExecutor extends CustomizableThreadFactory for common bean properties and uses itself as default factory * ThreadPoolTaskExecutor uses its bean name as default thread name prefix (analogous to DefaultMessageListenerContainer) * MethodInvokingRunnable logs target exception directly at error level (instead of InvocationTargetException wrapper) * MethodInvokingJobDetailFactoryBean propagates invocation exceptions as non-JobExecutionExceptions (for error logging) * DelegatingJob propagates exceptions as-is instead of wrapping them in JobExecutionExceptions (for error logging) Package org.springframework.scripting * ResourceScriptSource is able to detect updates for a script file stored in a jar/zip as well Package org.springframework.test * @IfProfileValue correctly checked against concrete test class, even in case of overridden test methods * @IfProfileValue annotation without specified value checks against presence (non-null value) of the given profile key * "executeSqlScript" (as in SimpleJdbcTestUtils) allows for multiple statements per line, separated by semicolons * SpringJUnit4ClassRunner catches AssumptionViolatedException in @Before methods (analogous to standard JUnit 4.4) * SpringJUnit4ClassRunner executes befores/afters in same thread for test method with JUnit timeout (-> transactions) * TransactionalTestExecutionListener is able to manage concurrent transactions for different test methods (with timeout) * TransactionalTestExecutionListener reobtains transaction manager for every transaction (picking up context changes) * fixed Abstract(Transactional)JUnit(38/4)SpringContextTests classes to be actually marked as abstract Package org.springframework.transaction * JtaTransactionManager" checks JNDI location "java:appserver/TransactionManager" for GlassFish's primary TM handle Package org.springframework.util * "ClassUtils.resolveClassName" preserves the original root cause in the rethrown IllegalArgumentException * NumberUtils treats number with leading zeros as decimal (removed unwanted octal support while preserving hex) * MethodInvoker scans all declared methods (of any visibility), being able to invoke protected/private methods as well * added "getChildElementsByTagNames" method with tag names Collection argument to DomUtils Package org.springframework.validation * factored out AbstractErrors base class from AbstractBindingResult, providing common access to evaluated errors * added "getRawFieldValue" and "findEditor" methods to BindingResult interface (for a completely decoupled BindStatus) * fixed AbstractPropertyBindingResult's "getFieldType" to correctly apply nested path to field name * added convenience constructors to ObjectError and FieldError Package org.springframework.web * ContextLoader accepts system property placeholders in "contextConfigLocation" value (again) * OncePerRequestFilter cleans up its marker attribute at the end of each outer request (for Portlet compatibility) * RequestContextFilter supports "threadContextInheritable" init-param (analogous to DispatcherServlet) * HttpRequestHandlerServlet translates HttpRequestMethodNotSupportedException into HTTP status code 405 * DispatcherServlet translates HttpRequestMethodNotSupportedException into HTTP status code 405 by default * introduced WEB_APPLICATION_CONTEXT_ATTRIBUTE in RequestContext, for overriding the DispatcherServlet context * ControllerClassNameHandlerMapping detects @Controller beans by default as well * ControllerClassNameHandlerMapping registers plain path for multi-action controllers too ("/welcome/*" + "/welcome") * added ControllerBeanNameHandlerMapping, deriving URL paths from bean names for well-known controller types * AnnotationMethodHandlerAdapter's @RequestMapping matching is deterministic independent from the declared methor order * AnnotationMethodHandlerAdapter accepts @RequestParam annotations for @InitBinder methods as well * AnnotationMethodHandlerAdapter always exposes BindingResult objects for model attributes which are binding candidates * AnnotationMethodHandlerAdapter throws clear IllegalStateException in case of invalid BindingResult argument * Portlet AnnotationMethodHandlerAdapter supports Servlet ModelAndView and View objects as handler method return values * default attribute names for annotated handler method return values are consistently derived from the declared type * added "exposedContextBeanNames" property to InternalResourceView(Resolver), for exposing specific Spring beans only * InternalResourceView does not enforce ApplicationContext to be set anymore (allowing for "getServletContext" checking) * JstlView, Tiles(Jstl)View and AbstractJasperReportsView expose current RequestContext's MessageSource for localization * JSP form tags do not autogenerate id in case of empty id specified (empty id signals no id to be rendered) * JSP OptionTag and OptionsTag support "id" attribute now, analogous to RadioButton(s)Tag and Checkbox(es)Tag * added standard HTML "target" attribute to JSP FormTag, for submitting to another window/frame * fixed JSP LabelTag to render valid default "for" attribute for collection/map paths as well * fixed AbstractJasperReportsView to build exception messages for the specific sub-report location Changes in version 2.5.2 (2008-02-29) ------------------------------------- General * various reference documentation revisions (e.g. updated transaction management chapter) * removed outdated showcases sample applications from Spring distribution * spring-context.jar does not include InstrumentationSavingAgent class anymore (for parent-last class loaders) Package org.springframework.aop * AbstractRegexpMethodPointcut matches against target class as well, not just against method's declaring class * ProxyFactoryBean and AbstractAutoProxyCreator check autodetected proxy interfaces for visibility in the ClassLoader * Cglib2AopProxy properly detects overridden "finalize()" methods, never dispatching them to the interceptor chain * CustomizableTraceInterceptor properly escapes method names and exception messages for regex parsing (wrt "$" signs) * marked AbstractRefreshableTargetSource's status accessors as synchronized * AbstractBeanFactoryBasedTargetSourceCreator applies containing BeanFactory's configuration to internal BeanFactory * AbstractBeanFactoryBasedTargetSourceCreator creates an independent internal BeanFactory per target bean * deprecated ClassLoaderAnalyzerInterceptor and associated ClassLoaderUtils class * reintroduced AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(ParserContext,Object) for Spring 2.0 compatibility Package org.springframework.beans * introduced PropertyAccessorFactory facade for obtaining BeanWrapper and direct field accessor instances * deprecated BeanWrapper's "setWrappedInstance" method in favor of recreating a BeanWrapper per target instance * BeanWrapperImpl trims an enum candidate value before matching it against the available enum values * BeanWrapperImpl resolves the target type for a generically typed bean property, performing appropriate type conversion * StringArrayPropertyEditor (for comma-delimited splitting of array elements) registered for short[], int[], long[] too * CustomDateEditor and CustomNumberEditor preserve original ParseException as root cause of IllegalArgumentException * MethodInvokingFactoryBean falls back to interpreting specified arguments as single method argument of array type * deprecated RefreshablePagedListHolder class and associated PagedListSourceProvider interface * added "getOriginatingBeanDefinition()" method to BeanDefinition interface, exposing the decorated definition (if any) * PropertyOverrideConfigurer is able to properly override target bean definitions behind a scoped proxy decorator * added "nullValue" property to PropertyPlaceholderConfigurer, allowing for resolving specific Strings into a null value * CustomEditorConfigurer and CustomScopeConfigurer accept editor/scope values as class names as well * factored out AliasRegistry/SimpleAliasRegistry from BeanDefinitionRegistry/AbstractBeanFactory * introduced SimpleBeanDefinitionRegistry implementation for bean definition reader testing * "registerAlias" allows for overriding as long as bean definition overriding is allowed * added convenient "autowireBean(Object existingBean)" method to AutowireCapableBeanFactory * AbstractAutowireCapableBeanFactory removes singleton if created for type check in case of circular reference issues * AbstractAutowireCapableBeanFactory applies specified TypeConverter to bean references as well (not just to literals) * AbstractAutowireCapableBeanFactory resolves the target type for a generically typed dependency (method parameter) * AbstractAutowireCapableBeanFactory's "applyBeanPropertyValues" fully initializes the BeanWrapper used for binding * AbstractAutowireCapableBeanFactory's "applyBeanPropertyValues" and "configureBean" use a cached merged bean definition * fixed AbstractAutowireCapableBeanFactory's "configureBean" (@Configurable) to avoid bean name creation for inner beans * fixed AbstractAutowireCapableBeanFactory to skip invocation of InstantiationAwareBeanPostProcessors for null bean * fixed AbstractAutowireCapableBeanFactory to always resolve the bean class before a FactoryBean type check * added "freezeConfiguration()" method to Configurable/DefaultListableBeanFactory, allowing for eager metadata caching * revised bean destruction logging to log at WARN level with exception toString only (full exception at DEBUG level) * AutowiredAnnotationBeanPostProcessor resolves the target type for a generically typed dependency (method parameter) * fixed AutowiredAnnotationBeanPostProcessor to correctly cache a collection with a single autowired bean as element * fixed AutowiredAnnotationBeanPostProcessor to not cache special dependencies such as request and session references * deprecated AbstractBeanDefinition's Spring 1.2 style "setSingleton" method in favor of Spring 2.0's "setScope" * deprecated BeanDefinitionBuilder's "addConstructorArg" in favor of the consistently named "addConstructorArgValue" * deprecated various rarely used BeanDefinitionBuilder methods in favor of settings on the raw BeanDefinition object * added overloaded "genericBeanDefinition(beanClass)" method and "setParentName" method to BeanDefinitionBuilder * added support for "(scope)" key to PropertiesBeanDefinitionReader: e.g. "myBean.(scope)=prototype" * refactored AbstractBeanConfigurerAspect into Abstract(InterfaceDriven)DependencyInjectionAspect * nested XML decoration elements (e.g. "aop:scoped-proxy") are explicitly rejected if no corresponding handler present * InitDestroy/Autowired/Common/PersistenceAnnotationBeanPostProcessor perform appropriate debug logging * factored out generic SpringBeanELResolver and SimpleSpringBeanELResolver from "web.jsf.SpringBeanFacesELResolver" Package org.springframework.context * added "getId()" method to ApplicationContext interface, with corresponding "setId" in AbstractApplicationContext class * moved CONFIG_LOCATION_DELIMITERS constant from ConfigurableWebApplicationContext to ConfigurableApplicationContext * fixed AbstractApplicationContext to correctly ignore FactoryBean results that implement the Lifecycle interface * AbstractApplicationContext processes Lifecycle callbacks in the order of bean creation by default * AbstractApplicationContext explicitly freezes its bean factory configuration at the end of the "refresh()" phase * exposed "allowBeanDefinitionOverriding"/"allowCircularReferences" properties in AbstractRefreshableApplicationContext * factored out AbstractRefreshableConfigApplicationContext base class for common handling of specified config locations * ClassPathXmlApplicationContext and FileSystemXmlApplicationContext allow for bean-style configuration * StaticApplicationContext builds GenericBeanDefinitions by default (instead of RootBeanDefinitions) * added "initApplicationContext(ApplicationContext)" template method to ApplicationObjectSupport * ClassPathBeanDefinitionScanner detects scoped-proxy bean definitions as compatible (in case of duplicate scanning) * refactored ClassPathBeanDefinitionScanner into various template methods (for easier overriding) * refactored ComponentScanBeanDefinitionParser into various template methods (for easier overriding) * ComponentScanBeanDefinitionParser includes annotation config processors in nested composite component * "context:component-scan" resolves "${...}" placeholders in package paths against system properties * "context:component-scan" explictly ignores directories that accidentally match a specified custom resource pattern * fixed "context:load-time-weaver" to not break post-processor detection in case of Spring jars deployed as shared libs * added "context:property-override" configuration element, as a sibling to "context:property-placeholder" Package org.springframework.core * introduced Named(Inheritable)ThreadLocal, used throughout the framework for self-descriptive thread-bound context * added "getParameterName()" method to MethodParameter, activated through a ParameterNameDiscoverer * factored out GenericTypeResolver from BridgeMethodResolver and GenericCollectionTypeResolver * factored out DecoratingClassLoader base class from OverridingClassLoader and ShadowingClassLoader * added "isReadable()" method to Resource interface, giving a readability hint upfront (supported by FileSystemResource) * fixed ClassMetadataReadingVisitor (as used by "context:component-scan") to correctly ignore *usage* of inner classes Package org.springframework.dao * PersistenceExceptionTranslationPostProcessor extends ProxyConfig and applies its settings to newly created proxies Package org.springframework.ejb * Local/SimpleRemoteSlsbInvokerInterceptor use EJB(Local)Home for EJB 2.x detection, for WebSphere compatibility * SimpleRemoteSlsbInvokerInterceptor properly detects CORBA connect failures on the IBM JVM (for WebSphere EJB access) Package org.springframework.instrument * added public "isInstrumentationAvailable()" method to InstrumentationLoadTimeWeaver, avoiding direct access to agent * fixed ShadowingClassLoader to not attempt defining a package in case of a class in the default package Package org.springframework.jca * ResourceAdapterApplicationContext registers BootstrapContext as resolvable dependency type (for @Autowired) * ResourceAdapterApplicationContext registers WorkManager as lazily resolvable dependency type (for @Autowired) * added "workManagerName" property to WorkManagerTaskExecutor, for J2EE env lookups in JNDI (e.g. a Geronimo gbean-ref) * introduced JBossWorkManagerTaskExecutor as adapter for the JBoss JCA WorkManager (analogous to CommonJ) * introduced GlassFishWorkManagerTaskExecutor as adapter for the GlassFish JCA WorkManager (analogous to CommonJ) Package org.springframework.jdbc * DriverManagerDataSource's "driverClassName" throws IllegalStateException instead of CannotGetJdbcConnectionException * added "defaultTransactionIsolationName" property to LazyConnectionDataSourceProxy * SQLStateSQLExceptionTranslator translates "01*" data truncation codes into DataIntegrityViolationException * SQLStateSQLExceptionTranslator translates "61*" deadlock codes into ConcurrencyFailureException * SQLErrorCodesSQLExceptionTranslator falls back to SQL state translation for IBM DB2 and MS SQL by default * added further default "sql-error-codes.xml" mappings for MS SQL, MySQL, PostgreSQL and Oracle * DatabaseStartupValidator lets startup continue instead of 'busy' waiting in case of thread interruption * JdbcTemplate falls back to type VARCHAR for a null value in case of an unknown SQL type specified against IBM DB2 * JdbcTemplate uses "PreparedStatement.setString" in case of LONGVARCHAR and CLOB (if given a String value) * fixed CallMetaDataContext to skip SqlParameter objects without name (avoiding NPE) * merged AbstractBeanPropertyRowMapper into concrete BeanPropertyRowMapper class * removed BeanPropertyRowMapper's "newInstance" method to avoid confusion with ParameterizedBeanPropertyRowMapper * revised BeanPropertyRowMapper to use JavaBean property introspection instead of expecting field/setter name matches * factored out "initBeanWrapper"/"getColumnValue" template methods in BeanPropertyRowMapper, allowing for customization * BeanPropertyRowMapper shares ResultSet value access logic with SingleColumnRowMapper * BeanPropertyRowMapper and SingleColumnRowMapper perform Oracle-specific "getObject" checks for unknown specified types * added ParameterizedSingleColumnRowMapper with a convenient "newInstance" method to specify the required type only once * BeanPropertySqlParameterSource derives a default SQL type from the corresponding property type (for typed null values) Package org.springframework.jms * improved SimpleMessageConverter's exception message for an unsupported message payload * DefaultMessageListenerContainer logs listener setup failures at INFO instead of ERROR level * DefaultMessageListenerContainer allows for specifying a callback on "stop", for a notification after actual stopping * DefaultMessageListenerContainer lets shutdown continue instead of 'busy' waiting in case of thread interruption * fixed DefaultMessageListenerContainer to correctly process "sessionTransacted=true" in case of locally exposed Session * SimpleMessageListenerContainer exposes listener Session as thread-bound resource for JmsTemplate calls (like DMLC) * deprecated ServerSessionMessageListenerContainer in favor of DefaultMessageListenerContainer/JmsMessageEndpointManager * DefaultJmsActivationSpecFactory is compatible with WebSphere MQ 6.0.2.1 as well now Package org.springframework.jmx * factored out "doUnregister(objectName)" and "onRegister(objectName,mbean)" methods in MBeanRegistrationSupport * MBeanExporter actually sets "exposeManagedResourceClassLoader" to "true" by default (matching the 2.5 javadoc now) * MBeanExporter explicitly removes all of its registered NotificationListeners from the target MBeanServer on shutdown * introduced NotificationListenerRegistrar for registering a listener with any MBean on any MBeanServer(Connection) Package org.springframework.mail * added "text/csv" to ConfigurableMimeFileTypeMap's and thus MimeMessageHelper's default MIME mappings Package org.springframework.mock * added "getServletContext()" method to MockHttpServletRequest (not available in the HttpServletRequest interface) Package org.springframework.orm * introduced "postProcessMappings" template method in Hibernate LocalSessionFactoryBean * fixed Hibernate AnnotationSessionFactoryBean to allow for mixed mapping sources (despite 2.5.1's "buildMappings" call) * HibernateTemplate exposes the "org.hibernate.event.EventSource" and "org.hibernate.classic.Session" interfaces as well * introduced "EntityManagerFactoryUtils.closeEntityManager" method that protects against exceptions thrown from close * Hibernate/Jpa/JdoTransactionManager explicitly rollback an active transaction before closing when begin failed * fixed TopLinkTransactionManager to correctly expose the underlying JDBC Connection in read-write transaction scenarios * JDO/JPA factories check autodetected proxy interfaces for visibility in the ClassLoader (for WebSphere compatibility) * added "entityManagerFactoryInterface" property to AbstractEntityManagerFactoryBean, as alternative to autodetection * added "getEntityManagerFactoryInterface()" to JpaVendorAdapter (for WebSphere compatibility of OpenJpaVendorAdapter) * added "getPersistenceProviderRootPackage()" to JpaVendorAdapter, for excluding provider classes from class overriding * introduced EclipseLinkJpaVendorAdapter and EclipseLinkJpaDialect, supporting EclipseLink 1.0 M4 or higher Package org.springframework.remoting * factored out RemotingSupport base class from RemoteAccessor and RemoteExporter * (Jndi)RmiClientInterceptor properly detects CORBA connect failures on the IBM JVM * HessianClientInterceptor and BurlapClientInterceptor expose the bean ClassLoader as thread context CL (if necessary) * added overloaded "executeRequest" method with original MethodInvocation argument to HttpInvokerClientInterceptor * added "hostname" bean property to SimpleHttpServerFactoryBean, for a specific network address to bind to Package org.springframework.scripting * introduced "ScriptFactory.requiresScriptedObjectRefresh(ScriptSource)" for object refresh even after a type check call * GroovyScriptFactory and JRubyScriptFactory refresh scripted object instances even after an intermediate type check * introduced "ScriptSource.suggestedClassName()" for dynamic Groovy scripts that do not define a class themselves * GroovyScriptFactory uses resource filename (for files) or bean name (for inline scripts) as suggested class name * added "depends-on" attribute to "lang:bsh/groovy/jruby" configuration element Package org.springframework.test * TestContextManager ignores default TestExecutionListeners that cannot be instantiated (e.g. due to spring-tx missing) * AbstractJUnit38SpringContextTests runs "afterTestMethod" callbacks even when "beforeTestMethod" or "setUp" failed * AbstractTestNGSpringContextTests executes Spring default callbacks in any case (marked with "alwaysRun = true") * added configurable "sqlScriptEncoding" property to AbstractTransactionalXxxSpringContextTests (for reading scripts) Package org.springframework.util * revised ConcurrencyThrottleSupport's interruption handling to throw an IllegalStateException instead of 'busy' waiting * deprecated ResponseTimeMonitor and PerformanceMonitorListener classes in favor of custom classes for specific needs Package org.springframework.validation * DataBinder's "initDirectFieldAccess()" sets the "extractOldValueForEditor" flag by default, analogous to bean access Package org.springframework.web * ServletRequestAttributes keeps hold onto the original session if a "request.getSession" call suddenly returns null * added "setConfigLocation" method to ConfigurableWeb/PortletApplicationContext, accepting an init-param style value * added "initServletContext(ServletContext)" template method to WebApplicationObjectSupport * optimized ServletContextResource's and PortletContextResource's "exists()" check to avoid unnecessary stream opening * Commons(Portlet)MultipartResolver catches and logs any exception thrown from file item cleanup (not propagating it) * introduced NativeWebRequest and MultipartRequest interfaces for even finer-grained generic request access options * introduced FacesRequestAttributes adapter, with attributes access falling back to current JSF FacesContext by default * added "dispatchOptionsRequest/TraceRequest" properties to FrameworkServlet, for dispatching all HTTP request methods * deprecated PathMap attribute and CommonsPathMapHandlerMapping class in favor annotation-based request mapping * deprecated ThrowawayController and ThrowawayControllerHandlerAdapter in favor annotation-based controllers * @RequestMapping's "method" attribute supported at type level as well, expressing restriction for entire handler * @RequestMapping's "params" attribute supported at type level for Servlets, expressing precondition for entire handler * @RequestMapping's "params" attribute supported at type level for Portlets, mapping mode+params onto specific handler * @RequestMapping annotation supports "!myParam" expressions for non-presence of a specific parameter as well * introduced WebArgumentResolver interface and "customArgumentResolver(s)" property on AnnotationMethodHandlerAdapter * factored out common HandlerMethodResolver/Invoker classes from Servlet/Portlet AnnotationMethodHandlerAdapter * AnnotationMethodHandlerAdapter does not restrict supported HTTP methods by default (allowing for PUT, DELETE as well) * AnnotationMethodHandlerAdapter narrows through method name resolution even for a set of equal non-empty mappings * AnnotationMethodHandlerAdapter resolves the target type for a generically typed @RequestParam/@ModelAttribute argument * AnnotationMethodHandlerAdapter properly allows for resolving a Principal argument to null (in case of none defined) * AnnotationMethodHandlerAdapter resolves InputStream/OutputStream and Reader/Writer subclasses as well * added "synchronizeOnSession" property to AnnotationMethodHandlerAdapter, analogous to AbstractController * fixed AnnotationMethodHandlerAdapter to avoid NPE in case of plain model attribute returned from handler method * Servlet AnnotationMethodHandlerAdapter sends HTTP 404 instead of throwing IllegalState if no handler method found * Portlet AnnotationMethodHandlerAdapter throws UnavailableException instead of IllegalState if no handler method found * added "prepareResponse"/"generatesDownloadContent" methods to AbstractView, for HTTPS cache header workaround for IE * AbstractPdfView and Abstract(J)ExcelView participate in AbstractView's HTTPS cache header workaround for IE * AbstractJasperReportsView does not perform a hard response reset, in favor of AbstractView's HTTPS cache workaround * AbstractTemplateView catches "HttpServletResponse.getContentType()" exceptions (for JBoss Portal compatibility) * InternalResourceView only exposes forward attributes when running on Servlet <2.5 (for GlassFish compatibility) * InternalResourceView detects circular dispatching to the same view even in case of pattern matches for same handler * InternalResourceView prevents dispatch to same handler path only if the "preventDispatchLoop" flag is set to "true" * InternalResourceViewResolver sets "preventDispatchLoop" to "true" for conventional name-based View instances only * JstlView exposes a JSTL-aware MessageSource even for a custom MessageSource passed in through the constructor * re-added AbstractDataBoundFormElementTag's COMMAND_NAME_VARIABLE_NAME in deprecated form (Spring 2.0.x compatibility) * made FormTag's MODEL_ATTRIBUTE_VARIABLE_NAME public (as replacement of COMMAND_NAME_VARIABLE_NAME) * JSP Checkbox(es)Tag and RadioButton(s)Tag render label as HTML label element after input element (for HTML compliance) * JSP CheckboxesTag and RadioButtonsTag compare raw item / raw Map key for selection check as well * JSP SelectTag and OptionsTag compare raw Map key for selection check as well Changes in version 2.5.1 (2008-01-09) ------------------------------------- General * refined PDF formatting settings for the reference documentation * added coverage of JAX-WS support to the reference documentation * added section on J2EE RAR deployment to the reference documentation * moved "org.springframework.web.bind/multipart" packages from spring-web.jar to spring-webmvc.jar * updated AspectJ jar in "-with-dependencies" distribution to AspectJ 1.5.4 * updated Groovy jar in "-with-dependencies" distribution to Groovy 1.5.1 * updated Hessian jar in "-with-dependencies" distribution to Hessian 3.1.3 * updated iText jar in "-with-dependencies" distribution to iText 2.0.7 * updated POI jar in "-with-dependencies" distribution to POI 3.0.1 Package org.springframework.aop * ProxyFactory caches CGLIB proxies only when underlying (Smart)ClassLoader does not indicate a reloadable Class * added "logTargetClassInvocation" property to AbstractMonitoringInterceptor, for logging the target invocation trace Package org.springframework.beans * ConfigurablePropertyAccessor extends the TypeConverter interface (moved up from BeanWrapper interface) * BeanWrapper supports well-known collection implementation types for generic element conversion again (like Spring 2.0) * TypeConverterDelegate protects its text conversion step against PropertyEditors which don't support "setValue" calls * factored out FactoryBeanRegistrySupport base class from AbstractBeanFactory and AbstractAutowireCapableBeanFactory * optimized AbstractBeanFactory's access to cached FactoryBean-exposed objects, avoiding unnecessary locks * ConstructorResolver prefers concrete class matches over interface matches at the same level when checking arguments * revised accidental public exposure of "isPrimary" method in ConfigurableListableBeanFactory/DefaultListableBeanFactory * moved "resolveDependency" implementation from AbstractAutowireCapableBeanFactory down to DefaultListableBeanFactory * revised DefaultListableBeanFactory's "resolveDependency" exceptions with respect to clarity and context inclusion * DefaultListableBeanFactory does not eagerly initialize FactoryBeans for type checks even with factory-bean reference * DefaultListableBeanFactory throws descriptive exception in case of factory-bean circular reference * DefaultListableBeanFactory supports ObjectFactory indirection for resolvable dependencies * DefaultListableBeanFactory always resolves bean class before checking a bean definition as autowire candidate * AbstractBeanDefinition stores and exposes the originating Resource (rather than just the resource description) * XmlBeanDefinitionReader detects recursive loading of the same resource (e.g. through import cycles) * DefaultBeanDefinitionDocumentReader sends ImportDefinition events containing the actually resolved Resource objects * DefaultDocumentLoader includes the JAXP IllegalArgumentException in the rethrown ParserConfigurationException * ClassPathBeanDefinitionScanner marks default init/destroy methods as not enforced (accepting beans without those) * SingletonBeanFactoryLocator falls back to a single bean of type BeanFactory (if any) when given a null locator key * SingletonBeanFactoryLocator removes bean factory group definition if its initialization fails * factored out protected "getTargetBean" method in ObjectFactoryCreatingFactoryBean (for easier overriding) * revised BeanConfigurerSupport to allow for usage as a delegate as well, not just as a base class * revised BeanConfigurerSupport to re-initialize its default BeanWiringInfoResolver for each context refresh * fixed AutowiredAnnotationBeanPostProcessor to properly cache dependencies that do not correspond to a registered bean * annotation processors detect already managed methods/fields, avoiding double invocation in case of multiple processors * explicit annotation processors override implicit default processors (as built by annotation-config / component-scan) Package org.springframework.cache * added "cacheManagerName" property to EhCacheManagerFactoryBean Package org.springframework.context * fixed AbstractApplicationContext to only send ContextStoppedEvent in case of "stop()" (i.e. not for "close()") * fixed AbstractApplicationContext to always detect LoadTimeWeaverAwareProcessor in the local ClassLoader (for OSGi) * ClassPath/FileSystemXmlApplicationContext perform early check for null elements in config location array * added "addMessages(Map, Locale)" method to StaticMessageSource, for bulk adding messages * ContextTypeMatchClassLoader does not generally exclude classes in the "org.springframework" package anymore * DefaultContextLoadTimeWeaver only chooses GlassFishLoadTimeWeaver when running in the EAR ClassLoader * DefaultContextLoadTimeWeaver removes all registered transformers from the VM Instrumentation object (if applicable) * CommonAnnotationBeanPostProcessor properly ignores @Resource-annotated JAX-WS WebServiceContext references * AnnotationBeanNameGenerator (used by "context:component-scan") detects default name values in custom annotation types * ClassPathScanningCandidateComponentProvider ("context:component-scan") ignores non-static inner and local classes * "context:property-placeholder" configuration element does not require a "location" attribute (for system properties) Package org.springframework.core * introduced SmartClassLoader marker interface, declaring a "boolean isClassReloadable(Class clazz)" operation * OverridingClassLoader excludes the "oracle." package by default as well (e.g. for TopLink's custom annotations) * MethodParameter uses reflection to obtain parameter annotations (for compatibility with the IBM 1.4.2 VM's debug mode) * LocalVariableTableParameterNameDiscoverer caches parameter names per method and obtained ASM ClassReaders per class * added "getEnclosingClassName()", "hasEnclosingClass()" and "isIndependent()" methods to ClassMetadata interface Package org.springframework.ejb * "jee:local-slsb" and "jee:remote-slsb" work for EJB3 Session Beans as well (as alternative to "jee:jndi-lookup") * introduced EJB3-compliant SpringBeanAutowiringInterceptor for processing Spring's @Autowired in EJB3 SBs/MDBs Package org.springframework.instrument * InstrumentationLoadTimeWeaver allows for operating on a pre-defined ClassLoader and for removing transformers again * TomcatInstrumentableClassLoader always passes local ClassLoader into ClassFileTransformers (makes AspectJ LTW work) * ShadowingClassLoader excludes the "com.ibm." package by default as well (for IBM JDK classes, DB2 JDBC driver, etc) Package org.springframework.jdbc * fixed JdbcUtils to not access the DatabaseMetaData implementation class for "extractDatabaseMetaData" calls * TransactionAwareDataSourceProxy obtains target Connections lazily when the first call comes in on the Connection proxy * added "reobtainTransactionalConnections" flag to TransactionAwareDataSourceProxy (for Connection handles on JBoss) * WebSphereDataSourceAdapter, JBossNativeJdbcExtractor and CommonsDbcpNativeJdbcExtractor propagate SQLExceptions as-is Package org.springframework.jms * JmsUtils protects against misbehaving JMS providers (such as ActiveMQ) when closing an interrupted MessageConsumer * JmsTemplate's standard "execute(ProducerCallback)" pre-initializes producer with default destination (if available) * added overloaded execute methods with Destination/destination name and ProducerCallback to JmsOperations/JmsTemplate * added various "browse"/"browseSelected" methods JmsOperations/JmsTemplate, for browsing a queue with a BrowserCallback * DelegatingConnectionFactory adapts specific create(Queue/Topic)Connection calls to a generic JMS 1.1 ConnectionFactory * JmsInvokerClientInterceptor accepts any JMS 1.1 ConnectionFactory, not insisting on a QueueConnectionFactory anymore * MethodListenerAdapter uses type difference weight algorithm to choose between ambiguous listener methods * DefaultMessageListenerContainer catches TaskRejectedException and pauses affected tasks for subsequent resuming * DefaultMessageListenerContainer exposes listener Session as thread-bound resource for JmsTemplate calls * ServerSessionMessageListenerContainer always establishes a shared Connection (even if autoStart="false") * CommonsPoolServerSessionFactory removes specific ServerSessionPool on close (for proper reuse on stop and restart) * "jms:listener-container" tag supports a concurrency range (e.g. "3-5"), for specifying a minimum number of consumers Package org.springframework.jmx * added "getServer()" method to MBeanRegistrationSupport (MBeanExporter), exposing the underlying JMX MBeanServer Package org.springframework.jndi * JndiTemplate prepares a specific Hashtable for the InitialContext, exposing default environment properties as well Package org.springframework.mail * fixed potential NPE in MailSendException Package org.springframework.mock * MockRequestDispatcher stores forwarded/included URL in MockHttpServletResponse even in case of wrapped response Package org.springframework.orm * LocalSessionFactoryBean uses LocalJtaDataSourceConnectionProvider (supporting aggressive release) in case of JTA TM * LocalSessionFactoryBean supports Connection release mode "after_statement" without "useTransactionAwareDataSource" too * LocalSessionFactoryBean eagerly compiles registered mappings, for availability in the post-processing phase * added "cacheProvider" property to LocalSessionFactoryBean, allowing for a Spring-managed CacheProvider instance * added overloaded "delete" methods with "entityName" argument to HibernateOperations and HibernateTemplate * added "earlyFlushBeforeCommit" flag to HibernateTransactionManager, allowing to enforce a flush before synchronization * fixed Jpa/JdoTransactionManager to correctly nest a REQUIRES_NEW transaction within a SUPPORTS scope with early access * JPA PersistenceUnitReader supports location patterns for the "jar-file" attribute in "persistence.xml" files * PersistenceAnnotationBeanPostProcessor accepts vendor-specific EntityManager interfaces for @PersistenceContext again Package org.springframework.remoting * HessianClientInterceptor/ProxyFactoryBean supports "debug", "chunkedPost", "readTimeout" and "hessian2" properties * HessianServiceExporter supports "debug" property analogous to Hessian 3.1.3's HessianServlet * HessianServiceExporter and BurlapServiceExporter expose the bean ClassLoader as thread context CL (if necessary) * factored out stream-based HessianExporter and BurlapExporter classes * factored out abstract RemoteInvocationSerializingExporter base class from HttpInvokerServiceExporter * introduced SimpleHttpInvokerServiceExporter and SimpleHessian/BurlapServiceExporter as HttpHandlers for Sun JRE 1.6 * introduced SimpleHttpServerFactoryBean for Spring-style set-up of a Sun JRE 1.6 HttpServer Package org.springframework.samples * PetClinic's JPA version showcases AspectJ load-time weaving, including @Transactional handling in AspectJ mode * PetClinic's JPA EntityManagerClinic uses explicit flushing and id assigning to make sure that the id is available Package org.springframework.scheduling * ThreadPoolTaskExecutor supports Java 6's "allowCoreThreadTimeOut" feature (for both native and backport-concurrent) Package org.springframework.scripting * fixed ScriptFactoryPostProcessor to avoid NPE in case of script that produces null value and no interfaces specified * StaticScriptSource exposes "StaticScript" as toString result, in order for Groovy to derive a valid class name from it * GroovyScriptFactory caches a temporarily created result object from "getScriptedObjectType" until "getScriptedObject" * GroovyScriptFactory exposes "getGroovyClassLoader()" method and lazily initializes the GroovyClassLoader * "lang:groovy/jruby/bsh" does not insist on an id for a scripted bean anymore (i.e. allows for anonymous scripts) Package org.springframework.test * fixed AbstractContextLoader to detect and accept "classpath*:" URLs as well * AbstractTestNGSpringContextTests does not define a "SpringTestContext" group anymore (for ease of using custom groups) Package org.springframework.transaction * added "validateExistingTransaction" property to AbstractPlatformTransactionManager, for isolation level checks * added "prepareForCommit" template method to AbstractPlatformTransactionManager, called before commit synchronization * JtaTransactionManager consistently throws TransactionSystemException in case of unexpected internal transaction state * JtaTransactionManager detects JBoss 4.2 transaction rollbacks caused by a timeout, throwing a meaningful exception * fixed WebSphereUowTransactionManager to correctly detect an existing global transaction (ignoring local tx contexts) Package org.springframework.ui * fixed ModelMap's "mergeAttributes" to correctly copy new attributes into the model * added "containsAttribute" method to ModelMap, as a more specific alternative to a general "containsKey" call * introduced Java-5-specific Model interface (for use with MVC handler methods) and corresponding ExtendedModelMap impl Package org.springframework.util * AutoPopulatingList is serializable now * MethodInvoker (and subclasses) use type difference weight algorithm to choose between multiple matching methods * FreeMarker "formSingleSelect" macro also accepts options from a sequence (list) as both labels and values Package org.springframework.validation * clarified that BindingResult's "getPropertyEditorRegistry()" method may return null to indicate no support for editors * DataBinder implements the TypeConverter interface, delegating to the underlying PropertyAccessor Package org.springframework.web * ContextLoader(Listener/Servlet) explicitly removes the context attribute from the ServletContext (for WLS hot deploy) * introduced static "getCurrentWebApplicationContext()" accessor on ContextLoader, for context lookup by thread * introduced SpringBeanAutowiringSupport class for self-autowiring classes within a web app (e.g. JAX-WS endpoints) * WebApplicationContext impls register request/session/ServletContext as resolvable dependencies (e.g. for @Autowired) * PortletApplicationContext impls register request/session/PortletContext as resolvable dependencies (for @Autowired) * CommonsMultipartResolver uses FileUpload 1.2's "isMultipartContent" variant when available (for stricter checks) * added "useCacheControlNoStore" property to WebContentGenerator, allowing to suppress the "no-store" header value * SimpleUrlHandlerMapping explicitly trims specified handler bean names (in order to ignore unintended whitespace) * UrlPathHelper detects a context path of "/" (as exposed by Jetty for includes) and processes it as root context ("") * improved NoSuchRequestHandlingMethodException's error message to include request URL and query string explicitly * DispatcherServlet consistently logs correct request URI for include requests (even in debug log messages) * MultiActionController properly supports String return types for handler methods (for consistency with @RequestMapping) * MultiActionController detects and rejects invalid last-modified method return types * WebRequest interface (as supported for @RequestMapping) supports "checkNotModified" method for last-modified handling * @RequestMapping paths are considered a match even without suffix (e.g. "/users" matches a request for "/users.do") * @InitBinder methods apply to @RequestParam parameters as well, with the @InitBinder value matched against param names * @ModelAttribute's default attribute names are consistently derived from the *declared* parameter/return type * AnnotationMethodHandlerAdapter properly handles overridden handler methods with overridden @RequestMapping annotation * AnnotationMethodHandlerAdapter maps relative paths specified at method level analogous to default method name mappings * AnnotationMethodHandlerAdapter throws an exception if it cannot find a clear best path match for a specific request * AnnotationMethodHandlerAdapter throws descriptive exception in case of optional parameter being declared as primitive * AnnotationMethodHandlerAdapter automatically resolves arguments of type Principal as the request's user principal * AnnotationMethodHandlerAdapter propagates checked exceptions as-is for handler/attribute/init-binder methods * AnnotationMethodHandlerAdapter applies @InitBinder methods for view preparation as well (like WebBindingInitializers) * AnnotationMethodHandlerAdapter applies binder initialization for 'end' views (with processing being complete) as well * factored out "createBinder" template method within AnnotationMethodHandlerAdapter, called for each binding attempt * Servlet AnnotationMethodHandlerAdapter supports View return value for handler methods (as alternative to view name) * fixed Portlet AnnotationMethodHandlerAdapter to explicitly check for Action/Render*Response* (to work on Liferay) * InternalResourceView prevents dispatching to same path as handler (e.g. with default view name and default resolver) * JstlView detects session-scoped JSTL LocalizationContext/Locale attributes and merges them with its own context * JstlView and (JspAware)RequestContext consistently use JSTL Config class for scoped attribute access * reworked Spring's Tiles2 support such that it can operate against the Tiles2 (2.0.5+) JDK 1.4 version as well * Tiles2 TilesView explicitly checks whether the Tiles container has been initialized (throwing a descriptive exception) * Tiles2 TilesView exposes Servlet 2.4 forward request attributes (for non-2.4-compliant web containers like OC4J) * fixed JSP BindTag to correctly detect and ignore a repeated nested path for the global errors case * JSP CheckboxTag/CheckboxesTag and RadioButtonTag/RadioButtonsTag use registered property editor for value rendering Changes in version 2.5 final (2007-11-19) ----------------------------------------- General * updated javadoc and reference documentation * revised PetPortal sample application into a full-fledged Java 5 showcase (annotation-based configuration etc) Package org.springframework.aop * fixed garbage collection problem with CGLIB proxies, using a strong reference map for the fixed interceptors Package org.springframework.context * "context:load-time-weaver" autodetects the GlassFish ClassLoader even within a GlassFish web app now * "context:load-time-weaver" correctly detects the use of the Spring VM agent on WebLogic 9 Package org.springframework.core * URL-to-File conversion for ClassPathResource/UrlResource performs URI-based decoding rather than using URLDecoder * optimized UrlResource's handling of URI access and File access if constructed with a URI directly * fixed AbstractLabeledEnum to correctly determine the default enum type for a top-level enum class (again) Package org.springframework.jdbc * added "registerDatabase" method to SQLErrorCodesFactory, for eager association of database names with DataSources Package org.springframework.jms * DefaultMessageListenerContainer avoids deadlock between Connection and Session through the use of a shared monitor Package org.springframework.jndi * fixed "jee:jndi-lookup" tag to correctly handle "default-value" and "default-ref" attributes Package org.springframework.orm * Hibernate SpringSessionSynchronization explicitly disconnects on suspend/completion (to make "on_close" work on JBoss) Package org.springframework.scheduling * fixed CommonJ TimerManagerFactoryBean to not require the "scheduledTimerListeners" property Package org.springframework.test * TestContextManager logs TestExecutionListener exceptions at error/warn level instead of info/debug Package org.springframework.transaction * JtaTransactionManager swallows IllegalStateException when synchronizing with existing transaction (for JBoss 4.2) Package org.springframework.web * CommonsMultipartResolver detects multiple files for the same field name and throws a corresponding exception * RequestToViewNameTranslator kicks in before the "HandlerInterceptor.postHandle" phase * RequestToViewNameTranslator's "getViewName" is allowed to return null if no default found * fixed AnnotationMethodHandlerAdapter to expose the implicit model even when using request-to-view-name translation * fixed AnnotationMethodHandlerAdapter to correctly match parameters even in case of request method specified as well * DispatcherPortlet/AnnotationMethodHandlerAdapter swallows IllegalStateException when setting implicit render parameter * Portlet AnnotationMethodHandlerAdapter preserves implicit model from action phase to render phase * Portlet AnnotationMethodHandlerAdapter applies cache settings (prevents caching when session attributes are involved) * Portlet AnnotationMethodHandlerAdapter allows default @RequestMapping annotations for action as well as render methods * Portlet AnnotationMethodHandlerAdapter resolves PortletPreferences, PortletMode, WindowState, PortalContext arguments * factored out AbstractWizardFormController's "getTargetPage" logic into WebUtils/PortletUtils, for reuse in custom code * InternalResourceView explicitly sets content type on response in include case (for correct charset handling on Tomcat) * exposed applicable standard HTML attributes on JSP "form:option" and "form:options" tags * JSP form tags always autogenerate valid HTML ids (not including "[" or "]" characters from array element properties) Changes in version 2.5 RC2 (2007-11-12) --------------------------------------- General * introduced complete rewrite of the Spring MVC step-by-step guide for version 2.5 Package org.springframework.aop * fixed garbage collection problem with CGLIB proxies, now holding onto the Advised configuration independent of factory Package org.springframework.beans * DefaultListableBeanFactory now supports autowiring of FactoryBean instances 'by type' * revised DefaultListableBeanFactory's exception handling for clearer wrapping of nested exceptions * DefaultListableBeanFactory performs bean creation within a PrivilegedAction (for SecurityManager compatibility) * optimized DefaultListableBeanFactory's invocation of setter methods for re-created bean instances * optimized DefaultListableBeanFactory's invocation of post-processor methods * changed XmlReaderContext's "getReader()" to expose the XmlBeanDefinitionReader again (for backwards compatibility) * AutowiredAnnotationBeanPostProcessor caches determined candidate constructors per bean class * RequiredAnnotationBeanPostProcessor caches validated bean names, skipping re-validation for the same bean * added bean type argument to MergedBeanDefinitionPostProcessor (for InitDestroyAnnotationBeanPostProcessor) Package org.springframework.context * "context:mbean-export" autodetects WebLogic and WebSphere, performing an appropriate MBeanServer lookup * "context:mbean-export" falls back to a simple MBeanExporter on JDK 1.4, detecting standard MBeans * introduced "context:mbean-server" configuration element, for setting up a standalone MBeanServer reference * "context:load-time-weaver" automatically activates "spring-configured" if AspectJ weaving is enabled * "context:load-time-weaver"'s temporary ClassLoader for type matching uses a fully isolated loader for each match Package org.springframework.dao * PersistenceExceptionTranslationAdvisor detects @Repository on interfaces as well Package org.springframework.jca * added missing "refresh()" call to SpringContextResourceAdapter's ApplicationContext Package org.springframework.jdbc * TransactionAwareDataSourceProxy exposes a special "toString()" result for its Connection proxies * fixed SingleColumnRowMapper to use passed-in required type in the default "convertValueToRequiredType" implementation * SimpleJdbcCallOperations and SimpleJdbcInsertOperations return the interface type (not the impl) for method chaining Package org.springframework.jndi * "jee:jndi-lookup" supports "default-value" and "default-ref" attributes, translated to a default object Package org.springframework.mail * MailSendExceptions keeps failed messages in a LinkedHashMap, allowing for access in the order of sending * added "getMessageExceptions()" accessor to MailSendException, with "getFailedMessages()" being transient now Package org.springframework.orm * fixed Jpa/JdoTransactionManager to correctly suspend and resume even for dialects without JDBC Connection retrieval * SqlMapClientTemplate explicitly checks for TransactionAwareDataSourceProxy, avoiding double synchronization Package org.springframework.remoting * RmiClientInterceptor and AbstractSlsbInvokerInterceptor do not consider MarshalException as connect failure anymore Package org.springframework.stereotype * @Component, @Repository, etc are not marked as inherited anymore (i.e. inheritance checks to be performed explicitly) Package org.springframework.test * AbstractGenericContextLoader provides an opportunity for subclasses to customize the context before calling refresh * revised TestExecutionListener method signatures to declare Exception instead of Throwable Package org.springframework.transaction * "tx:jta-transaction-manager" autodetects Oracle OC4J as well, in addition to WebLogic and WebSphere Package org.springframework.web * ContextLoader provides an opportunity for subclasses to customize the context before calling refresh * made AbstractController's handleRequest entry point method non-final (allowing for overriding and CGLIB proxying) * AbstractUrlHandlerMapping always takes the first matching path (in case of multiple path patterns of equal length) * AnnotationMethodHandlerAdapter for Servlet MVC exposes UrlPathHelper and PathMatcher configuration properties * AnnotationMethodHandlerAdapter for Servlet MVC supports MethodNameResolver for resolving default handler methods * AnnotationMethodHandlerAdapter for Servlet MVC supports path patterns for @RequestMapping at the method level as well * AnnotationMethodHandlerAdapter for Servlet MVC always prevents HTTP caching in case of @SessionAttributes specified * reworked @RequestMapping's "type" attribute into "method", accepting strongly typed @RequestMethod enum values * revised AnnotationMethodHandlerAdapter's resolution of multiple matching handler methods to take params into account * @RequestParam's "value" attribute is not required anymore, defaulting to the method parameter name (if available) * added "types" attribute to @SessionAttributes, allowing to enumerate model attributes types instead of names * AbstractJasperReportsSingleFormatView converts exporter parameter values in the model (if appropriate) * InternalResourceView lets explicit model attributes override Spring beans in case of "exposeContextBeansAsAttributes" * JstlView does not set "exposeContextBeansAsAttributes" flag to "true" by default (analogous to InternalResourceView) * JSF 1.1 DelegatingVariableResolver checks original VariableResolver first again (for strict backwards compatibility) * introduced JSF 1.1 SpringBeanVariableResolver, letting Spring bean definitions override other attributes of same name * renamed JSF 1.2 DelegatingFacesELResolver to SpringBeanFacesELResolver, indicating its concrete lookup strategy * fixed Tiles 1.x TilesConfigurer to explicitly set the factory name to empty String by default Changes in version 2.5 RC1 (2007-10-22) --------------------------------------- General * introduced spring-framework-with-docs.zip distribution; reduced spring-framework.zip to the minimal binaries * spring.jar does not include Servlet Web MVC support anymore; add spring-webmvc.jar separately * spring.jar and spring-core.jar include repackaged version of ASM 2.2.3 (avoiding side effects with other ASM versions) * spring-orm.jar contains the web ORM support (again), in order to avoid split packages across bundles * spring-web.jar includes the entire Hessian, Burlap, HTTP invoker, JAX-RPC and JAX-WS support (avoiding split packages) * removed outdated Countries sample application * revised PetClinic sample application into a full-fledged Java 5 showcase (annotation-based configuration etc) * revised default handling in BeanDefinitionParsers for XML config namespaces to work without XSD validation as well * updated Spring's JDO support to require JDO 2.0 or higher, with early support for JDO 2.1 features Package org.springframework.aop * revised AdvisedSupport to avoid lock contention for method cache lookups (using a concurrent map with special keys) * fixed AspectJ pointcut handling to strictly match generic return types according to Java language rules * AspectJ pointcut matching only registers LocalVariableTableParameterNameDiscoverer if ASM is present on the classpath * removed unused pointcut type attribute from "spring-aop-2.5.xsd" Package org.springframework.beans * BeanWrapperImpl obtains old value with converted key in case of a Map with non-String keys * TypeMismatchException and MethodInvocationException are serializable even in case of non-serializable property values * URIEditor only tries to resolve "classpath:" locations if explicitly constructed with a ClassLoader * URIEditor converts spaces in location values into "%20" quotes (as required by the URI format) * exposed "autowireCandidate" property in BeanDefinition interface (avoiding casts to AbstractBeanDefinition) * deprecated ConfigurableBeanFactory's "registerCustomEditor" in favor of "addPropertyEditorRegistrar" * AbstractBeanFactory ignores PropertyEditorRegistrars which tried to obtain a currently created bean * revised AbstractBeanFactory to detect FactoryBeans which are in turn created through factory methods * DefaultListableBeanFactory freshly resolves autowired arguments even for cached constructors (re-resolving prototypes) * DefaultListableBeanFactory removes a singleton bean instance if a new bean definition gets registered * DefaultListableBeanFactory fully destroys singleton bean instance when the corresponding bean definition gets replaced * DefaultListableBeanFactory resets the caches for all derived beans as well if a bean definition gets replaced * fixed CglibSubclassingInstantiationStrategy to avoid CGLIB class leak for inner prototypes with MethodReplacer usage * XmlBeanDefinitionReader initializes default EntityResolver lazily, avoiding classpath scan in case of custom resolver * DefaultNamespaceHandlerResolver exposes public DEFAULT_HANDLER_MAPPINGS_LOCATION constant * DefaultNamespaceHandlerResolver loads NamespaceHandler mappings and classes lazily (only when namespace actually used) * fixed BeanDefinitionParserDelegate to correctly parse property sub-elements even with custom name for beans namespace * BeanDefinitionParserDelegate stores definition source for metadata attributes and qualifier attributes * qualifier attributes consist of "key" and "value" in spring-beans-2.5.xsd (formerly "name" and "value") * AbstractBeanDefinition's qualifier handling provides a unified "addQualifier(AutowireCandidateQualifier)" method * AbstractSingleBeanDefinitionParser applies full scope to inner beans, making them eligible for destruction callbacks * added "getParentName" template method to AbstractSingleBeanDefinitionParser, allowing for child bean definitions * @Autowired qualifier annotations may be defined with target 'type' as well, marking the target bean class * Autowired/Common/PersistenceAnnotationBeanPostProcessor implement PriorityOrdered and expose an "order" bean property * "depends-on" kicks in before the affected bean is entering its creation phase; can be used to resolve circular refs * added "registers-scope" annotation to spring-tool.xsd, allowing a tool to determine valid scope names Package org.springframework.context * AbstractApplicationContext calls "cancelRefresh" method in case of refresh failure now, resetting the 'active' flag * AbstractRefreshableApplicationContext calls the full "destroyBeans()" method when refreshing the bean factory * ClassPathXmlApplicationContext and FileSystemXmlApplicationContext trim passed-in config location Strings * added "concurrentUpdates" flag to AbstractApplicationEventMulticaster, enabling copy-on-write for the listener set * AnnotationConfigUtils checks for EntityManagerFactory class instead of PersistenceContext (for Tomcat 6 compatibility) * moved CommonAnnotationBeanPostProcessor class from package "beans.factory.annotation" to "context.annotation" * CommonAnnotationBeanPostProcessor supports @Resource's "mappedName" attribute as (potentially global) JNDI location * added "alwaysUseJndiLookup" flag to CommonAnnotationBeanPostProcessor, enforcing Java EE 5 JNDI lookups * CommonAnnotationBeanPostProcessor detects and processes the JAX-WS @WebServiceRef annotation as well * CommonAnnotationBeanPostProcessor detects and processes the EJB 3 @EJB reference annotation (if present) as well * @PostConstruct/@PreDestroy methods are only called once even if they are specified as standard init/destroy methods * added "context:mbean-export" configuration element to "spring-context-2.5" schema, for annotation-driven JMX export Package org.springframework.core * NestedRuntimeException/NestedCheckedException's "contains" checks the nested causes of any kind of wrapped exception * added "ConcurrentMap createConcurrentMap" method to CollectionFactory, exposing a common ConcurrentMap interface * deprecated CollectionFactory's "createLinkedSet/LinkedMap/IdentityMapIfPossible" (for usage on JDK 1.4 or higher) * AttributeAccessorSupport uses a LinkedHashMap, keeping the attributes in the order of registration * "Conventions.getVariableName" follows JavaBeans property naming rules in case of multiple upper case letters * added "getURI()" method to Resource interface * added constructor with URI argument to UrlResource class * FileSystemResource's "getURL()" builds URLs that can be converted to an URI * introduced ContextResource interface with "getPathWithinContext()" method (exposed for context-relative lookups) * reworked "core.asm.ClassReaderFactory" into "core.classreading.MetadataReaderFactory" (with internal ASM usage only) * AspectJTypeFilter uses a given ClassLoader instead of the default ClassLoader Package org.springframework.ejb * spring-jee.xsd explicitly declares defaults for its boolean flags Package org.springframework.instrument * added WebLogicLoadTimeWeaver for BEA WebLogic version 10 or higher Package org.springframework.jdbc * SimpleJdbcTemplate's varargs handling always considers a single array argument as collection of arguments Package org.springframework.jms * JmsTemplate only starts lazily created transactional Connections if actually necessary (-> "startConnection" flag) * JmsTransactionManager does not start transactional Connections until a transactional Session actually requires it * added DestinationResolver support to StandardJmsActivationSpecFactory, for Destination objects on JCA ActivationSpecs * DefaultJmsActivationSpecFactory autodetects WebSphere's JMS ResourceAdapter and extended ActivationSpec properties * "spring-jms.xsd" supports "destination-resolver" attribute for "jca-listener-container" element as well * JmsNamespaceHandler registers class names only, allowing tools to run without the JMS API on the classpath Package org.springframework.jmx * MBeanExporter applies NotificationPublisherAware callbacks to objects registered via "registerManagedResource" as well * MBeanExporter's "exposeManagedResourceClassLoader" defaults to "true" now, for interaction with third-party MBeans * MBeanExporter uses AUTODETECT_ALL as default if no beans have been specified explicitly * MBeanExporter supports dynamic AOP proxies with the target class being a standard MBean/MXBean * introduced AnnotationMBeanExporter with conveniently pre-configured AnnotationJmxAttributeSource * ManagedResource annotation allows for specifying the "objectName" as annotation value as well * MetadataNamingStrategy falls back to bean key (bean name) if no "objectName" specified in source-level metadata * fixed IdentityNamingStrategy to obtain the package name through class name inspection rather than "Class.getPackage()" * MBeanClientInterceptor automatically converts MXBean CompositeData/TabularData structures according to Java 5/6 rules * MBeanClientInterceptor uses the standard JDK MBeanServerInvocationHandler if possible (for full MXBean support) * MBeanClientInterceptor propagates exceptions thrown by the target MBean directly (i.e. not wrapped in a JmxException) Package org.springframework.mail * added "getJavaMailProperties()" method to JavaMailSenderImpl, allowing for convenient configuration of specific keys Package org.springframework.mock * MockServletContext supports "getContext" (allowing to register contexts through the new "registerContext" method) * MockServletContext supports "getMimeType" if the Java Activation Framework is present on the classpath * added convenience constructors to MockPortletConfig, MockActionRequest and MockRenderRequest Package org.springframework.orm * LocalSessionFactoryBean always uses the bean ClassLoader for "mappingResources" as well as for SessionFactory building * HibernateInterceptor can be interleaved with JTA transactions and non-transactional access even with async tx timeouts * removed custom detach/attach/newNamedQuery hooks from JdoDialect, expecting providers to follow the final JDO 2.0 API * deprecated JdoTemplate's "attachCopy" methods in favor of revised "makePersistent" with a JDO2-style return value * LocalPersistenceManagerFactoryBean passes the application ClassLoader into "JDOHelper.getPersistenceManagerFactory" * added "persistenceManagerFactoryName" property to LocalPersistenceManagerFactoryBean, supporting JDO 2.1 PMF lookup * added "jdoPropertyMap" property to LocalPersistenceManagerFactoryBean, allowing for non-String JDO property values * JdoTransactionManager and JpaTransactionManager support REQUIRES_NEW transactions in afterCompletion callbacks * JPA support exposes the application ClassLoader as PersistenceUnitInfo ClassLoader even without a LoadTimeWeaver * JPA support uses InstrumentationLoadTimeWeaver as default weaver if InstrumentationSavingAgent is active * revised CommonsLoggingSessionLog to work with TopLink 11 as well (remaining compatible with TopLink 10.1.3) Package org.springframework.remoting * fixed Hessian/BurlapClientInterceptor's "convertHessian/BurlapAccessException" method to return the exception properly * JndiRmiClientInterceptor's "prepare()" doesn't declare NamingException anymore (just RemoteLookupFailureException) * JaxRpcPortClientInterceptor's "prepare()" doesn't declare ServiceException anymore (just RemoteLookupFailureException) * JaxRpcPortClientInterceptor extracts the original exception as far as provided by JAX-RPC in case of a SOAP fault * introduced JAX-WS 2.0/2.1 support in package "org.springframework.remoting.jaxws" * introduced RemoteInvocationFailureException, thrown by RMI/HTTP/JMS invoker proxies in case of server-side failure * introduced SoapFaultException, thrown by JAX-RPC/JAX-WS proxies in case of a SOAP fault being reported Package org.springframework.stereotype * added @Service and @Controller stereotypes to the existing Component and Repository annotations Package org.springframework.test * introduced TestNG support based on the new test context framework Package org.springframework.transaction * TransactionSystemException preserves the original application exception, if any, in case of commit/rollback failure * revised AbstractFallbackTransactionAttributeSource's template methods for specific attribute/annotation retrieval * AnnotationTransactionAttributeSource supports a customizable TransactionAnnotationParser strategy * AnnotationTransactionAttributeSource supports EJB3's TransactionAttribute annotation (if present) as well * TransactionAspectSupport ignores transaction attributes when not configured with a transaction manager * added "tx:jta-transaction-manager" configuration element to "spring-tx-2.5" schema Package org.springframework.ui * "ModelMap.addObject(Object)" follows JavaBeans property naming rules in case of multiple upper case letters Package org.springframework.util * "ClassUtils.getShortNameAsProperty" strips the outer class name in case of an inner class Package org.springframework.web * added "resolveLazily" flag to Commons(Portlet)MultipartResolver, allowing to switch to lazy multipart resolution * reworked MultipartException into a RuntimeException (it may be thrown from file/parameter access methods as well now) * changed UrlPathHelper's and AbstractUrlHandlerMapping's/AbstractUrlMethodNameResolver's "urlDecode" default to "true" * added "getAttributeNames" method to RequestAttributes interface * introduced WebBindingInitializer interface, supported by BaseCommandController and MultiActionController * introduced annotation-based controller approach using @Controller, @RequestMapping, @RequestParam and @ModelAttribute * introduced annotation-based command/form controller facilities using @InitBinder, @FormAttributes and FormStatus * introduced DefaultAnnotationHandlerMapping and AnnotationMethodHandlerAdapter for Servlet MVC and Portlet MVC * added "caseSensitive", "pathPrefix" and "basePackage" properties to ControllerClassNameHandlerMapping * added "getActualValue()" method to BindStatus, exposing the raw property value for comparison purposes * added "exposeModelAttributes" property to RedirectView, allowing to suppress model exposure completely * added "exposeContextBeansAsAttributes" property to InternalResourceView and InternalResourceViewResolver * JstlView sets "exposeContextBeansAsAttributes" to "true" by default, allowing JSTL expressions to access Spring beans * factored out a "loadReport()" method in AbstractJasperReportsView (called by "initApplicationContext()") * revised AbstractJasperReportsView to allow for obtaining a report dynamically (through overriding "getReport()") * TagWriter in JSP AbstractFormTag reobtains the Writer from the PageContext all the time (for FreeMarker compatibility) * introduced "modelAttribute" property for JSP FormTag, superseding the "commandName" property for general purposes * JSP SelectTag, OptionTag and OptionsTag properly detect a selected value even for Maps with converted keys * JSP CheckboxTag caches converted candidate value when comparing it with collection elements * introduced JSP CheckboxesTag (form:checkboxes) and RadioButtonsTag (form:radiobuttons) * JSF 1.1 DelegatingVariableResolver checks Spring bean match first (analogous to JSF 1.2 DelegatingFacesELResolver) Changes in version 2.1 M4 (2007-09-09) -------------------------------------- General * updated build to use JUnit 4.4 for the tiger test suite while sticking with JUnit 3.8 for the main test suite * moved GlassFish and OC4J instrumentation support from spring-context-support.jar to spring-context.jar * renamed spring-mock.jar to spring-test.jar, reflecting the focus on the test context framework * factored out Struts 1.x support (including Tiles 1.x support) into spring-webmvc-struts.jar * Spring-style pattern matching ("*xxx", "xxx*", "*xxx*") supports multi-part patterns as well now ("xxx*yyy") Package org.springframework.aop * ProxyFactoryBean and AbstractSingletonProxyFactoryBean are serializable if their target and interceptors are * made parts of ReflectiveMethodInvocation and other internal impl classes public again (for framework integration) * "AopNamespaceUtils.registerAutoProxyCreatorIfNecessary" registers a plain InfrastructureAdvisorAutoProxyCreator now * "target()" pointcut handles types implemented in superclasses correctly * "aop:scoped-proxy" applies a specified "autowire-candidate" flag to the proxy Package org.springframework.beans * TypeConverterDelegate protects its value conversion step against PropertyEditors which don't support "setValue" calls * TypeConverterDelegate falls back to "toString()" conversion for a primitive value type if the required type is String * changed visibility of PropertyEditorRegistrySupport's "getDefaultEditor(requiredType)" method to public * PropertyEditorRegistrySupport's "copyCustomEditorsTo" copies all editors if 'nestedProperty' argument is null * exposed "String[] getDependentBeans(beanName)" method on ConfigurableBeanFactory interface * introduced "String[] getDependenciesForBean(beanName)" method on ConfigurableBeanFactory interface * DefaultSingletonBeanRegistry uses a concurrent Map for managing dependent beans, avoiding unnecessary synchronization * removed superseded ResourceFactoryBean (String-to-Resource conversion has been implicitly available for years) * added overloaded "createBean(beanClass)" method to AutowireCapableBeanFactory interface * introduced "registerResolvableDependency" method on ConfigurableListableBeanFactory interface * introduced qualifier support, allowing to use custom parameter annotations for identifying specific target beans * introduced AutowireCandidateResolver mechanism and QualifierAnnotationAutowireCandidateResolver implementation * reworked Annotated/ScannedRootBeanDefinition into Annotated/ScannedGenericBeanDefinition * fixed AbstractBeanFactory's type check to ignore a null value (as potentially exposed by a FactoryBean) * fixed AbstractBeanFactory to never cache FactoryBean-exposed objects for inner beans (avoiding name conflicts) * optimized DefaultListableBeanFactory's shortcut access to cached merged bean definitions * optimized DefaultListableBeanFactory's resolution of bean references during prototype creation * DefaultListableBeanFactory performs SmartFactoryBean eager-init check even if the FactoryBean singleton already exists * CommonAnnotationBeanPostProcessor falls back to default type match if no bean found for @Resource field/property name * Common/Autowired/PersistenceAnnotationBeanPostProcessor reject injection annotations on static fields/methods * factored out "isCandidateComponent(beanDefinition)" template method in ClassPathScanningCandidateComponentProvider * ClassPathBeanDefinitionScanner does not apply scoped-proxy setting to prototypes (only to extended scopes) * scoped inner beans are now eligible for scoped destruction callbacks, despite not living as scoped attributes * "spring-beans-2.1.xsd" supports "default-autowire-candidates" attribute, accepting Spring-style bean name patterns Package org.springframework.context * AbstractApplicationContext registers BeanFactory, ApplicationContext etc as resolvable dependency types for @Autowired * fixed AbstractApplicationContext's temporary ClassLoader to work for by-type autowiring in ApplicationListeners etc * AbstractApplicationContext propagates "start()"/"stop()" call to LifecycleBeans according to inter-bean dependencies * AbstractApplicationContext sends ContextStartedEvent/ContextStoppedEvent when propagating "start()"/"stop()" call Package org.springframework.core * factored out protected "openStreamForClass" template method in OverridingClassLoader * PathMatchingResourcePatternResolver's static "logger" variable is private now * PathMatchingResourcePatternResolver detects Oracle OC4J's "code-source" URLs as jar files now Package org.springframework.jdbc * strengthened SQLExceptionTranslator's contract to define root cause handling for returned DataAccessExceptions * added batch update support to SimpleJdbcTemplate * added new SimpleJdbcInsert and SimpleJdbcCall classes to provide ease-of-use for inserts and stored procedure calls Package org.springframework.jms * MessageListenerAdapter logs at warn level if a listener method returned a result but no response message can be sent * added BeanFactoryDestinationResolver, for use with "jms:listener-container"'s "destination-resolver" attribute * added "message-converter" attribute to "jms:listener-container/jca-listener-container" XML configuration element * added "response-destination" attribute to "jms:listener" element, defining a default in case of no JMSReplyTo header Package org.springframework.orm * HibernateJdbcException extracts the SQL statement and explicitly builds it into the exception message * introduced EntityManagerProxy interface, allowing access to underlying EntityManager for shared/extended EM proxies * container-managed extended EntityManager gets explicitly closed on destruction of the containing bean * PersistenceUnitReader checks for well-known explicit schema resource locations instead of searching the classpath * revised JpaTransactionManager to convert JPA RollbackExceptions into Spring TransactionSystemExceptions * JpaTransactionManager provides fine-grained commit exceptions through translating JPA RollbackException root causes * HibernateJpaDialect translates native HibernateExceptions (introspecting them as root causes of PersistenceExceptions) * added savepoint support to JpaDialect, implemented by OpenJpaDialect, supported by JpaTransactionManager * OpenJpaDialect exposes a special JDBC ConnectionHandle that immediately returns the Connection to the EntityManager * OpenJpaVendorAdapter supports OpenJPA 1.0.0 (exposing the full OpenJPAEntityManagerSPI interface) Package org.springframework.remoting * LocalJaxRpcServiceFactory trims whitespace from "namespaceUri" values Package org.springframework.scripting * ScriptCompilationException carries the ScriptSource of the offending script * GroovyScriptFactory passes script source description to GroovyClassLoader.parseClass (for descriptive error messages) * added "autowire" and "dependency-check" attributes to "lang:bsh/jruby/groovy" XML configuration elements Package org.springframework.test * fixed AbstractSpringContextTests's "hasCachedContext" implementation to use the context key String translation * reduced AbstractTransactionalSpringContextTests's log level for transaction management from INFO to DEBUG * introduced annotation-oriented test context framework based on test execution listeners * introduced JUnit4 support (SpringJUnit4ClassRunner) based on the new test context framework Package org.springframework.transaction * fixed "tx:annotation-driven" to not activate "aop:config"-style autodetection of application-defined Advisor beans Package org.springframework.ui * ModelMap extends LinkedHashMap, exposing model elements in registration order Package org.springframework.util * "ClassUtils.forName" supports the JDK's internal names for primitive array classes as well (for JMX compatibility) * ReflectionUtils provides a "findMethod" variant without parameter types argument Package org.springframework.web * RequestContext uses a full ResourceBundleThemeSource as default again (for backwards compatibility) * RequestContext lazily obtains the Theme instance (for more efficiency when theme support is not used) * AbstractView does not log static attributes anymore, in order to allow for scoped proxies to be used as attributes * factored out protected "isEligibleProperty(key, value)" template method in RedirectView * RedirectView only exposes Strings, primitives and primitive wrappers as query properties by default * JstlView properly allows for programmatic usage (added overloaded constructors; exposing a MessageSource is optional) * InternalResourceViewResolver uses JstlView as default (instead of InternalResourceView) if the JSTL API is present * JSP MessageTag resolves arguments in default text even if no message code was specified * JSP tags in the form tag library default to htmlEscape=true in case of no defaultHtmlEscape setting given * added support for Tiles2 in the "org.springframework.web.servlet.view.tiles2" package (requiring Tiles 2.0.4+) * JasperReports View classes support JasperReports 2.0 while remaining compatible with JasperReports 1.3 Changes in version 2.1 M3 (2007-07-31) -------------------------------------- General * fixed and updated reference documentation on JMS listener container configuration and transaction participation Package org.springframework.aop * Cglib2AopProxy uses weak references for advised object, interceptors and validated classes (avoiding a memory leak) * ProxyFactoryBean avoids NPE in case of target class being null (due to misconfiguration) * fixed AspectJ pointcut handling to resolve bridge methods before matching * fixed AspectJ pointcut handling to correctly match generic return types * added support for "bean(name)" element in AspectJ pointcut expressions * ReflectiveMethodInvocation, BeanFactoryAdvisorRetrieval and other internal impl classes are just package-visible now * the pointcut element's "id" attribute is required as of the 2.1 version of the AOP namespace (spring-aop-2.1.xsd) * aop:aspectj-autoproxy's "proxy-target-class" attribute properly escalates class proxying (not overriding the setting) * ConfigBeanDefinitionParser turns "pointcut" attribute into inner bean definition (instead of ref to an anonymous bean) * fixed ConfigBeanDefinitionParser to properly handle empty pointcut/advice bean names in a tooling environment * added "getAspectClassLoader()" method to AspectInstanceFactory interface * revised reflective class loading to use the correct ClassLoader according to the OSGi bundle structure (if any) * declare-parents allows specifying "delegate-ref" to delegate introductions to a bean as alternative to "default-impl" Package org.springframework.beans * added "charsToDelete" and "emptyArrayAsNull" options to StringArrayPropertyEditor * URIEditor trims whitespace before parsing the URI (allowing for XML formatting with whitespace) * BeanWrapperImpl lazily performs JavaBeans introspection (avoiding introspection failure for non-visible target class) * TypeConverterDelegate protects its collection conversion process against misbehaving Collections with a null Iterator * TypeConverterDelegate only attempts to convert well-known collection types (skips custom types in the first place) * PropertyBatchUpdateException synchronizes on PrintStream/PrintWriter (like the JDK 1.6 Throwable class does) * BeanFactoryUtils uses linked HashMaps for "beansOfTypeIncludingAncestors", preserving "getBeansOfType" order * added "isEagerInit()" method to SmartFactoryBean interface, making post-processors apply to an exposed object eagerly * exposed "getBean(name, args)" method on BeanFactory interface * exposed "BeanDefinition getMergedBeanDefinition(beanName)" method on ConfigurableBeanFactory interface * exposed "isFactoryBean" and "registerDependentBean" methods on ConfigurableBeanFactory interface * introduced "isAutowireCandidate" method on ConfigurableListableBeanFactory interface * passing in explicit arguments for bean creation is supported for constructors as well (not just for factory methods) * passing in different combinations of explicit arguments is supported for overloaded factory methods and constructors * PropertyPathFactoryBean supports a null property value (removed historic restriction there) * exposed "parentName", "factoryBeanName" and "factoryMethodName" properties in BeanDefinition interface * added "visitParentName", "visitFactoryBeanName" and "visitFactoryMethodName" callbacks to BeanDefinitionVisitor * PropertyPlaceholderConfigurer resolves placeholders in parent, factory-bean and factory-method values as well * fixed AbstractBeanFactory to correctly handle factory-bean references in case of a temporary ClassLoader being used * DefaultListableBeanFactory ignores invalid parent bean names when matching beans by type with allowEagerInit=false * DefaultListableBeanFactory only ignores invalid bean class names when matching beans by type with allowEagerInit=false * DefaultListableBeanFactory does not invoke custom init/destroy method twice if pointing to Initializing/DisposableBean * DefaultListableBeanFactory allows for concurrent "registerBeanDefinition" calls after the configuration phase * bean creation records suppressed exceptions, exposing them as related causes in a subsequent BeanCreationException * added "setTypeConverter" method to ConfigurableBeanFactory, allowing to override the default PropertyEditor mechanism * introduced "removeBeanDefinition" method in BeanDefinitionRegistry interface and DefaultListableBeanFactory class * exposed "isBeanNameInUse" method on BeanDefinitionRegistry interface * AbstractBeanFactory supports any BeanDefinition implementation (does not require AbstractBeanDefinition anymore) * reworked AbstractBeanFactory's bean definition merging for less coupling to RootBeanDefinition as merge result * introduced GenericBeanDefinition as one-stop shop for standard bean definition purposes (with configurable parent) * DefaultBeanNameGenerator does not require an AbstractBeanDefinition implementation for bean name generation anymore * DefaultBeanNameGenerator generates a "#0" suffix in the canonical name even for the first occurence of an unnamed bean * added "resolveDependency" methods to AutowireCapableBeanFactory interface * @Autowired annotation ignores target beans marked as autowire-candidate="false" (analogous to standard autowiring) * added autowiring by type for arrays, collections, maps (available for @Autowired, 'constructor', 'byType' autowiring) * Autowired/CommonAnnotationBeanPostProcessor registers autowired beans as dependent on their injected target bean * AnnotationBeanConfigurerAspect proceeds without injection in case of a circular reference problem, logging a warning * added "registerBeanComponent" convenience method to ParserContext * changed visibility of BeanDefinitionParserDelegate's "buildTypedStringValue(ForMap)" methods to protected Package org.springframework.context * AspectJWeavingEnabler implements Ordered, exposing HIGHEST_PRECEDENCE (executing before other factory post-processors) * moved AnnotationConfigUtils to "context.annotation" package (post-processor beans are a context-specific feature) * "context:annotation-config" XML tag activates JPA's @PersistenceContext and @PersistenceUnit as well (if available) * AnnotationConfig/ComponentScanBeanDefinitionParser sends component registration for each registered BeanPostProcessor * AnnotationBeanNameGenerator does not silently adapt the default bean name in case of overlap anymore * "context:spring-configured" registers its bean configurer aspect with a fixed internal bean name * revised reflective class loading to use the correct ClassLoader according to the OSGi bundle structure (if any) Package org.springframework.cache * added "maxElementsOnDisk" bean property to EhCacheFactoryBean, supporting EHCache 1.2.4's extended Cache constructor Package org.springframework.core * added "isAtLeastJava16()" convenience method to JdkVersion class * OverridingClassLoader (and hence SimpleThrowawayClassLoader) exclude classes from the "sun." package * fixed PathMatchingResourcePatternResolver to build correct JarFile URLs on WebLogic and WebSphere * PathMatchingResourcePatternResolver uses a static Log instance in order to avoid repeated synchronization overhead Package org.springframework.ejb * turned visibility of AbstractEnterpriseBean and AbstractSessionBean to public (showing up in the javadoc now) Package org.springframework.instrument * added "excludePackage" and "excludeClass" methods to ShadowingClassLoader, analogous to OverridingClassLoader Package org.springframework.jdbc * added exception translation based on SQLException subclasses introduced in Java 6 * added additional exceptions to divide hierarchy into Recoverable, Transient and NonTransient exceptions * added support for arrays of values in parameter value lists: "select * from t where (a, b) in ((1,'x'), (3,'y'))" * added DerbyMaxValueIncrementer to provide an alternative for autoGeneratedKeys used with IDENTITY columns * added HsqlSequenceMaxValueIncrementer to support sequences now added to HSQL * added H2SequenceMaxValueIncrementer to support sequences in H2 Database Package org.springframework.jms * SingleConnectionFactory sets client ID before ExceptionListener (for providers with strict Connection state handling) * added "receiveTimeout" property to JmsInvokerClientInterceptor/ProxyFactoryBean (with reimplemented request execution) * listener-container type "default102"/"simple102" leads to the implicit choice of MessageListenerAdapter102 Package org.springframework.jmx * MBeanExporter unregisters its MBeans in case of any kind of registration failure * MBeanExporter accepts bean name keys in NotificationListener mappings (in addition to ObjectName Strings) * revised reflective class loading to use the correct ClassLoader according to the OSGi bundle structure (if any) Package org.springframework.orm * HibernateTemplate delegates to "SessionFactory.getCurrentSession()" when "allowCreate" has been set to "false" * added overloaded "findByExample" methods with entityName argument to HibernateOperations/HibernateTemplate * deprecated HibernateTemplate's "saveOrUpdateAll" method in favor of individual "saveOrUpdate"/"merge" usage * fixed Hibernate/JpaTransactionManager to clean up properly in case of transaction begin failure on pre-bound resource * added "prepareTransaction" method to JpaDialect interface, for preparing a JTA-joining EntityManager * HibernateJpaDialect switches FlushMode to MANUAL in case of a read-only transaction even for JTA * PersistenceAnnotationBeanPostProcessor registers autowired beans as dependent on their EntityManagerFactory * ExtendedEntityManagerCreator's "joinTransaction()" checks whether there is an externally managed local transaction * ExtendedEntityManagerCreator's EntityManager proxies are serializable now Package org.springframework.mock * MockHttpServletResponse automatically flushes the Writer in case of a "write(int)" call too Package org.springframework.remoting * RmiClientInterceptor and JaxRpcClientInterceptor propagate any kind of declared RemoteException as-is * (Jndi)RmiClientInterceptor resets stub before a refresh attempt, avoiding race condition in case of registry restart * JndiRmiClientInterceptor wraps CORBA SystemExceptions in RemoteExceptions (if declared) Package org.springframework.scheduling * added "waitForTasksToCompleteOnShutdown" property to ScheduledExecutorFactoryBean * changed ScheduledExecutorFactoryBean's default behavior to shutdown immediately, not waiting for scheduled tasks Package org.springframework.scripting * updated JRuby support for JRuby 1.0 compatibility (still compatible with JRuby 0.9.8 / 0.9.9 as well) Package org.springframework.test * AbstractDependencyInjectionSpringContextTests allows for annotation-driven autowiring (even in case of AUTOWIRE_NO) Package org.springframework.scheduling * Quartz SchedulerFactoryBean does not set default AdaptableJobFactory in case of RemoteScheduler (not supported there) Package org.springframework.scripting * "lang:*" configuration elements create their implicit ScriptFactoryPostProcessor under a fully qualified bean name Package org.springframework.transaction * refined TransactionAspectSupport to allow for overriding the "getTransactionManager()" method in subclasses * TransactionInterceptor only uses ThrowableHolderException if necessary and makes sure to expose the cause in any case * "tx:annotation-driven" registers its transaction aspect with a fixed internal bean name Package org.springframework.util * fixed "StringUtils.parseLocaleString" to parse multiple variants correctly * DefaultPropertiesPersister detects and uses JDK 1.6's "Properties.load/store" variants with Reader/Writer argument Package org.springframework.validation * added overloaded "rejectIfEmpty(OrWhitespace)" methods with args but without default message to ValidationUtils Package org.springframework.web * factored out "invokeDelegate" template method in DelegatingFilterProxy * fixed Servlet/PortletContextResourcePatternResolver to correctly match bounded patterns * fixed FrameworkServlet to always refresh its BeanNameUrlHandlerMapping with the correct context * added "postProcessWeb/PortletApplicationContext" method to FrameworkServlet/Portlet * DispatcherServlet/Portlet's "noHandlerFound" declares Exception instead of just IOException/PortletException * added "addInterceptor" and "addInterceptors" methods to Servlet/Portlet HandlerExecutionChain * AbstractUrlHandlerMapping exposes "path within mapping" attribute through an interceptor (for proper include cleanup) * AbstractWizardFormController's "showForm" method is not final anymore (can be overridden e.g. for exception handling) * added "transformerFactoryClass" property and "newTransformerFactory()" template method to (Abstract)XsltView * added "accept-charset" support to JSP FormTag * fixed JSP CheckboxTag to apply the custom PropertyEditor (if any) to rendered values Changes in version 2.1 M2 (2007-05-31) -------------------------------------- General * removed support for Hibernate 2.1; Spring's Hibernate support generally requires Hibernate 3.1 or higher now * spring-context.jar includes JMX support and core remoting support (no spring-jmx and spring-remoting jars anymore) * spring-orm.jar combines all ORM support packages (replaces spring-jdo, spring-jpa, spring-hibernate etc jars) * spring-web.jar contains web-related remoting and ORM classes (for proper use in J2EE EAR deployment structures) * renamed spring-dao.jar to spring-tx.jar, also containing the JCA support now * renamed spring-support.jar to spring-context-support.jar * renamed spring-portlet.jar to spring-webmvc-portlet.jar * module jar files contain module-specific "spring.handlers" and "spring.schemas" files now * added missing websphere_uow_api.jar to -with-dependencies distribution Package org.springframework.aop * ReflectiveMethodInvocation always uses a shared user attribute Map in clones (for proper binding of multiple advices) * fixed MethodInvocationProceedingJoinPoint to properly pass modified arguments (via proceed) to subsequent aspects * fixed AbstractAspectJAdvisorFactory to ignore 'code-style' aspect classes that have been compiled by ajc * "aop:aspectj-autoproxy" XML configuration tag detects all aspect beans in case of empty XML body content as well * moved "aop:spring-configured" to context namespace ("context:spring-configured") in the 2.1 versions of the XSDs Package org.springframework.beans * CustomBooleanEditor trims text before comparing against true/false Strings * added temporary ClassLoader support to ConfigurableBeanFactory / AbstractBeanFactory * mirrored FactoryBean's "getObjectType()" as abstract method in AbstractFactoryBean again, for @Override compatibility * reworked SmartInstantiationAwareBeanPostProcessor's "determineConstructor" hook into "determineCandidateConstructors" * added "resolveAliases" method to ConfigurableBeanFactory, applying a given StringValueResolver * PropertyPlaceholderConfigurer applies its placeholder parsing to alias target names and aliases as well * PropertyResourceConfigurer (and in particular PropertyPlaceholderConfigurer) is marked as PriorityOrdered * BeanWiringInfo and ClassName/AnnotationBeanWiringInfoResolver support the notion of a 'default' bean name * @Configurable applies factory callbacks (BeanFactoryAware, InitializingBean etc) and post-processors as well * @Configurable applies factory callbacks and post-processors if no bean definition found for default bean name * DefaultListableBeanFactory clears a cached merged bean definition in case of re-registering a bean definition * AbstractBeanDefinition declares a public "clone()" method as well as "AbstractBeanDefinition cloneBeanDefinition()" * AbstractBeanDefinition excludes purely descriptive metadata from its equals check (for more lenient equality) * fixed BeanDefinitionParserDelegate to avoid NPE in case of a custom namespace without a NamespaceHandler registered * fixed BeanDefinitionParserDelegate to extract correct source element for "key-ref"/"value-ref" attributes * added 'required' attribute to @Autowired annotation (configurable for a custom autowire annotation as well) * avoid double invocation of @Autowired/@Resource setter method in case of explicitly specified property value * InitDestroy/Common/AutowiredAnnotationBeanPostProcessor use ConcurrentHashMaps for minimal locking * introduced AnnotatedBeanDefinition interface and AnnotatedRootBeanDefinition implementation class * added support for the JDK 1.6 ServiceLoader facility (package "beans.factory.serviceloader") Package org.springframework.cache * EhCacheFactoryBean applies a specified CacheEntryFactory to an existing cache region as well Package org.springframework.context * AbstractApplicationContext instantiates and applies priority-ordered Bean(Factory)PostProcessors first * AbstractApplicationContext creates all non-ordered BeanPostProcessors first before registering them with the factory * AbstractApplicationContext sets a temporary ClassLoader for type matching if a bean named "loadTimeWeaver" is defined * added LoadTimeWeaverFactoryBean, building a default LoadTimeWeaver (autodetecting the runtime environment) * added LoadTimeWeaverAware interface, automatically supported if a default LoadTimeWeaver is available * added AspectJWeavingEnabler, registering AspectJ's class transformer for standard AspectJ load-time weaving * added "context:load-time-weaver" XML tag, building a default LoadTimeWeaver and enabling AspectJ load-time weaving * introduced ScannedRootBeanDefinition class for autodetected components * added @Scope annotation for autodetected components, indicating the target bean scope in the Spring context * reworked ClassPathBeanDefinitionScanner into subclass of ClasspathScanningCandidateComponentProvider * ClassPathBeanDefinitionScanner provides "addIncludeFilter" etc config methods instead of overloaded "scan" methods * reworked ComponentBeanNameGenerator into AnnotationBeanNameGenerator, handling @Repository name values as well * explicit bean names indicated by autodetected components are enforced, only to be overridden by explicit definitions Package org.springframework.core * updated NestedXxxException to build on JDK 1.4 exception chaining, adding extended messages and convenience accessors * introduced PriorityOrdered marker interface, with order values automatically applied before any plain Ordered values * fixed BridgeMethodResolver to properly detect a method that substitutes a type parameter with an array type * fixed BridgeMethodResolver to detect type variables in interface hierarchies with different type variable names * added "getClassLoader()" method to ClassPathResource, exposing the ClassLoader used for resource loading * PathMatchingResourcePatternResolver avoids full subtree scan through skipping non-matching directory paths early * PathMatchingResourcePatternResolver explicitly closes freshly created JarFile handles, to allow for hot redeployment * introduced ClassMetadata/AnnotationMetadata abstraction in "core.type" package * refactored "core.typefilter" package into "core.type.asm" and "core.type.filter" * introduced ClassReaderFactory abstraction, with SimpleClassReaderFactory and CachingClassReaderFactory implementations * introduced ClassReaderFactory as TypeFilter match argument, for resolving cached ClassReaders for the type hierarchy * moved FilterType enum to "context.annotation" package, since it is closely related to component scanning * introduced AnnotatedBeanDefinition interface and AnnotatedRootBeanDefinition implementation class * introduced ScannedRootBeanDefinition class for autodetected components * StringCodedLabeledEnum accepts empty codes (that purely consist of whitespace) as well Package org.springframework.jdbc * added named parameter support to SimpleJdbcTemplate * added ParameterizedBeanPropertyRowMapper, providing automatic mapping between columns and bean properties * added new SqlReturnUpdateCount parameter to provide name for update counts from stored procedures * added stored procedure support for retrieving update counts and storing the retrieved int in the output map * added automatic processing of stored proc returned resultsets (will create default one if declared parameter missing) * added automatic processing of stored proc update counts (will create default one if declared parameter missing) Package org.springframework.jmx * MBeanExporter does not insist of a minimum of 1 bean exposed anymore, also accepting no beans to export in the context Package org.springframework.mail * JavaMailSenderImpl sets the original message id (if specified in the given MimeMessage) after "message.saveChanges()" Package org.springframework.mock * added MockJspWriter and MockBodyContent classes for testing content-emitting JSP tags * MockPageContext supports the "getOut()" method, exposing a MockJspWriter Package org.springframework.orm * LocalContainerEntityManagerFactoryBean and DefaultPersistenceUnitManager autodetect a context's default LoadTimeWeaver * avoid double invocation of @PersistenceContext/Unit setter method in case of explicitly specified property value Package org.springframework.transaction * marked DelegatingTransactionAttribute as Serializable * added mode="proxy"/"aspectj" flag to "tx:annotation-driven" config tag, for choosing the AspectJ transaction aspect * WebSphereUowTransactionManager does not enforce the presence of a JTA UserTransaction anymore * WebSphereTransactionManagerFactoryBean uses the context class loader for compatibility with the WSAD 5.1 test server Package org.springframework.util * added "makeAccessible(Method)" and "makeAccessible(Constructor)" convenience methods to ReflectionUtils * added "matchStart" method to PathMatcher interface and AntPathMatch implementation, for checking the start of a match Package org.springframework.web * added "getDescription" method to WebRequest interface * ServletWebRequest and PortletWebRequest expose a descriptive "toString()" result (including URI, session id, user id) * added "includeClientInfo" flag to AbstractRequestLoggingFilter, for including client address and session id in the log * added Log4jNestedDiagnosticContextInterceptor for use with Servlet and Portlet MVC * CookieLocaleResolver checks specified "defaultLocale" in case of a setLocale call with null argument * RequestContext uses a shared default Theme instance as fallback, avoiding the recreating of empty Theme instances * MultiActionController explicitly disallows direct invocation of exception handler methods (as handler methods) * CancellableFormController suppresses validation for a cancel request * AbstractView and AbstractTemplateView pass an explicit ServletContext reference to a created RequestContext instance * changed AbstractTemplateView(Resolver)'s "exposeSpringMacroHelpers" default to "true" * JSP FormTag exposes full nested path for compatibility with Spring's standard BindTag * JSP TransformTag is able to work within JSP SelectTag etc as well, not just within BindTag Changes in version 2.1 M1 (2007-05-13) -------------------------------------- General * Spring is built on JDK 1.6 now, with support for common Java 6 APIs / Java EE 5 APIs * Spring requires JDK 1.4 or higher now, not supporting JDK 1.3 anymore (JDK 1.3 has reached its official end-of-life) * Spring's Hibernate3 support generally requires Hibernate 3.1 or higher (note: there's separate Hibernate 2.1 support) * fixed contents of spring-remoting.jar: does not include RemoteInvocationUtilsTests anymore Package org.springframework.aop * removed Perl5RegexpMethodPoint and RegexpMethodPointcutAdvisor's "perl5" flag (always using java.util.regex now) Package org.springframework.beans * introduced InitDestroyAnnotationBeanPostProcessor, processing configurable init and destroy annotations * introduced CommonAnnotationBeanPostProcessor, processing JSR-250's @PostConstruct, @PreDestroy and @Resource * introduced @Autowired annotation, indicating that a field, config method or constructor is supposed to be autowired * introduced AutowiredAnnotationBeanPostProcessor, processing the new @Autowired annotation * fixed AbstractAutowireCapableBeanFactory to allow for changing the InstantiantionStrategy (again) * deprecated BeanDefinitionReader's "BeanDefinitionRegistry getBeanFactory()" method in favor of "getRegistry()" * exposed "getBeanNameGenerator()" method in BeanDefinitionReader interface * changed XmlReaderContext's "getReader()" method to expose the plain BeanDefinitionReader interface * added "getResourceLoader()" convenience method to XmlReaderContext, exposing the context's ResourceLoader (if any) * added "getBeanClassLoader()" convenience method to XmlReaderContext Package org.springframework.context * introduced CandidateComponentProvider mechnism, for finding annotated component classes through scanning the classpath * introduced "context" XML schema namespace, providing a "property-placeholder" convenience tag * introduced convenient tags for annotation-based configuration as part of the "context" namespace * removed deprecated ConsoleListener class Package org.springframework.core * introduced the "core.typefilter" package, for ASM-based scanning of class files Package org.springframework.jca * introduced GenericMessageEndpointManager for JCA 1.5 message endpoint management, plus supporting infrastructure * introduced SpringContextResourceAdapter, for deploying a Spring application context as JCA 1.5 RAR file * added BootstrapContextAware interface, as a callback in a JCA 1.5 resource adapter environment Package org.springframework.jdbc * AbstractDataSource and DelegatingDataSource support the JDBC 4.0 Wrapper interface * added Jdbc4NativeJdbcExtractor, delegating to JDBC 4.0's "unwrap" method (defined by java.sql.Wrapper) * added "streamAsLob" flag to DefaultLobHandler, allowing for explicit usage of the JDBC 4.0 setBlob/setClob variants * fixed SQLErrorCodeSQLExceptionTranslator to avoid potential NPE in debug log message * added BeanPropertyRowMapper, providing automatic mapping between columns and bean properties * moved "isInputValueProvided" method from SqlOutParameter up to the SqlParameter root class * fixed RdbmsOperation's "validateParameters" to properly detect and count input-providing SqlOutParameters Package org.springframework.jms * added JmsMessageEndpointManager, extending GenericMessageEndpointManager with the JmsActivationSpecFactory mechanism * added StandardJmsActivationSpecFactory, supporting all standard JMS propertied as defined by the JCA 1.5 specification * added DefaultJmsActivationSpecFactory, autodetecting ActiveMQ and JORAM's ActivationSpecs and extended properties * introduced "jms" XML schema namespace, providing convenient tags for listener container configuration Package org.springframework.jmx * default MBean checks in JmxUtils and MBeanExporter automatically detect a Java 6 MXBean as well Package org.springframework.jndi * added SimpleJndiBeanFactory to "jndi.support" package, providing a JNDI-based BeanFactory implementation Package org.springframework.mail * removed CosMailSenderImpl (as part of generally removing COS support from the Spring codebase) Package org.springframework.mock * added support for Servlet 2.5's "getContextPath()" method to MockServletContext Package org.springframework.orm * Hibernate LocalSessionFactoryBean prefers a Hibernate 3.1 CurrentSessionContext now, instead of a SessionFactory proxy * Hibernate3 AbstractSessionFactoryBean's "exposeTransactionAwareSessionFactory" to refer to a SpringSessionContext now Package org.springframework.transaction * added TransactionFactory interface to "jta" subpackage, abstracting the creation of specific JTA Transaction objects * JtaTransactionManager and WebLogic/OC4JJtaTransactionManager implement the TransactionFactory interface accordingly * JtaTransactionManager autodetects and uses JTA 1.1's TransactionSynchronizationRegistry (e.g. on Java EE 5) * added WebSphereUowTransactionManager, supporting full transaction management via IBM's UOWManager API on WAS 6.0/6.1 * removed WAS 4.0/5.0 support from WebSphereTransactionManagerFactoryBean, keeping it for WAS 5.1 support only * removed outdated WebLogicServerTransactionManagerFactoryBean (for WebLogic 7.0) Package org.springframework.web * removed deprecated BindInitializer and BindUtils from the "bind" package * removed deprecated "setFilterConfig" method from GenericFilterBean (no WebLogic 6.1 compatibility necessary anymore) * removed CosMultipartResolver (as part of generally removing COS support from the Spring codebase) * introduced explicit JSF 1.2 support (web.jsf.el): DelegatingFacesELResolver and WebApplicationContextFacesELResolver * JSP InputTag, SelectTag etc support expressions as "disabled" and "readonly" attribute values Changes in version 2.0.5 (2007-05-07) ------------------------------------- Package org.springframework.aop * DelegatingIntroductionInterceptor only replaces a return value with the proxy if the proxy is actually assignable * JdkDynamic/Cglib2AopProxy only replaces return value with proxy if declaring class is not marked for raw target access * AbstractRefreshableTargetSource's "getTargetClass()" method is properly synchronized * ScopedObject's "getTargetObject()" method returns the actual target object now (instead of the proxy object) * fixed "aop:scoped-proxy" tag to properly apply to defined alias names as well Package org.springframework.beans * BeanWrapper doesn't iterate over Collection/Map if no generic type declared and no property-specific editor registered * BeanWrapper converts an empty String to null in case of a Java 5 enum as target type * default editor settings get copied to nested beans even if no default editors have been used yet * revised MethodInvokingFactoryBean's "getObjectType()" implementation to gracefully return null if not prepared already * added "determineConstructor(beanClass, beanName)" method to SmartInstantiationAwareBeanPostProcessor * AbstractBeanFactory's "containsBean"/"isSingleton"/"isTypeMatch"/etc behave correctly for "&" FactoryBean dereferences * AbstractBeanFactory uses concurrent Maps for singletons, aliases and bean definitions (for better concurrency) * DefaultListableBeanFactory finds initialized FactoryBeans / factory-bean references in case of allowEagerInit=false * fixed ConstructorResolver to correctly convert prepared collection arguments to arrays if necessary (for prototypes) * added overloaded "rootBeanDefinition" factory methods with bean class name (instead of Class) to BeanDefinitionBuilder * an (undefined) null value returned from a NamespaceHandler's "decorate" method is treated as 'no decoration required' * XmlBeanDefinitionReader caches the DefaultNamespaceHandlerResolver instance, sharing it across multiple files * added "getBeanClassName" template method to AbstractSingleBeanDefinitionParser, as alternative to "getBeanClass" * added "scope" attribute to "util:list", "util:set", "util:map" and "util:properties", allowing for scoped collections Package org.springframework.context * factored out fine-grained protected template methods from AbstractApplicationContext's "refresh()" implementation * AbstractRefreshableApplicationContext actually calls the 2.0.3-introduced "customizeBeanFactory" template method Package org.springframework.core * BridgeMethodResolver is able to match open type variables in complex overloading scenarios as well * BridgeMethodResolver caches based on TypeVariable references, handling overlapping type variable names appropriately * added "createConcurrentMap" method to CollectionFactory, creating a JDK 1.5+ or backport-concurrent ConcurrentHashMap * Constants class always uses upper-case transformation according to English notation * added "toCodeForSuffix" operation to Constants class Package org.springframework.instrument * ShadowingClassLoader explicitly defines a package for all classes that it loads, for "Class.getPackage()" to work Package org.springframework.jdbc * fixed GeneratedKeyHolder to avoid NPE in exception message in case of a null key returned by the JDBC driver * fixed JdbcTemplate's fallback support for batch updates to properly handle InterruptibleBatchPreparedStatementSetters * added scale support to SqlParameter, for declaring numeric RdbmsOperation parameters with a specific scale * added SqlParameterValue class, holding a value including SQL type and scale, accepted by JdbcTemplate argument arrays * optimized SQL parsing in NamedParameterUtils, NamedParameterJdbcTemplate and SqlOperation through the use of caching * added "execute" operation with PreparedStatementCallback argument to NamedParameterJdbcOperations/Template * added overloaded "query" operations with ResultSetExtractor argument to NamedParameterJdbcOperations/Template * SqlQuery and SqlUpdate accept named parameter declarations in arbitrary order (not requiring positional declaration) * SqlQuery and SqlUpdate accept unparameter declarations for named parameter usage (assuming positional declaration) Package org.springframework.jms * JndiDestinationResolver prefers a concurrent Map for caching purposes (for better concurrency) * changed visibility of various AbstractMessageListenerContainer property accessors from protected to public * JmsInvokerClientInterceptor/ProxyFactoryBean and JmsInvokerServiceExporter support a configurable MessageConverter Package org.springframework.jndi * TypeMismatchNamingException carries required type and actual type as explicit attributes Package org.springframework.orm * ExtendedEntityManagerCreator efficiently detects JTA through PersistenceUnitInfo's "transactionType" (if possible) * PersistenceAnnotationBeanPostProcessor is able to resolve a lazy EntityManagerFactory via its unit name as well * factored out "findEntityManagerFactory(ListableBeanFactory, unitName)" method into EntityManagerFactoryUtils Package org.springframework.remoting * RemoteExporter shows "use reference, not value" error message in case of the specified service object being a String * added "replaceExistingBinding" property to RmiServiceExporter, allowing to turn off the automatic replacement strategy * JndiRmiClientInterceptor/ProxyFactoryBean detects CORBA SystemExceptions and converts them to RemoteAccessExceptions * JndiRmiClientInterceptor/ProxyFactoryBean detects CORBA OBJECT_NOT_FOUND connect failures and recovers accordingly Package org.springframework.scheduling * MethodInvokingJobDetailFactoryBean avoids obtaining the target bean twice in case of "targetBeanName" specified * revised MethodInvokingJobDetailFactoryBean's error message to include the target class instead of the target object * DelegatingTimerTask catches any exception or error thrown from its delegate Runnable, to make the Timer proceed * added "continueScheduledExecutionAfterException" flag to ScheduledExecutorFactoryBean, overriding the default behavior Package org.springframework.scripting * added "init-method" and "destroy-method" attributes on "lang:groovy/bsh/jruby", for init/destroy methods in scripts * ScriptFactoryPostProcessor generates config interface methods for init/destroy methods as well, if demanded Package org.springframework.test * AbstractTransactionalSpringContextTests' "onSetUp()"/"onTearDown()" are non-final, allowing for flexible overriding Package org.springframework.transaction * AbstractPlatformTransactionManager properly resumes 'foreign' existing synchronization even in case of begin failure * revised OC4JJtaTransactionManager to support the "oracle.j2ee.transaction" package on OC4J later than 10.1.3.2 Package org.springframework.ui * ResourceBundleThemeSource will always return the same Theme instance for a given theme name Package org.springframework.util * PathMatcher's javadoc defines the semantics of the "extractPathWithinPattern" method in more detail * AntPathMatcher's "extractPathWithinPattern" preserved a path's leading separator in case of a "*.html" pattern match Package org.springframework.web * ContextLoader loads parent context based on "parentContextKey" parameter, not requiring "locatorFactorySelector" param * DispatcherServlet/Portlet only refresh their strategies if their own ApplicationContext refreshes * made AbstractHandlerMapping's "setInterceptors" method non-final * added "extendInterceptors" template method to AbstractHandlerMapping, for registering additional interceptors * UrlFilenameViewController and InternalPathMethodNameResolver prefer a concurrent Map for caching purposes * added "mappedHandlerClasses" property to Servlet/Portlet SimpleMappingExceptionResolver, for mapping specific types * factored out protected "shouldApplyTo" and "doResolveException" template methods in SimpleMappingExceptionResolver * added "localesToInitialize" property to ResourceBundleViewResolver, for initializing common locales eagerly * XmlViewResolver (and similar strategies) work again in combination with the implicit default BeanNameUrlHandlerMapping * JSP FormTag escapes the entire query string, including the parameter separators * JSP SelectTag always renders a full closing tag (i.e. never renders a short-circuited opening tag with "/>" ending) * JSP SelectTag accepts null values for its attributes (doesn't strictly enforce non-null values anymore) * JSP OptionTag properly detects a Java 5 Enum as selected even in case of an overridden "toString()" implementation * FreeMarkerView exposes a ServletConfig object to FreeMarker, for use with ServletConfig-accessing JSP tags * fixed AbstractXsltView to correctly apply a specified custom "contentType", even in case of a stylesheet specified * revised XsltView for Servlet 2.3 compatibility, avoiding the "HttpServletResponse.setCharacterEncoding" method * revised XsltView to respect a specified "contentType" property, using it if no XSLT media type has been specified * fixed XsltViewResolver to properly apply the "cacheTemplates" flag to created XsltView instances * revised AbstractJasperReportsView to accept a model without explicit data source as well (for Hibernate/JPA queries) * PortletUtils' "getParametersStartingWith" method checks for an empty value array (WebSphere Portal 6.0 peculiarity) Changes in version 2.0.4 (2007-04-10) ------------------------------------- Package org.springframework.aop * AbstractAutoProxyCreator caches advice information per bean, for efficient prototype creation with auto-proxying * fixed AspectJAfterReturningAdvice to avoid NPE within returning type check in case of the return value being null * fixed AspectJAwareAdvisorAutoProxyCreator's "toString()" implementation to be compatible with JDK 1.3/1.4 * AnnotationAwareAspectJAutoProxyCreator caches Advisors for singleton @Aspect aspects, increasing performance * introduced Simple(MetadataAware)AspectInstanceFactory, creating an independent aspect instance on every invocation * revised AspectJProxyFactory to avoid "spring-beans" dependencies, using SimpleMetadataAwareAspectInstanceFactory now * AbstractAspectJAdvice lazily calculates argument bindings, avoiding a "spring-beans" dependency (InitializingBean) * "this" pointcut in AspectJ pointcut expressions is matched against the proxy object rather than the target object Package org.springframework.beans * PropertyEditorRegistrySupport/BeanWrapperImpl lazily registers default editors when needed (to avoid init overhead) * PropertyEditorRegistrySupport supports registration of shared editors, to allow for specific synchronization * BeanWrapperImpl mimimizes bean name parsing overhead and caches parsed property path tokens * PatternEditor allows for customization through specifying "java.util.regex.Pattern" flags * fixed PropertyPlaceholderConfigurer/BeanDefinitionVisitor to correctly handle TypedStringValue objects with null value * AbstractFactoryBean offers a protected "getBeanFactory()" method for accessing its BeanFactory reference * BeanReferenceFactoryBean returns null from "getObjectType()" if the BeanFactory has not been injected yet * AbstractAutowireCapableBeanFactory uses "filteredPropertyDescriptorsCache" for the PropertyDescriptor array per class * DefaultListableBeanFactory is able to invoke public init and destroy methods on package-protected classes * DefaultListableBeanFactory caches pre-converted property values as far as possible * DefaultListableBeanFactory allows placeholders in class names even for non-lazy-init beans * ConstructorResolver caches the resolved constructor or factory method, for faster re-creation of prototype instances * ConstructorResolver caches converted argument values, to avoid conversion overhead for re-created prototype instances * DefaultNamespaceHandlerResolver logs linkage error at warn level, in case of a handler class found but not loadable Package org.springframework.context * added "addApplicationListener" method to ConfigurableApplicationContext interface, for statically registered listeners Package org.springframework.core * added "getNames", "getNamesForProperty", "getNamesForSuffix" and "getValuesForSuffix" methods to Constants * fixed GenericCollectionTypeResolver to correctly navigate Map-List-List structures with a nesting level of 3 or more * BridgeMethodResolver performs multi-step resolution of type variables, for complex multi-type inheritance scenarios Package org.springframework.dao * PersistenceExceptionTranslationInterceptor supports PersistenceExceptionTranslator autodetection in standalone mode Package org.springframework.jca * added "setConnectionSpec" method and corresponding constructor to CciTemplate, for specifying a spec at template level * added "getDerivedTemplate(ConnectionSpec) method to CciTemplate, for obtaining a template with just different con spec * added "getCciTemplate(ConnectionSpec) method to CciDaoSupport, for obtaining a template with just different con spec Package org.springframework.jdbc * SqlOperation and its subclasses do not pre-parse for named parameters anymore, accepting ":" in plain SQL strings Package org.springframework.jms * added "isSessionTransactional" method to ConnectionFactoryUtils * introduced SessionProxy interface for target Session access, exposed by TransactionAwareConnectionFactoryProxy * DefaultMessageListenerContainer switches "sessionTransacted" to "true" in case of a non-JTA ResourceTransactionManager * DefaultMessageListenerContainer rolls back an external transaction in case of a message rejected while stopping * DefaultMessageListenerContainer does not eagerly commit/rollback a in case of a synchronized transacted Session * DefaultMessageListenerContainer obtains a shared Connection lazily in case of autoStartup="true" * DefaultMessageListenerContainer recovers a shared Connection lazily if it is not currently running (has been stopped) * DefaultMessageListenerContainer allows for specifying the listener object lazily, and for replacing it at runtime * fixed JmsInvokerClientInterceptor/ProxyFactoryBean's "queue" property to declare type Queue now Package org.springframework.jndi * added "proxyInterfaces" property to JndiObjectFactoryBean, for specifying multiple interfaces * JndiObjectFactoryBean autodetects proxy interfaces from a specified "expectedType", if necessary * JndiObjectTargetSource returns the specified "expectedType" as target class if no JNDI object has been obtained yet Package org.springframework.mail * added "setPriority" method to MimeMessageHelper, for populating the "X-Priority" mail header Package org.springframework.mock * MockHttpServletResponse automatically marks the response as committed once the buffer size has been exceeded * MockHttpServletResponse marks the response as committed in case of a "OutputStream.flush()" / "Writer.flush()" call Package org.springframework.orm * SharedEntityManagerCreator's proxies deliver a "toString()" result without touching a target EntityManager * added protected "getPersistenceUnitInfo" method to DefaultPersistenceUnitManager, to allow for better subclassing * DefaultPersistenceUnitManager clears the default PersistenceUnitInfo once it has been obtained * added "defaultPersistenceUnitName" property to PersistenceAnnotationBeanPostProcessor * PersistenceAnnotationBeanPostProcessor only sets fields/methods accessible when actually necessary Package org.springframework.remoting * RemoteInvocationUtils detects cycles in exception causes when updating the stack trace (avoiding an infinite loop) Package org.springframework.samples * added default Hibernate EntityManager and Apache OpenJPA configurations to PetClinic's WAR file and integration tests * PetClinic's JPA variant explicitly specifies "META-INF/orm.xml" as mapping file (for Hibernate EntityManager 3.3.0) * PetPortal's build script properly includes the Log4J jar in the WAR file Package org.springframework.scheduling * added "targetBeanName" property to MethodInvokingJobDetailFactoryBean for Quartz, allowing for non-singleton targets * ThreadPoolTaskExecutor/ScheduledExecutorFactoryBean includes the corresponding bean name in startup/shutdown logging Package org.springframework.scripting * LangNamespaceHandler references ScriptFactory classes by name, to avoid NoClassDefFoundErrors in all scenarios * added "scope" attribute to all script tags in the "lang" namespace, allowing for non-singleton script objects * updated JRuby support for JRuby 0.9.8 (requiring this version now due to incompatible JRuby API changes) Package org.springframework.test * added "getActualException()" method to AssertThrows, for introspecting the actual exception instance after throwing Package org.springframework.transaction * factored out TransactionOperations interface from TransactionTemplate, defining the central "execute" operation * introduced ResourceTransactionManager (i.e. non-JTA) interface, indicating the resource factory that it operates on * "tx:advice" expects that the XML parser might not expose the defaults defined in "spring-tx-2.0.xsd" (e.g. on Resin) Package org.springframework.util * ObjectUtils's "nullSafeToString"/"getDisplayValue" returns an empty String if "Object.toString()" returned null * ClassUtils's "classPackageAsResourcePath" parses the class name in order to detect the package name in all cases * fixed CustomizableThreadCreator to properly apply its "daemon" flag (inherited by SimpleAsyncTaskExecutor) Package org.springframework.web * added "getContextPath", "getRemoteUser", "getUserPrincipal", "isUserInRole", "isSecure" to WebRequest abstraction * changed visibility of "getRequest" accessor on ServletWebRequest and PortletWebRequest to public * CharacterEncodingFilter sets the encoding as default response encoding on Servlet 2.4+ (if "forceEncoding"="true") * Servlet/PortletContextAware and Servlet/PortletConfigAware are simply skipped if they cannot be satisfied * added public "refresh()" operation with protected "onRefresh()" template method to DispatcherServlet/Portlet * reworked DispatcherServlet/Portlet to automatically refresh internal state if its ApplicationContext refreshes * DispatcherPortlet logs startup logging at debug level instead of info level, analogous to DispatcherServlet * factored out protected "getHandlerExecutionChain" template method in Servlet/Portlet AbstractHandlerMapping * added "getRootHandler()" method to AbstractUrlHandlerMapping, called on each access to the root handler * added overloaded "suppressValidation(request, command, errors)" variant to BaseCommandController * deprecated "suppressValidation(request)" in BaseCommandController, in favor of the "(request, command)" variant * revised AbstractXsltView for transformer customization options ("buildTransformer" and "getTemplates" methods) * added "getParameters(model, request") variant to AbstractXsltView, deprecating the old "getParameters()" variant * "spring.tld" and "spring-form.tld" declare the Spring major version number (2.0) as taglib version number * fixed JSP BindTag to correctly save and re-expose a page-scoped "status" attribute (not just a request-scoped one) * JSP FormTag escapes the "action" attribute as well if HTML escaping has been requested * JSP InputTag supports the common "autocomplete" HTML extension attribute (as supported by IE and Firefox) * JSP InputTag and TextareaTag support the HTML "readonly" element correctly now, only rendering it if specified * JSP CheckboxTag applies custom editors for the element type when comparing collection elements * added missing "readonly" attribute to JSP TextareaTag * checkbox and radiobutton macros in "spring.vm" for Velocity do not render an id anymore (because it isn't unique) * checkbox macro in "spring.vm" for Velocity and "spring.ftl" for FreeMarker renders the default field marker * added theme macros to "spring.vm" for Velocity and "spring.ftl" for FreeMarker, providing access to theme messages Changes in version 2.0.3 (2007-03-09) ------------------------------------- General * basic scheduling support is included in "spring-context.jar", with only Quartz support added in "spring-support.jar" * all checks for library presence are explicitly performed with Spring's own ClassLoader (not the application's) * overall startup/shutdown logging at info level is less verbose (activate debug log level for more config details) * included the "petportal" sample application in the "-with-dependencies" distribution Package org.springframework.aop * introduced AfterAdvice marker, as super-interface of AfterReturningAdvice and ThrowsAdvice, for reduced coupling * exposed "invocableClone()" and "setUserAttribute"/"getUserAttribute" on ProxyMethodInvocation, for reduced coupling * introduced TargetClassAware interface, extended by Advised, and framework-decoupled "AopUtils.getTargetClass" method * fixed ClassFilters to provide JDK-1.3/1.4-compatible "hashCode()" implementations for unions and intersections * MethodMatchers and Pointcuts support IntroductionAwareMethodMatcher for unions and intersections * added pointcut union operation to ComposablePointcut, reused by the "Pointcuts.union" convenience operation * RegexpMethodPointcutAdvisor references ORO classes indirectly, to avoid eager loading of ORO on Solaris JDK 1.6 * AnnotationMethodMatcher and AnnotationMatchingPointcut check for an annotation on the target method as well * added "forClassAnnotation" and "forMethodAnnotation" factory methods to AnnotationMatchingPointcut * redefined target-class proxying to create a JDK proxy in case of the target class being an interface * CGLIB proxies handle "hashCode" calls according to their "equals" behavior, analogous to JDK dynamic proxies * introduced stricter null checks for Advised/AdvisedSupport * exposed "indexOf(Advice)" method on Advised interface * revised ProxyConfig/AdvisedSupport's "toString()" output * added "setTargetClass" method to AdvisedSupport, building an EmptyTargetSource for the specified class * moved "aopProxyFactory" bean property and AdvisedSupportListener management down to new ProxyCreatorSupport base class * AdvisorChainFactory is not forced to implement the AdvisedSupportListener interface anymore * deprecated AdvisorChainFactoryUtils and HashMapCachingAdvisorChainFactory in favor of SimpleAdvisorChainFactory * added overloaded ProxyFactory constructors for single-interceptor and TargetSource-only proxies * ProxyFactoryBean exposes a composite interface as object type in case of multiple proxy interfaces specified * AbstractSingletonProxyFactoryBean and AbstractAutoProxyCreator use the bean ClassLoader for generating proxies * reworked AdvisorAdapter and AdvisorAdapterRegistry to expose a MethodInterceptor right away * AspectJExpressionPointcut ignores target classes not accepted by PointcutExpression matching (such as arrays) * AspectJExpressionPointcut falls back to the proxy method if the ShadowMatch failed for the target method * revised AspectJPointcutAdvisor to never apply AspectJ advice methods to themselves (avoiding a stack overflow) * AbstractAspectJAdvice calls "setAccessible" on an advice method right before invocation and only if actually necessary * AspectJAdviceParameterNameDiscoverer properly considers reference pointcuts as potential source of parameter binding * AbstractAspectJAdvisorFactory detects @AspectJ aspects through the presence of the @Aspect annotation * MethodInvocationProceedingJoinPoint allows for multiple "proceed(arguments)" calls, cloning the underlying invocation * PrototypeAspectInstanceFactory enforces that the target bean is a prototype; it does not accept scoped objects * PrototypeTargetSource enforces that the target bean is a prototype; it does not accept scoped objects * PrototypeTargetSource destroys bean instances on release (honors DisposableBean and/or destroy-method) * ThreadLocalTargetSource destroys bean instances via ConfigurableBeanFactory's "destroyBean" (if possible) * added "forClass" factory method to EmptyTargetSource, allowing to indicate a specific target class * added "equals"/"hashCode" implementation to AbstractBeanFactoryBasedTargetSource * HotSwappableTargetSource's "hashCode" implementation returns a constant value even if the target object changes * added SimpleBeanTargetSource, performing a fresh getBean lookup on every request, for any kind of bean * ScopedProxyFactoryBean uses the BeanFactory's bean ClassLoader for generating scoped proxies * auto-proxying ignores objects exposed by ScopedProxyFactoryBeans; only their target beans are eligible * fixed "scoped-proxy" bean definition decorator to properly parse an inner bean with scoped-proxy marker * added "proxy-target-class" attribute to "scoped-proxy" XML tag, allowing to turn target class proxying off * reworked "scoped-proxy" XML tag to enforce a target class proxy selectively, for its specific target bean * "scoped-proxy" marks its targets as autowireCandidate=false, to make autowiring by type only hit the scoped proxy * @Configurable works for deserialized objects as well Package org.springframework.beans * CachedIntrospectionResults's "acceptedClassLoaders" facility uses thread-safe iteration * fixed BeanWrapperImpl's "toString()" output in case of no wrapped object set * BeanWrapperImpl supports nested generic collections as map keys and as indexed map values * added "getTypeConverter()" method to ConfigurableBeanFactory interface * MethodInvokingFactoryBean obtains the TypeConverter from the BeanFactory that it runs in * List/Set/MapFactoryBean convert elements to the generic type expressed in a superclass/interface of the target class * added SmartInstantiationAwareBeanPostProcessor interface, supporting type prediction (for scripted object types) * PropertyPlaceholderConfigurer detects and processes placeholders in scope names as well * PropertyPlaceholderConfigurer does not log resolved (potentially decrypted) placeholder values at debug level anymore * PreferencesPlaceholderConfigurer resolves paths in placeholders ("myPath/myPlaceholderKey") as preference nodes * added "isPrototype(beanName)" method to BeanFactory interface, explicitly checking for an independent instance * added extended SmartFactoryBean interface, including an "isPrototype()" method that checks for an independent instance * AbstractBeanFactory throws BeanCreationException will full context info if "postProcessObjectFromFactoryBean" fails * DisposableBeanAdapter (as passed into "Scope.registerDestructionCallback") is serializable, even for post-processors * AbstractAutowireCapableBeanFactory does not trigger "toString()" call on argument for UnsatisfiedDependencyException * turned visibility of AbstractAutowireCapableBeanFactory's "applyPropertyValues" method from private to protected * DefaultListableBeanFactory's "getBeansOfType" only ignores currently-in-creation for beans which are still in creation * added copy constructor to ChildBeanDefinition, for custom use in programmatic bean registration code * TypedStringValue overrides "equals", "hashCode" and "toString" * TypedStringValue implements the BeanMetadataElement interface and provides a "setSource" method * introduced BeanNameGenerator strategy interface, to be configured on an AbstractBeanDefinitionReader * added "generateBeanName/registerWithGeneratedName(BeanDefinition)" methods to XmlReaderContext * BeanDefinitionParseDelegate always builds TypedStringValue for "value" and "null" XML elements, preserving the source * BeanDefinitionParseDelegate builds TypedStringValue for "entry" and "prop" keys and values, preserving the source * BeanDefinitionParseDelegate trims whitespace from "class" attributes in XML bean definitions * collection merging accepts a null parent value as well, simply using the child collection as-is in this case * indexed constructor arguments support collection merging (driven by merge="true", analogous to property values) * BeanDefinitions returned by nested custom XML elements receive a generated id, to avoid FactoryBean cache conflicts * added deprecated "findXxx" signatures back to NamespaceHandlerSupport, for full compatibility with Spring 2.0 final * added protected "shouldGenerateIdAsFallback()" template method to AbstractBeanDefinitionParser * AbstractSingleBeanDefinitionParser applies a document's default-lazy-init="true" to its generated bean definitions * added "isEligibleAttribute" template method to AbstractSimpleBeanDefinitionParser, for excluding specific attributes * "util:properties" tag supports nested "prop" elements for local entries, analogous to the standard "props" tag Package org.springframework.context * AbstractApplicationContext instantiates BeanPostProcessors which implemented Ordered before non-Ordered ones * AbstractApplicationContext applies start/stop callbacks to existing Lifecycle instances only, particularly on shutdown * AbstractApplicationContext correctly detects listener creation failure (in case of currently-in-creation exception) * factored out protected "destroyBeans()" template method in AbstractApplicationContext, for custom bean destruction * AbstractRefreshableApplicationContext allows BeanFactory access during the destruction phase of a "refresh()" call * added "customizeBeanFactory(DefaultListableBeanFactory)" template method to AbstractRefreshableApplicationContext * (Reloadable)ResourceBundleMessageSource trims whitespace from specified bundle basenames * ResourceBundleMessageSource by default uses the bean ClassLoader for loading bundles Package org.springframework.core * added "getMostSpecificCause()" method to NestedRuntime/CheckedException, retrieving the root cause or this exception * fixed BridgeMethodResolver's "populateTypeMapFromParameterizedType" to properly handle nested generics * fixed BridgeMethodResolver to properly detect a generic interface even in a class hierarchy * fixed BridgeMethodResolver to properly detect a generic array type as exposed by a vararg signature * introduced AsyncTaskExecutor extension interface, defining an "execute" variant with start timeout * refactored SimpleAsyncTaskExecutor to allow for reuse of the CustomizableThreadCreator class * SimpleAsyncTaskExecutor executes tasks with timeout='immediate' directly, bypassing the concurrency throttle * introduced TaskTimeoutException, thrown by an AsyncTaskExecutor in case of a task rejected because of a timeout Package org.springframework.dao * PersistenceExceptionTranslationPostProcessor uses the bean ClassLoader for generating translation proxies Package org.springframework.ejb * AbstractEnterpriseBean uses the EJB instance as WeakReferenceMonitor handle, instead of a BeanFactoryReference proxy * all "jee:*" tags support an "environment-ref" attribute, pointing to a shared bean of type "java.util.Properties" * OC4J's "com.evermind.server.rmi.RMIConnectionException" gets detected as Remote EJB (RMI) connect failure as well Package org.springframework.instrument * ShadowingClassLoader excludes "com.sun." package by default (for using Sun's Xerces version through JAXP) Package org.springframework.jca * TransactionAwareConnectionFactoryProxy throws JCA IllegalStateException in case of "getLocalTransaction()" access * CciLocalTransactionManager unwraps given TransactionAwareConnectionFactoryProxy to obtain its target ConnectionFactory * added ResourceAdapterFactoryBean to "jca.support" package, for bootstrapping a JCA 1.5 ResourceAdapter locally * introduced "jca.work" package, containing a JCA 1.5 WorkManagerTaskExecutor and a SimpleTaskWorkManager implementation Package org.springframework.jdbc * added overloaded ConnectionHolder constructor with a given Connection plus "transactionActive" flag as arguments * UserCredentialDataSourceAdapter delegates "getConnection(String, String)" to "doGetConnection", for unified handling * introduced IsolationLevelDataSourceAdapter, preparing Connections with isolation level (transaction's or fixed) * introduced WebSphereDataSourceAdapter, obtaining Connections through WebSphere's JDBCConnectionSpec facility * re-added Spring 1.2's "JdbcUtils.isNumeric" convenience method, for use by applications (upgrading from Spring 1.2) * revised JdbcTemplate's prepared statement logging Package org.springframework.jms * marked JmsDestinationAccessor as abstract * moved protected "createConnection" and "createSession" methods from JmsTemplate up to JmsAccessor * TransactionAwareConnectionFactoryProxy throws TransactionInProgressException in case of manual commit/rollback calls * JmsTransactionManager unwraps given TransactionAwareConnectionFactoryProxy to obtain its target ConnectionFactory * ConnectionFactoryUtils's JmsResourceHolder only stops Connections if a SmartConnectionFactory explicitly asks for it * factored out AbstractJmsListeningContainer base class from AbstractMessageListenerContainer * AbstractMessageListenerContainer's "refreshSharedConnection" properly resets shared Connection in refresh failure case * AbstractMessageListenerContainer explicitly aborts messages which have been delivered after initiated shutdown * added "acceptMessagesWhileStopping" flag to AbstractMessageListenerContainer, for processing all delivered messages * factored out AbstractPollingMessageListenerContainer base class from DefaultMessageListenerContainer * added dynamic scaling up/down to DefaultMessageListenerContainer, configured through "maxConcurrentConsumers" property * DefaultMessageListenerContainer's Connection recovery loop catches any Exception thrown from "createConnection" * MessageListenerAdapter can delegate to native target (SessionAware)MessageListener if no listener method specified Package org.springframework.jmx * MBeanExporter and MBeanServerConnectionFactoryBean use the bean ClassLoader for generating lazy-init proxies * MBeanExporter supports lazy-init standard MBeans analogously to lazy-init Spring beans with ModelMBean wrapping * factored out protected "isMBean(Class") method in MBeanExporter, to allow for extending the default MBean check * MBeanServerFactoryBean only tries to obtain the JDK 1.5 platform MBeanServer in case of no agent id specified * MBeanServerFactoryBean tries to create a new MBeanServer if not allowed to access the JDK 1.5 platform MBeanServer * added WebSphereMBeanServerFactoryBean, using WebSphere's proprietary AdminServiceFactory API for MBeanServer access * added "agentId" property to MBeanClientInterceptor/MBeanProxyFactoryBean, for locating a specific MBeanServer Package org.springframework.jndi * JndiObjectFactoryBean uses the bean ClassLoader for generating lazy-init proxies * JndiObjectTargetSource (as used by JndiObjectFactoryBean's "proxyInterface" support) throws JndiLookupException Package org.springframework.mock * added "clearAttributes()" method to MockHttpServletRequest and MockHttpSession * added "serializeState" and "deserializeState" methods to MockHttpSession, for testing attribute serialization * introduced MockFilterChain (recording the call) and PassThroughFilterChain (passing the call on to a Filter/Servlet) Package org.springframework.orm * added "flushMode" init parameter to Hibernate3 OpenSessionInViewFilter (supporting "AUTO" etc as value) * Hibernate3 SessionFactoryUtils translates SQLGrammar/DataException into InvalidDataAccessResourceUsageException * Hibernate3 HibernateAccessor/TransactionManager translates GenericJDBCException using a default SQLExceptionTranslator * TopLink LocalSessionFactory provides "loginProperties"/"loginPropertyMap" bean properties, for applying login settings * TopLink LocalSessionFactoryBean uses the bean ClassLoader as TopLink Session ClassLoader Package org.springframework.remoting * all remoting ProxyFactoryBeans use the bean ClassLoader for generating service proxies * RemoteExporter uses the bean ClassLoader for generating service proxies * added public "getHost()" and "getPort()" accessors to RmiRegistryFactoryBean * added "alwaysCreate" flag to RmiRegistryFactoryBean, for avoiding the overhead of locating an existing registry * added "alwaysCreateRegistry" flag to RmiServiceExporter, for avoiding the overhead of locating an existing registry * added "rebind()" method to JndiRmiServiceExporter, for recovering in case of the target registry having been restarted * CodebaseAwareObjectInputStream uses "Class.forName", to be able to resolve array classes with any ClassLoader * added "getTargetInterfaceName()" method to RmiInvocationHandler, for client-side introspection * HttpInvokerClientInterceptor does not require an "afterPropertiesSet()" call for initializing the request executor * added "serviceFactory" property to LocalJaxRpcServiceFactory, for passing in a pre-initialized ServiceFactory instance * fixed JaxRpcPortClientInterceptor to properly recover in case of a failed lazy "prepare()" attempt * JaxRpcPortClientInterceptor consistently throws RemoteLookupFailureException if a lazy "prepare()" attempt failed * added "refreshServiceAfterConnectFailure" bean property to JaxRpcPortClientInterceptor, allowing for service recovery Package org.springframework.scheduling * added "workListener" bean property to the CommonJ WorkManagerTaskExecutor * introduced the CustomizableThreadFactory class, implementing JDK 1.5's ThreadFactory SPI with bean-style configuration * ThreadPoolTaskExecutor's "corePoolSize" and "maxPoolSize" properties allow for runtime changes (e.g. through JMX) * added "getPoolSize()" and "getActiveCount()" methods to ThreadPoolTaskExecutor (intended for JMX exposure) * added "getThreadPoolExecutor()" accessor to ThreadPoolTaskExecutor, for native access to the underlying executor * added "exposeUnconfigurableExecutor" bean property to ScheduledExecutorFactoryBean * added support for the JSR-166 (java.util.concurrent) backport project, in the "scheduling.backportconcurrent" package Package org.springframework.scripting * added "getScriptedObjectType" method to ScriptFactory interface * Bsh/Groovy/JRubyScriptFactory uses the bean ClassLoader for generating script objects * BshObjectInvocationHandler/JRubyObjectInvocationHandler implement "equals"/"hashCode/"toString" based on script object * BshScriptUtils and BshScriptFactory support BeanShell scripts that declare an actual class or instance * GroovyScriptFactory supports Groovy scripts that create an actual instance or explicitly return an object * Bsh/GroovyScriptFactory caches the script class as far as possible, building prototypes from the same class * JRubyScriptUtils passes the declared return type to JRuby, for proper conversion of number types * JRubyScriptUtils converts Ruby arrays back to declared Java arrays * ScriptFactoryPostProcessor uses the bean ClassLoader for generating refreshable script proxies * ScriptFactoryPostProcessor applies a config interface to the scripted target object only, not to a refreshable proxy * revised ScriptFactoryPostProcessor to support AOP auto-proxying for scripted objects * revised ScriptFactoryPostProcessor to support type determination for scripted objects * LangNamespaceHandler always registers all BeanDefinitionParsers, failing with NoClassDefFoundError for actual script Package org.springframework.test * AbstractSingleSpringContextTests uses GenericApplicationContext by default, created through "createApplicationContext" * added "customizeBeanFactory(DefaultListableBeanFactory)" template method to AbstractSingleSpringContextTests * AbstractSingleSpringContextTests supports "getConfigPaths()" method, specifying config files relative to test class * AbstractSingleSpringContextTests supports "getConfigPath()" method, specifying a single file relative to test class * changed the visibility of AbstractDependencyInjectionSpringContextTests's "injectDependencies" method to protected * changed the visibility of AbstractTransactionalSpringContextTests's "transactionDefinition" field to protected * AssertThrows preserves an unexpected exception as root cause in the "wrong exception thrown" AssertionFailedError Package org.springframework.transaction * AbstractPlatformTransactionManager exposes "actualTransactionActive" flag for a newly synchronized existing tx as well * AbstractPlatformTransactionManager marks an existing transaction as rollback-only even in case of a commit exception * turned various AbstractPlatformTransactionManager methods from private to protected, for reuse in specific subclasses * JtaTransactionManager does not fail if default UserTransaction lookup fails: falls back on TransactionManager instead * SpringJtaSynchronizationAdapter does not explicitly call "setRollbackOnly" on WebLogic, to preserve the root cause * added OC4JJtaTransactionManager for Oracle OC4J 10.1.3(.2), with support for transaction names and isolation levels * fixed AbstractFallbackTransactionAttributeSource to synchronize access to its attribute cache * added "order" attribute to "tx:annotation-driven" tag, determining the order of the tx advisor in the advice chain Package org.springframework.util * ResourceUtils's "extractJarFileURL" only prepends a slash in front of a file path if it doesn't already have a slash * added CustomizableThreadCreator class, serving as base class for ThreadFactory adapters Package org.springframework.web * CharacterEncodingFilter only applies its encoding if actually specified (non-null) * ConfigurableWebApplicationContext and ConfigurablePortletApplicationContext expose config state through getters * RequestContextListener works correctly even in case of the "requestDestroyed" callback coming from a different thread * ServletRequestAttributes's DestructionCallbackBindingListener is serializable, surviving web app restarts * added "warnLogCategory" property to SimpleMappingExceptionResolver, allowing to log the exception to warn level * added protected "determineStatusCode" method to Servlet SimpleMappingExceptionResolver, for custom status codes * added "rootHandler" bean property to AbstractUrlHandlerMapping, kicking in for the "/" path * added "detectHandlersInAncestorContexts" to BeanNameUrlHandlerMapping, for detecting handler beans in the root context * added "excludedPackages" and "excludedClasses" bean properties to ControllerClassNameHandlerMapping * ControllerClassNameHandlerMapping excludes all classes in the "org.springframework.web.servlet.mvc" package by default * revised FormTag to be more extensible (through less assertions and consistent use of protected template methods) * OptionsTag accepts no or empty items specified, simply not rendering any option tags in such a case * ErrorsTag properly supports HTML escaping (participates in default HTML escaping and respects the "htmlEscape" flag) * ErrorsTag simply renders empty if neither a BindingResult nor a target object for its bind path is present * revised VelocityToolboxView to support Velocity Tools 1.3's init methods (ViewTool callbacks are now deprecated) * FreeMarker "formTextarea" macro does not re-escape its value (escaping is up to "htmlEscape"/"defaultHtmlEscape") * added "messageArgs" and "messageArgsText" macros to the "spring.ftl" FreeMarker macro template library Changes in version 2.0.2 (2007-01-08) ------------------------------------- General * fixed spring-beans.jar to not include "META-INF/aop.xml", "META-INF/spring.tld" and "META-INF/spring-form.tld" anymore * leverage the "trace" log level in the Spring core, to make activating the "debug" log level more bearable Package org.springframework.aop * AbstractRegexpMethodPointcut trims whitespace from passed-in "patterns" and "excludedPatterns" * fixed AbstractAutoProxyCreator to allow for proxying the same bean with multiple auto proxy creators (again) * BeanNameAutoProxyCreator trims whitespace from passed-in "beanNames" * ScopedProxyFactoryBean throws IllegalStateException if it couldn't determine the type of the target bean (avoid NPE) * "scoped-proxy" tag works for non-singleton FactoryBeans as well, leveraging the BeanFactory's improved type check * factored out BeanFactoryAdvisorRetrievalHelper from AbstractAdvisorAutoProxyCreator * factored out BeanFactoryAspectJAdvisorsBuilder from AnnotationAwareAspectJAutoProxyCreator * added AbstractBeanFactoryPointcutAdvisor and DefaultBeanFactoryPointcutAdvisor * each "aop:advisor" entry lazily initializes its Advice bean, to let all target beans be exposed to all Advisors Package org.springframework.beans * CachedIntrospectionResults allows for caching for specific ClassLoaders even if their classes are not cache-safe * BeanWrapper interface extends TypeConverter interface, instead of just BeanWrapperImpl implementing TypeConverter * BeanWrapperImpl converts nested collection value (e.g. List within Map) to declared generic type, if applicable * BeanWrapperImpl's TypeMismatchException mentions the specific element that failed in case of a (generic) collection * BeanWrapperImpl assigns a given array directly if component type matches and no matching custom editors registered * added default editor for JDK 1.4's "java.net.URI" class, supporting "classpath:" pseudo URLs as well as general URIs * ResourceEditorRegistrar always registers ClassEditor for given ResourceLoader's ClassLoader * added "originalBeanName(String)" method to BeanFactoryUtils, allowing to cut off a generated "#..." suffix * FieldRetrievingFactoryBean and PropertyPathFactoryBean extract the original bean name for their beanName-based syntax * added support for 'early access singletons' to AbstractFactoryBean, exposing a proxy in case of a circular reference * ListFactoryBean, SetFactoryBean and MapFactoryBean support exposure of a proxy in case of a circular reference * refined currently-in-creation check for lazy-init singletons, to avoid unintended BeanCurrentlyInCreationException * DefaultSingletonBeanRegistry and subclasses use unified mutex for singleton access, to avoid potential for deadlocks * AbstractBeanFactory caches merged bean definitions with bean definition identity as key (to avoid bean name conflicts) * AbstractAutowireCapableBeanFactory caches "isExcludedFromDependencyCheck" results for affected PropertyDescriptors * AbstractAutowireCapableBeanFactory provides two-step FactoryBean type check for non-singleton FactoryBeans as well * fixed AbstractAutowireCapableBeanFactory to only apply injection-before-wrapping check for singletons * DefaultListableBeanFactory avoids expensive dependency check preparations unless an actual dependency check is needed * ResourceEntityResolver catches any kind of Exception in system root URL check (in particular AccessControlException) * introduced XmlBeanDefinitionStoreException, with special support for SAXParseException and its location information * XmlBeanDefinitionReader chooses XSD validation if XmlValidationModeDetector indicates AUTO (= no clear indication) * XML bean "id" and "name" (aliases) are allowed to define the same name (for backwards compatibility with Spring 1.2.8) * BeanDefinitionDecorators are applied to inner beans as well (in particular: "p:" namespace works for inner beans now) * fixed AbstractBeanDefinitionParser and UtilNamespaceHandler to consistently use ProblemReporter instead of exceptions * added "fatal" method to ProblemReporter, used by NamespaceHandlerSupport to report a missing parser or decorator * added "defaultsRegistered" notification to ReaderEventListener, with DefaultsDefinition marker interface as argument * reworked BeanDefinitionParserDelegate to build and hold a DocumentDefaultsDefinition instance, also firing an event * BeanDefinitionParserDelegate/AbstractBeanDefinitionParser report bean name generation failure through ProblemReporter * DefaultBeanDefinitioDocumentReader reports alias registration failure through ProblemReporter Package org.springframework.context * AbstractApplicationContext explicitly stops all Lifecycle Beans before destroying them one-by-one (to avoid delays) Package org.springframework.core * Conventions (as used by ModelMap) extracts inner class name for inner classes * Conventions (as used by ModelMap) extracts primary interface name for JDK proxies * reworked CollectionFactory's "createApproximateCollection/Map" to preserve original Comparator for TreeSet/TreeMap * LocalVariableTableParameterNameDiscoverer uses current ClassLoader for ASM analysis (not the system ClassLoader) * PathMatchingResourcePatternResolver properly handles jar file roots returned by the ClassLoader (e.g. on Resin) Package org.springframework.dao * added "singleResult" and "requiredSingleResult" methods to DataAccessUtils, distinct from "uniqueResult"'s contract Package org.springframework.jdbc * RowMapperResultSetExtractor always uses ArrayList, even in case of unknown number of rows expected * JdbcTemplate by default uses "PreparedStatement.setString" for any CharSequence (including String and StringBuilder) * JdbcTemplate logs SQLWarnings at debug instead of warn level, to avoid repeated warn logs for acceptable conditions * JdbcTemplate's "queryForObject" uses "requiredSingleResult" to never accept more than 1 row in result (as per its c.) * SqlQuery's "findObject" explicitly uses "singleResult" to never accept more than 1 row in result (as per its contract) Package org.springframework.jms * introduced SmartConnectionFactory interface and "ConnectionFactoryUtils.releaseConnection" method * introduced DelegatingConnectionFactory, configuring whether a Connection should be stopped before closing it * JmsTemplate/DefaultMessageListenerContainer do *not* explicitly stop their Connections by default anymore (see above) * added "transactionName" property to DefaultMessageListenerContainer (in particular for WebLogic's tx monitoring) * fixed JmsInvokerClientInterceptor to always explicitly start its Connection (not rely on pre-started Connections) Package org.springframework.jmx * reworked MBeanProxyFactoryBean's and ConnectorServerFactoryBean's "setObjectName" to also accept ObjectName reference Package org.springframework.orm * SqlMapClientFactoryBean uses SqlMapClientBuilder with InputStream if possible (on iBATIS 2.3, to avoid encoding issue) * Hibernate3 LocalSessionFactoryBean automatically sets JTATransactionFactory if given a "jtaTransactionManager" * Hibernate3 LocalSessionFactoryBean only sets connection release mode "on_close" if not given a "jtaTransactionManager" * Hibernate3 LocalSessionFactoryBean exposes configured DataSource for schema update (required on Hibernate 3.2.1+) * fixed Hibernate JTA transaction synchronization to properly mark a rollback on WebSphereExtendedJTATransactionLookup * HibernateJpaDialect switches FlushMode to MANUAL in case of read-only, and enforces COMMIT or AUTO for read-write tx * fixed "hashCode()" handling in extended JPA EntityManager proxy, avoiding an eternal recursion * extended JPA EntityManagers that join a synchronized transaction propagate a commit exception to the (commit) caller * PersistenceUnitReader determines URI-conforming persistence unit root (for Hibernate EntityManager's archive browsing) * JpaTransactionManager and EntityManagerFactoryUtils's JTA synchronization clear a pre-bound EntityManager on rollback * PersistenceAnnotationBeanPostProcessor allows for specifying JNDI names for persistence units and persistence contexts * OpenXxxInViewFilters reobtain thread-bound holder for closing it, to allow for replacing the holder during a request Package org.springframework.remoting * RmiServiceExporter logs description of actual registry instead of port (to properly handle passed-in "registry") * HttpInvokerClientInterceptor/ProxyFactoryBean uses the ClassLoader of the containing BeanFactory for deserialization Package org.springframework.samples * cleaned up platform/login configuration in PetClinic's TopLink variant Package org.springframework.scheduling * fixed MethodInvokingJobDetailFactoryBean to be compatible with Quartz 1.6 as well as Quartz 1.5.2 (again) * reworked Quartz SpringBeanJobFactory's "ignoredUnknownProperties" into a String array of unknown properties to ignore * CommonJ TimerManagerFactoryBean supports Lifecycle interface, suspending/resuming its TimerManager accordingly * CommonJ TimerManagerFactoryBean explicitly stops its TimerManager on destroy, not relying on J2EE application shutdown * added "shared" flag to CommonJ TimerManagerFactoryBean, to suppress suspend/resume/stop calls in case of a shared TM Package org.springframework.scripting * updated Groovy support to Groovy 1.0 final * added optional GroovyObjectCustomizer constructor arg to GroovyScriptFactory, to allow for setting a custom MetaClass * updated JRuby support to JRuby 0.9.2 (not compatible with previous JRuby versions anymore!) * fixed JRubyScriptFactory to correctly wrap Java objects that get passed into a JRuby script proxy * fixed JRubyScriptFactory's "findClassNode" to always cast the correct object Package org.springframework.test * added public "getApplicationContext()" method to AbstractSingleSpringContextTests * added public "getJdbcTemplate()" method to AbstractTransactionalDataSourceSpringContextTests Package org.springframework.transaction * AbstractPlatformTransactionManager logs full transaction definition when creating a new transaction * added "defaultTimeout" property to AbstractPlatformTransactionManager Package org.springframework.ui * VelocityEngineFactory/SpringResourceLoader supports Velocity-style comma-separated paths as "resourceLoaderPath" value Package org.springframework.util * added overloaded no-arg "start()" method to StopWatch * added "hasConstructor" and "getConstructorIfAvailable" methods to ClassUtils * ClassUtils's "getAllInterfaces"/"getAllInterfacesForClass" preserves interface definition order in the result array * fixed AntPathMatcher's "extractPathWithinPattern" to correctly extract paths that have fewer parts than the pattern * XmlValidationModeDetector returns VALIDATION_AUTO if it encounters a CharConversionException Package org.springframework.validation * added "prefix" property and "postProcessMessageCode" template method to DefaultMessageCodesResolver Package org.springframework.web * IntrospectorCleanupListener explicitly exposes the web app ClassLoader as cacheable for CachedIntrospectionResults * introduced MissingServlet/PortletRequestParameterException subclasses of Servlet/PortletRequestBindingException * reworked the 'default value for missing parameter' check in Servlet/PortletRequestUtils to be as efficient as possible * AbstractUrlHandlerMapping exposes PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for default handler as well * extracted "getViewNameForUrlPath(String)" in UrlFilenameViewController, for full compatibility with Spring 1.2.8 * added "alwaysInclude" bean property to InternalResourceView, for enforcing the use of an include (never a forward) * AbstractJasperReportsView automatically converts exporter parameter Strings that start with a digit into Integers * added "getCompletePath()" method to AbstractDataBoundFormElementTag, esposing nested path concatenated with path * fixed ErrorsTag to use complete path as id, including the nested path * removed unnecessary setter assertions for optional properties in FormTag and InputTag Changes in version 2.0.1 (23.11.2006) ------------------------------------- General * included classes in the "test.annotation" and "test.jpa" packages (tiger mock directory) in the Spring API javadoc Package org.springframework.aop * HashMapCachingAdvisorChainFactory uses synchronized access to its method cache Map * AbstractAutoProxyCreator considers all Advices (not just MethodInterceptors) as infrastructure classes to ignore * fixed AbstractAutoProxyCreator to only obtain beans for "interceptorNames" that have been fully initialized already * reworked AbstractAdvisorAutoProxyCreator's "extendCandidateAdvisors" into "extendAdvisors", operating on sorted list * renamed AspectJInvocationContextExposingAdvisorAutoProxyCreator to AspectJAwareAdvisorAutoProxyCreator * removed unintended JDK 1.5 dependency in AspectJExpressionPointcut ("equals"/"hashCode" implementation) * added "order" attribute to "aspect" tag in AOP schema, allowing to declaratively specify ordering for aspect instances * reworked aspect ordering to allow aspect instances to depend on beans that in turn get advised by the same aspect * added @Order annotation support for @AspectJ style aspects, as alternative to implementing the Ordered interface * redesigned AspectJ support SPI: AspectInstanceFactory, AspectJPointcutAdvisor, AspectJAwareAdvisorAutoProxyCreator * renamed DelegatePerTargetObjectDelegatingIntroductionInterceptor to DelegatePerTargetObjectIntroductionInterceptor Package org.springframework.beans * fixed BeanWrapperImpl to correctly determine generic type for each key in a chain (e.g. "myMap[myKey][myInnerKey]") * introduced PatternEditor for "java.util.regex.Pattern", automatically registered when running on JDK 1.4 or higher * Number objects (as property or argument values) are automatically coerced into the target Number type (if necessary) * added CustomMapEditor for Map-to-Map conversion, with a default instance registered for SortedMap * added "equals" and "hashCode" implementations to BeanDefinitionHolder * PropertyValue's copy constructor copies source object as well * ConstructorArgumentValues copies ValueHolder content when merging, and enforces uniqueness of merged ValueHolders * reworked BeanComponentDefinition into subclass of BeanDefinitionHolder, exposing aliases on the bean definition * re-added BeanReferenceFactoryBean, to allow for substituting the target bean name with a placeholder * UnsatisfiedDependencyException message for multiple matches mentions the names of all matching beans * improved "scope is not active" error message to explicitly hint at the singleton-refers-to-scoped-bean problem * factory methods are allowed to return null, with the null value exposed as bean reference * introduced "isTypeMatch" method on BeanFactory interface, allowing for type checks without actually loading the Class * AbstractBeanFactory supports alias chaining, with an alias registered for a bean name that is itself an alias * AbstractBeanFactory uses bean name as cache key for merged bean definitions, to avoid equality matching overhead * AbstractBeanFactory detects circular references between non-singletons and throws a corresponding exception * AbstractBeanFactory overrides an inner bean's singleton status from the merged outer bean (potentially a child def) * removed default for "abstract"/"singleton" attributes in "spring-beans.dtd", for 2.0-style inheritance for inner beans * added "findAutowireCandidates" template method to AbstractAutowireCapableBeanFactory, superseding "findMatchingBeans" * DefaultListableBeanFactory excludes beans which are not autowire candidates even before it obtains the instances * fixed PropertyPlaceholderConfigurer to throw a BeanDefinitionStoreException in case of any circular reference * fixed PluggableSchemaResolver to accept a null ClassLoader argument (falling back to the default ClassLoader) * introduced CompositeComponentDefinition for holding nested components (applied e.g. for "aop:config" element) * introduced "registerComponent" method on ParserContext, for transparent registration of top-level or nested components * reworked AbstractBeanDefinitionParser to only determine id and build holder for top-level bean definition * "util:list/set/map" are now allowed as nested elements as well and do not require an id anymore Package org.springframework.cache * reworked EhCacheFactoryBean to be based on EHCache 1.2's Ehcache interface rather than the concrete Cache class * added "blocking" flag to EhCacheFactoryBean, for decorating the cache with EHCache 1.2's BlockingCache * added "cacheEntryFactory" flag to EhCacheFactoryBean, for decorating with EHCache 1.2's (Updating)SelfPopulatingCache Package org.springframework.context * added serialVersionUID to ApplicationEvent, for serialization compatibility with Spring 1.2 * LocaleContextHolder supports standard ThreadLocal as well as InheritableThreadLocal * EventPublicationInterceptor caches the application event constructor Package org.springframework.core * GenericCollectionTypeResolver correctly detects an array type as element type of a generic collection type * fixed BridgeMethodResolver to always identify an appropriate bridge method (avoid IllegalStateException) * introduced TaskRejectedException, thrown from a TaskExecutor if it does not accept a given task Package org.springframework.instrument * added GlassFishLoadTimeWeaver for GlassFish / Sun Application Server * refactored Java-5-only AbstractOverridingClassLoader into JDK-1.3-compatible OverridingClassLoader in "core" package Package org.springframework.jdbc * introduced AbstractRoutingDataSource and IsolationLevelDataSourceRouter * JdbcTemplate logs all warnings in case of "ignoreWarnings"=true, not just the first warning in the chain * added "setQueryTimeout" method to JdbcTemplate and RdbmsOperation, for specifying a timeout outside of a transaction * removed bind parameter check from SqlOperation, not parsing the SQL anymore at all (relying on JDBC driver instead) Package org.springframework.jms * reimplemented JMSException translation to handle subclasses of standard JMSExceptions in a specific fashion as well * refined AbstractMessageListenerContainer's autodetection of "pubSubDomain" flag to handle WebLogic Topic correctly * DefaultMessageListenerContainer uses its bean name (if specified) as thread name prefix for its default TaskExecutor Package org.springframework.jmx * MBeanExporter uses ObjectName as exposed by returned ObjectInstance after registration (which differs on WebSphere) * MethodExclusionMBeanInfoAssembler operates correctly in case of no "ignoredMethods" specified Package org.springframework.mock * added "isActive()" and "close()" methods to MockHttpServletRequest and MockPortletRequest * MockHttpServletResponse handles HTTP header names as case-insensitive (analogous to MockHttpServletRequest) * added "setOutputStreamAccessAllowed" and "setWriterAccessAllowed" methods to MockHttpServletResponse * unified mock object constructors that take ServletContext/PortletContext/PortalContext arguments * added all of MockPortletRequest's overloaded constructors to MockActionRequest and MockRenderRequest * turned AbstractSingleSpringContextTests's "contextKey" and "loadContext" methods non-final again * AbstractSingleSpringContextTests provides empty default implementation of "getConfigLocations" (not abstract anymore) Package org.springframework.orm * reworked Hibernate session synchronization to properly work with WebSphereExtendedJTATransactionLookup on WAS 6.0/6.1 * fixed Hibernate3 LocalSessionFactoryBean's "schemaUpdate" behavior to not run into an IllegalStateException * LocalContainerEntityManagerFactoryBean detects jar file URL in WebLogic jar entry URLs correctly * PersistenceAnnotationBeanPostProcessor always injects transactional EntityManager with extended interfaces (if any) * included OpenJPA support classes (OpenJpaDialect, OpenJpaVendorAdapter), tested against OpenJPA 0.9.6 Package org.springframework.scheduling * TimerFactoryBean uses its bean name as Timer thread name (on JDK 1.5, falling back to a default Timer on JDK 1.3/1.4) * deprecated TimerFactoryBean's "createTimer(daemon)" method in favor of "createTimer(name, daemon)" * ScheduledExecutorFactoryBean does not insist on statically specified ScheduledExecutorTasks anymore * DelegatingWork/Job/TimerTask exposes the wrapped Runnable implementation through a "getDelegate()" method * Concurrent/ThreadPoolTaskExecutor and WorkManagerTaskExecutor throw Spring's TaskRejectedException (when appropriate) * CommonJ TimerManagerFactoryBean cancels all statically registered Timers on shutdown * updated LocalTaskExecutorThreadPool to be compatible with Quartz 1.6 Package org.springframework.test * AbstractTransactionalSpringContextTests invokes "onTearDownAfterTransaction" even for a manually completed transaction * fixed AbstractJpaTests to not keep context reference in cache if context refresh failed Package org.springframework.transaction * AbstractPlatformTransactionManager exposes current transaction isolation level via TransactionSynchronizationManager * AbstractPlatformTransactionManager properly resumes all synchronizations even after suspend or inner begin failure * active transaction synchronization gets suspended when going from SUPPORTS/NOT_SUPPORTED into REQUIRED/REQUIRES_NEW * JtaTransactionManager's "doRegisterAfterCompletionWithJtaTransaction" avoids NPE if no current JTA transaction active * TransactionAttributeEditor does not accept transaction attributes with invalid whitespace anymore * fixed AnnotationTransactionAspect to not throw a NoTransactionException in case of transaction begin failure * AnnotationTransactionAspect supports protected and private methods that carry Spring's @Transactional annotation Package org.springframework.ui * deprecated FreeMarkerConfigurationFactory's "templateLoaders" property in favor of "pre/postTemplateLoaders" Package org.springframework.util * "ObjectUtils.toObjectArray(Object)" returns a given Object[] as-is instead of throwing an IllegalArgumentException * added "containsWhitespace" method to StringUtils Package org.springframework.web * ExpressionEvaluationUtils catches any linkage error for the JSP 2.0 API, always falling back to the Jakarta JSTL * WebDataBinder explicitly suppresses field marker prefix values in case of "ignoreUnknownFields" switched off * Servlet/PortletRequestAttributes allow for accessing the session even after the request has been completed * RequestContextHolder supports standard ThreadLocal as well as InheritableThreadLocal * DispatcherServlet/Portlet do not expose LocaleContext/RequestAttributes as inheritable for child threads anymore * added "threadContextInheritable" property to DispatcherServlet and DispatcherPortlet, for explicit choice * factored out protected "buildLocaleContext" and "cleanupMultipart" methods in DispatcherServlet * made AbstractHandlerMapping's "getDefaultHandler()" method public * added public "getHandlerMap()" method to AbstractUrlHandlerMapping, exposing a read-only map of registered handlers * added public "getUrlMap()" method to SimpleUrlHandlerMapping, to allow for adding or overriding individual entries * added overloaded "suppressValidation" version with command object argument to BaseCommandController * added overloaded "isFormChangeRequest" version with command object argument to SimpleFormController * "spring:message" tag detects single expression argument that resolves to an array and processes it as arguments array * "form:errors" tag can now be used in a nested JSP outside the scope of a "form:form" tag * FreeMarkerView exposes all standard FreeMarker hash models now (including session and request parameters) * FreeMarkerView uses the ObjectWrapper as specified in the FreeMarker configuration, rather than always the default * FreeMarkerConfigurer always registers ClassTemplateLoader for its own package (rather than the package of a subclass) * AbstractJasperReportsSingleFormatView only sets parameter Map on JRExporter instance in case of actual parameters * added "boolean useWriter()" method to AbstractXsltView, allowing to prefer Writer access over OutputStream access * DispatcherPortlet exposes thread-bound request attributes for render requests as well (not just action requests) * DispatcherPortlet restores LocaleContextHolder/RequestContextHolder state (e.g. from surrounding DispatcherServlet) Changes in version 2.0 final (3.10.2006) ---------------------------------------- Package org.springframework.aop * dropped InvocationContextExposingAdvisorAutoProxyCreator base class Package org.springframework.beans * default property editors for primitive wrapper types (Boolean, Integer, etc) turn empty Strings into null values now * ConstructorArgumentValues supports configuration source objects per argument (e.g. keep track of original XML element) * ConfigurableBeanFactory's "setParentBeanFactory" throws IllegalStateException if already associated with a parent * added "getRegisteredScopeNames" and "getRegisteredScope" accessors to ConfigurableBeanFactory interface * added "getConversationId" method to Scope interface (exposing session id for session scope, null for request scope) * introduced BeanMetadataElement interface, giving access to config source object (implemented by BeanDefinition etc) * introduced BeanReference interface, implemented by RuntimeBeanReference as well as RuntimeBeanNameReference * dropped BeanReferenceFactoryBean; use the available alias mechanisms instead * reworked CustomScopeConfigurer to only support Scope instances as values for the "scopes" map * DefaultSingletonBeanRegistry keeps singleton beans in registration order (requires JDK 1.4 or Commons Collections) * AbstractBeanFactory does not explicitly register a given alias that is equal to the canonical bean name * dropped BeanDefinitionRegistryBuilder in favor of refined BeanDefinitionReaderUtils convenience methods * added "getInnerBeanDefinitions()" accessor to ComponentDefinition interface, exposing all relevant inner beans * added Resource argument to SourceExtractor interface, exposing the defining resource for the given source candidate * reworked type matching for FactoryBeans, avoiding repeated recreation/destruction through early "getObjectType" checks * "lookup-method" overrides no-arg method only, to let overloaded variants be implemented in a traditional fashion * added "setAllowRawInjectionDespiteWrapping" config method to DefaultListableBeanFactory, to enable Spring 1.2 behavior * added overloaded AbstractSingleBeanDefinitionParser's "doParse" template method with a ParserContext argument * moved ComponentDefinition, ReaderContext and support classes from "beans.factory.support" to "beans.factory.parsing" * reworked ReaderEventListener to take AliasDefinition/ImportDefinition argument for alias/import callback, respectively * revised BeanDefinitionParsingException to take a single Problem argument Package org.springframework.cache * EhCacheFactoryBean uses EHCache 1.2's extended Cache constructor to avoid EHCache warning (requires EHCache 1.2 now) Package org.springframework.core * AbstractLabeledEnum uses label as "toString()" representation, analogous to JDK 1.5 enums * StaticLabeledEnum and AbstractGenericLabeledEnum use the code as default label Package org.springframework.jdbc * JdbcTemplate uses "PreparedStatement.setObject(index, null)" for null values with unknown SQL type on Informix * turned visibility of "org.springframework.jdbc.core.StatementCreatorUtils" to public (again) Package org.springframework.jms * factored out protected "prepareSharedConnection" template method in AbstractMessageListenerContainer * AbstractMessageListenerContainer's "durableSubscriptionName" property defaults to the message listener class name * added "subscriptionDurable" flag to AbstractMessageListenerContainer (set this to "true" to for actual durability!) * added "defaultResponseQueueName" and "defaultResponseTopicName" properties to MessageListenerAdapter * added JMS invoker strategy for service-based remoting via JMS: JmsInvokerServiceExporter, JmsInvokerProxyFactoryBean Package org.springframework.jmx * MBeanExporter's MBean autodetection properly registers multiple beans even if their instances as equal * MBeanExporter's "registerManagedResource" registers a given MBean as-is (only wrapping a plain object as ModelMBean) Package org.springframework.mock * AbstractSingleSpringContextTest's "loadContextLocations()" declares Exception, to allow subclasses to throw exceptions * added MockMultipartFile, MockMultipartHttpServletRequest and MockMultipartActionRequest for testing multipart access Package org.springframework.orm * added overloaded query/insert/update/delete operations without parameter object to SqlMapClientOperations/Template * refined Hibernate3 support to detect Hibernate 3.2's FlushMode.MANUAL as well, while remaining compatible with 3.0/3.1 * factored out AbstractSessionFactoryBean base class from Hibernate3 LocalSessionFactoryBean * Hibernate3 LocalSessionFactoryBean registers filter definitions before loading any mapping files * ScopedBeanInterceptor for Hibernate3 exposes target class name as Hibernate entity name in case of a CGLIB proxy * changed the semantics of AbstractJpaVendorAdapter's "generateDdl" flag to create/update (instead of drop-and-recreate) Package org.springframework.transaction * clarified @Transactional semantics for JDK/CGLIB proxies as well as for AspectJ * AbstractPlatformTransactionManager properly propagates an "afterCommit" synchronization exception to the caller * JtaTransactionManager executes "afterCommit" callbacks even when synchronizing with an existing JTA transaction * factored out TransactionSynchronizationUtils and JtaAfterCompletionSynchronization helper classes * introduced CallbackPreferringPlatformTransactionManager interface, to be implemented by callback-loving PTM impls * TransactionTemplate/TransactionInterceptor automatically detect and use CallbackPreferringPlatformTransactionManager * fixed MethodMapTransactionAttributeSource to avoid unnecessary reinitialization of method map Package org.springframework.util * ClassUtils falls back to the system class loader if the thread context class loader is inaccessible * all class loading is done via "ClassLoader.loadClass(name)" rather than "Class.forName(name, true, ClassLoader)" Package org.springframework.validation * DataBinder matches all field names using their canonical name (for required, allowed and disallowed checks) Package org.springframework.web * clarified MultipartFile constract details * InternalResourceView correctly exports forward attributes on Servlet 2.3- (and preserves existing attributes on 2.4+) * OptionTag and ErrorsTag implement BodyTag interface directly to work around a bug in WebLogic Server 8.1's JSP engine * added "renderPhaseOnly" flag to Portlet WebRequestHandlerInterceptorAdapter, allowing to intercept action phase too * added "applyWebRequestInterceptorsToRenderPhaseOnly" flag to Portlet AbstractHandlerMapping * factored out AbstractMapBasedHandlerMapping base class from Parameter/PortletMode/PortletModeParameterHandlerMapping * renamed PortletModeParameterHandlerMapping's "allowDupParameters" property to "allowDuplicateParameters" Changes in version 2.0 RC4 (17.9.2006) -------------------------------------- General * renamed Spring 2.0 DTD to spring-beans-2.0.dtd, while keeping the Spring 1.2.x DTD as compatible spring-beans.dtd * renamed Spring 2.0 XSDs to spring-beans-2.0.xsd etc, to allow for proper versioning of future additions and changes * spring-beans-2.0.dtd/xsd does not support singleton="true"/"false" anymore. Use scope="singleton/"prototype" instead! * added "spring-agent.jar" to "dist/weavers" directory, containing the agent for Spring's InstrumentationLoadTimeWeaver * JPA support is fully tested against Oracle TopLink Essentials v2 b16 as well as Hibernate EntityManager 3.2.0 CR4 * removed ORM support for Apache OJB from the Spring core distribution. OJB support has been moved to Spring Modules. * declared all internal ThreadLocal variables as final (to avoid potential class reloading issues) Package org.springframework.aop * replaced all use of AOP Alliance AspectException with AopInvocationException/AopConfigException/IllegalStateException * Cglib2AopProxy exposes additional interfaces of a CGLIB-enhanced target bean on a CGLIB AOP proxy as well * fixed PointcutAdvisor support classes to avoid eager access to Advice and Pointcut from "hashCode()"/"toString()" * added "getTargetObject" method to ScopedObject interface, allowing for access to the raw object in the target scope * fixed AnnotationAwareAspectJAutoProxyCreator to lazily retrieve aspect singletons (only once a pointcut matches) * fixed @Configurable support to correctly identify the class name even for a CGLIB proxy Package org.springframework.beans * fixed BeanWrapperImpl to return a Collection/Map as-is if it is not accessible (e.g. because it is a scoped proxy) * fixed BeanWrapperImpl to always use a valid read-write type for a converted collection/map (never use original class) * fixed BeanWrapperImpl to properly resolve even nested generic Collections and Maps (List of Map, Map of List, etc) * renamed PropertyAccessExceptionsException to PropertyBatchUpdateException and explicitly declared when it is thrown * added "destroyBean" method to ConfigurableBeanFactory interface, for destroying a given instance based on a bean def * added support for destruction callbacks to Scope abstraction, driven by a BeanFactory's definition for a scoped bean * PropertyResourceConfigurer, CustomEditorConfigurer and CustomScopeConfigurer use highest Ordered precendence now * fixed FieldRetrievingFactoryBean to return "false" from "isSingleton()", since it reobtains the field value every time * FieldRetrievingFactoryBean and PropertyPathFactoryBean trim whitespace in all given names (even within the String) * fixed AbstractBeanFactory to accept re-registration of alias for same bean name (-> bean definition overriding) * reworked AbstractBeanFactory's alias handling to support local alias definitions for a bean in the parent BeanFactory * AbstractAutowireCapableBeanFactory only logs name and class of eagerly cached bean (does not trigger toString anymore) * AbstractAutowireCapableBeanFactory catches any exception from BeanPostProcessor and wraps it in BeanCreationException * DefaultListableBeanFactory's "preInstantiateSingletons" only fetches the FactoryBean instance (instead of its object) * reworked DefaultListableBeanFactory's beans-by-type lookup to ignore beans that have been overridden by an alias * inner bean definitions inherit the singleton status of their containing bean even if generated by namespace handler * fixed method overrides check to accept methods declared on interfaces as well * removed deprecated BeanFactoryBootstrap class Package org.springframework.cache * EhCacheManagerFactoryBean creates an independent CacheManager instance by default now (requires EHCache 1.2) * added "shared" flag to EhCacheManagerFactoryBean, allowing to explicitly ask for a shared CacheManager instance * refined EhCacheManagerFactoryBean to use pass in an InputStream instead of a URL for CacheManager initialization Package org.springframework.context * exposed AbstractApplicationContext's "registerShutdownHook()" method in ConfigurableApplicationContext interface * reverted AbstractApplicationContext to not inherit ClassLoader from parent context by default (as up until 2.0 RC1) * added appropriate "equals"/"hashCode" implementations to DefaultMessageSourceResolvable Package org.springframework.core * fixed SpringVersion to return null if the package is not determinable because of ClassLoader restrictions * ResourceArrayPropertyEditor always preserves order of resource entries, even on JDK 1.3 without Commons Collections * PathMatchingResourcePatternResolver ignores classpath roots that cannot be resolved as jar or in file system Package org.springframework.ejb * introduced EjbAccessException as replacement of AOP Alliance AspectException in local/remote SLSB invoker interceptors Package org.springframework.instrument * removed unused AbstractLoadTimeWeaver and AspectJWeavingTransformer classes * reworked ReflectiveLoadTimeWeaver to cache Method references and consider "getThrowawayClassLoader" as optional * fixed AbstractOverridingClassLoader to override "loadClass(name, resolve)" and correctly synchronize its variables * fixed and reworked AbstractOverridingClassLoader's facility for excluding class names * added OC4JLoadTimeWeaver for Oracle OC4J 10.1.3.1+ Package org.springframework.jca * SingleConnectionFactory's Connection proxy implements "equals" and "hashCode" based on proxy equality * factored out "resetConnection", "prepareConnection" and "closeConnection" methods in SingleConnectionFactory Package org.springframework.jdbc * refined DataSourceUtils to catch Throwable on "Connection.close()" * DataSourceUtils uses lower synchronization order for delegating handles (such as from TransactionAwareDataSourceProxy) * SingleConnectionDataSource's Connection proxy implements "equals" and "hashCode" based on proxy equality * factored out "resetConnection", "prepareConnection" and "closeConnection" methods in SingleConnectionDataSource * CommonsDbcpNativeJdbcExtractor supports original Commons DBCP as well as Tomcat 5.5's relocated version * revised JBossNativeJdbcExtractor to unwrap ResultSet even for WrappedResultSet subclasses (requires JBoss 3.2.4+ now) * DataSourceLookup throws DataSourceLookupFailureException instead of DataAccessResourceFailureException * added SingleDataSourceLookup, exposing a single given DataSource for any data source name * added AbstractInterruptibleBatchPreparedStatementSetter base class, with single "setValuesIfAvailable" callback method * added default SQL error codes for the Apache Derby database Package org.springframework.jms * SingleConnectionFactory's Connection proxy implements "equals" and "hashCode" based on proxy equality * SingleConnectionFactory's Connection proxy ignores "stop()" calls as well (not just "close()" calls) * factored out "resetConnection", "prepareConnection" and "closeConnection" methods in SingleConnectionFactory * added "exceptionListener" and "reconnectOnException" properties to SingleConnectionFactory * JmsTemplate and AbstractMessageListenerContainer call "stop()" on a Connection before closing it (if started before) * DefaultMessageListenerContainer does not block on startup until it can establish a shared Connection (if necessary) * added support for synchronized local JMS transactions (alongside some other main transaction) to JmsTemplate * added TransactionAwareConnectionFactoryProxy, including support for synchronized local JMS transactions Package org.springframework.orm * iBATIS support works correctly with "useTransactionAwareDataSource" and JTA transaction resume with subsequent access * reintroduced default SQLExceptionTranslator in JdoAccessor/JdoTransactionManager/LocalPersistenceManagerFactoryBean * HibernateTemplate exposes Session proxies that implement the SessionImplementor interface as well now (if possible) * exception translation for Hibernate3 turns PropertyValueException into Spring's DataIntegrityViolationException * exception translation for Hibernate3 keeps original JDBCException as root cause of Spring's HibernateJdbcException * added ScopedBeanInterceptor for Hibernate3, exposing the raw target class as entity name in case of a scoped proxy * LocalPersistenceManagerFactoryBean and JdoTemplate perform full exception translation even for reflective calls * expose underlying PersistenceProvider instance in EntityManagerFactoryInfo (if available) * added "persistenceProvider" property to AbstractEntityManagerFactoryBean, for using a shared PersistenceProvider * JpaVendorAdapter exposes a shared PersistenceProvider instance rather than just the PersistenceProvider class * added PersistenceUnitManager interface and DefaultPersistenceUnitManager implementation (in "jpa.persistenceunit") * added "persistenceUnitManager" bean property to LocalContainerEntityManagerFactoryBean (default is internal manager) * "dataSourceLookup"/"dataSources" configuration is now available on DefaultPersistenceUnitManager instead of LCEMFB * "postProcessPersistenceUnitInfo" hook method is now available on DefaultPersistenceUnitManager instead of LCEMFB * introduced PersistenceUnitPostProcessor interface, to be registered on DefaultPersistenceUnitManager or LCEMFB * introduced MutablePersistenceUnitInfo base class, to turn SpringPersistenceUnitInfo to package-protected again * PersistenceUnitReader searches for "classpath*:**/SCHEMA_NAME" last, and catches and logs any IOException thrown * added support for custom JPA properties to SharedEntityManagerBean/JpaTransactionManager/JpaInterceptor/JpaTemplate * added support for custom JPA properties to OpenEntityManagerInViewInterceptor * PersistenceAnnotationBeanPostProcessor supports @PersistenceContext's "properties", passed into "createEntityManager" * PersistenceAnnotationBeanPostProcessor does not cache EntityManagerFactory instances anymore, to allow for new EMFs * PersistenceAnnotationBeanPostProcessor throws IllegalStateException instead of NoSuchBeanDefinitionException Package org.springframework.mock * added support for attributes which implement the Servlet 2.3 HttpSessionBindingListener interface to MockHttpSession Package org.springframework.remoting * added service URL check to UrlBasedRemoteAccessor, in the form of an InitializingBean implementation * refined cache synchronization in (Jndi)RmiClientInterceptor and JaxRpcPortClientInterceptor * reworked RmiClientInterceptor to throw RemoteLookupFailureException instead of MalformedURLException/RemoteException * reworked Hessian/BurlapClientInterceptor to throw RemoteLookupFailureException instead of MalformedURLException * Hessian/BurlapClientInterceptor configure a Hessian/BurlapProxyFactory directly (dropped CauchoRemoteAccessor) * added "serializerFactory" and "sendCollectionType" properties to HessianClientInterceptor/ProxyFactoryBean * added "serializerFactory" property to HessianServiceExporter, applied to HessianInput/Output objects * HessianServiceExporter is compatible with the Hessian 2 protocol (Hessian version 3.0.20+) as well as classic Hessian Package org.springframework.scheduling * Spring's Quartz support requires Quartz 1.5 or higher now * added support for Quartz 1.5 JobFactory to SchedulerFactoryBean, through "jobFactory" bean property * SchedulerFactoryBean uses AdaptableJobFactory as default, which also supports Runnables as job class * added SpringBeanJobFactory as subclass of AdaptableJobFactory, as JobFactory replacement for QuartzJobBean * JobDetailBean allows any job class to be specified, to allow a JobFactory to adapt any class to the Job interface * added "jobDataAsMap" property to Simple/CronTriggerBean, supporting the Quartz 1.5 notion of trigger-specific job data * MethodInvokingJobDetailFactoryBean always creates durable JobDetails (just like it also sets the volatile flag) Package org.springframework.scripting * fixed BshScriptFactory to correctly handle void, null, and primitive return values * fixed JRubyScriptFactory to handle "toString()" invocations locally on the JRuby object proxy Package org.springframework.test * AbstractSpringContextTests calls ConfigurableApplicationContext's "registerShutdownHook()" for each context instance * factored out concrete loading of a single context from specified config locations to AbstractSingleSpringContextTests * restricted visibilities and stronger use of final in AbstractDependencyInjectionSpringContextTests Package org.springframework.transaction * added "afterCommit" callback to TransactionSynchronization interface * fixed TransactionAttributeSourceAdvisor to avoid potential NPE in TransactionAttributeSourcePointcut's "hashCode" Package org.springframework.validation * added "getPropertyEditorRegistry" method to BindingResult interface, for re-registering custom editors * AbstractBindingResult's "addAllErrors" only accepts Errors instance with same object name * added appropriate "toString" implementation to AbstractBindingResult * added appropriate "equals"/"hashCode" implementations to AbstractBindingResult and BindException * added appropriate "equals"/"hashCode" implementations to ObjectError and FieldError Package org.springframework.web * ExpressionEvaluationUtils falls back to Jakarta JSTL if JSP 2.0 ExpressionEvaluator API present but not implemented * added support for attribute destruction callbacks to RequestAttributes abstraction + Servlet/PortletRequestAttributes * introduced "requestCompleted()" method in AbstractRequestAttributes base class for Servlet/PortletRequestAttributes * adapted TagUtils to accept subclassed parent tag as expected ancestor too (e.g. OptionTag within subclassed SelectTag) * AbstractJasperReportsView converts exporter parameter values "true"/"false" to Boolean.TRUE/FALSE * removed deprecated FormatHelper from XSLT view package * fixed various JSP form tag issues Changes in version 2.0 RC3 (10.8.2006) -------------------------------------- General * spring.jar does not include Portlet support anymore (add spring-portlet.jar to your classpath if needed) Package org.springframework.aop * factored out AbstractGenericPointcutAdvisor (with a configurable Advice) as subclass of AbstractPointcutAdvisor * fixed AbstractAdvisorAutoProxyCreator to ignore Advisors for which "getBean" throws a BeanCurrentlyInCreationException * fixed AnnotationAwareAspectJAutoProxyCreator to explicitly ignore FactoryBeans when looking for aspect beans * reworked AspectJ auto-proxy creation to avoid the creation of unnecessary proxies * renamed ScopedObject's "remove" method to "removeFromScope", to avoid conflicts with methods on the target class Package org.springframework.beans * added overloaded "setPropertyValues" variant with additional "ignoreInvalidFields" flag to PropertyAccessor * fixed BeanWrapperImpl to properly catch and wrap conversion failures for map keys/values in TypeMismatchExceptions * introduced TypeConverter interface, implemented by BeanWrapperImpl, plus separate SimpleTypeConverter implementation * refined PropertyAccessExceptionsException to show nested details even when wrapped in a standard JDK exception * reworked ArgumentConvertingMethodInvoker to use a TypeConverter and allow the converter to be accessed/overridden * BeanFactoryUtils returns bean names in order of definition even for merged name arrays (in case of ancestor factories) * redefined BeanFactoryUtils' "countBeans/beanNamesIncludingAncestors" to build on "getBeanNamesOfType(Object.class)" * reworked InstantiationAwareBeanPostProcessor's "postProcessPropertyValues" method to take a PropertyDescriptor array * RequiredAnnotationBeanPostProcessor explicitly ignores special setter methods (such as "setBeanName"/"setBeanFactory") * added "copyConfigurationFrom" method to ConfigurableBeanFactory, allowing to create a factory with same configuration * exposed "getScope" and "setScope" methods on BeanDefinition interface, allowing a post-processor to override the scope * DefaultSingletonBeanRegistry disallows the creation (or recreation) of singletons during "destroySingletons()" phase * fixed AbstractBeanFactory to only invoke BeanPostProcessor for objects returned from FactoryBeans if non-null * fixed AbstractBeanFactory to throw BeanCurrentlyInCreationException on null from non-fully-initialized FactoryBean * AbstractBeanFactory's "getType" catches BeanCreationExceptions for a FactoryBean, treating it as "type unknown" * AbstractBeanFactory catches an exception thrown from a FactoryBean's "getObjectType", treating it as "type unknown" * AbstractAutowireCapableBeanFactory detects whether it injected raw instances of beans that eventually got wrapped * refined AbstractAutowireCapableBeanFactory to only adapt inner bean names for uniqueness in case of a singleton * refined AbstractAutowireCapableBeanFactory to reject an inner bean marked as singleton contained in a non-singleton * DefaultListableBeanFactory's non-eager lookup by type finds matches for lazy-init beans as long as class is loadable * added "setAllowEagerClassLoading" method to DefaultListableBeanFactory, to allow for turning off eager class loading * restored Spring 1.2 compatibility for default-lazy-init="true", with respect to detection of special beans by type * "idref" tag in XML bean definitions gets turned into a RuntimeBeanNameReference, which gets validated on bean creation * XML definitions for inner beans receive a default scope based on their containing bean (prototype for a non-singleton) * DefaultBeanDefinitionDocumentReader does not accept bean definitions with both "scope" and "singleton" values anymore Package org.springframework.context * added "isActive()" method to the ConfigurableApplicationContext interface * AbstractRefreshableApplicationContext disallows access to underlying BeanFactory after a "close()" call * avoid AbstractRefreshableApplicationContext deadlock in case of BeanFactory access in a multi-threaded destroy method Package org.springframework.core * fixed PathMatchingResourcePatternResolver to prevent eternal recursion in case of invalid prefix with pattern symbols Package org.springframework.dao * factored out reusable PersistenceExceptionTranslationInterceptor from PersistenceExceptionTranslationAdvisor Package org.springframework.jdbc * worked around "oracle.sql.DATE" problem on certain Oracle driver versions, extracting it as timestamp when appropriate * check for ResultSetSupportingSqlParameter superclass instead of SqlOutParameter and SqlReturnResultSet subclasses * factored out Spring/JtaLobCreatorSynchronization classes from Hibernate AbstractLobType to "jdbc.support.lob" package Package org.springframework.jms * introduced CachingDestinationResolver interface, implemented by JndiDestinationResolver (allowing to clear the cache) * JmsTransactionManager starts the transactional Session's Connection early (at transaction begin) rather than on demand * optimized JmsTemplate's resource handling to reuse the obtained JMS Connection/Session within a JTA transaction * added "clientId" property to SingleConnectionFactory(102), for assigning a client id to the underlying Connection * added "clientId" property to AbstractMessageListenerContainer, for assigning a client id to the underlying Connection * AbstractMessageListenerContainer supports individual Connections per listener as alternative to a shared Connection * DefaultMessageListenerContainer obtains all JMS resources fresh by default in case of "transactionManager" specified * added "cacheLevel"/"cacheLevelName" property to DefaultMessageListenerContainer, for overriding the default caching * DefaultMessageListenerContainer is able to recover from a broken Connection (both with and without cached Connection) * DefaultMessageListenerContainer is able to recover from a broken Destination if obtained via JndiDestinationResolver * DefaultMessageListenerContainer waits until all listener tasks have completed before returning from "destroy" * added "taskExecutor" property to SimpleMessageListenerContainer, allowing to execute listener in different thread * added protected "buildListenerArguments" template method to MessageListenerAdapter, allowing for multiple arguments Package org.springframework.orm * refined iBATIS SqlMapClientTemplate to allow for nested calls to same SqlMapSession (checking "getCurrentConnection") * reworked Hibernate JTA synch to expose beforeCompletion exceptions to the caller (via SpringJtaSynchronizationAdapter) * updated TopLink API jar to be fully compatible with the official TopLink 10.1.3 release jar (can be replaced with it) * Hibernate3 and TopLink LocalSessionFactoryBeans implement the PersistenceExceptionTranslator interface now * reworked Hibernate3 and TopLink exception translation to only apply a SQLExceptionTranslator if explicitly specified * JDO LocalPersistenceManagerFactoryBean implements the PersistenceExceptionTranslator interface now * DefaultJdoDialect only applies a SQLExceptionTranslator if explicitly specified (rely on default JDO translation else) * removed warning for read-only from JdoTransactionManager/JpaTransactionManager, since a vendor dialect may support it * factored out overridable "createEntityManager" template methods in OpenEntityManagerInViewFilter/Interceptor * EntityManagerFactoryInfo interface does not extend PersistenceExceptionTranslator anymore (only JpaDialect does) * SpringPersistenceUnitInfo is public to allow for post-processing in LocalContainerEntityManagerFactoryBean subclass * added "determinePersistenceUnitInfo/postProcessPersistenceUnitInfo" methods to LocalContainerEntityManagerFactoryBean * reworked OpenSession/PersistenceManager/EntityManagerInViewInterceptor to build on WebRequestInterceptor abstraction * dropped PortletOpenSession/PersistenceManager/EntityManagerInViewInterceptor in favor of WebRequestInterceptor model Package org.springframework.mock * MockHttpServletRequest handles HTTP header names as case-insensitive Package org.springframework.remoting * added "registryClientSocketFactory" bean property to RmiClientInterceptor/RmiProxyFactoryBean * added dedicated "prepare()" method to JndiRmiServiceExporter Package org.springframework.scheduling * renamed SchedulingTaskExecutor's "isShortLivedPreferred" method to "prefersShortLivedTasks" Package org.springframework.scripting * ScriptFactoryPostProcessor supports all callbacks that containing BeanFactory supports (e.g. ApplicationContextAware) Package org.springframework.test * AbstractTransactionalSpringContextTests only tries to end transaction on "tearDown" if the transaction is still active Package org.springframework.transaction * fixed AbstractPlatformTransactionManager to not invoke commit synchronization in case of propagated rollback-only flag * added SpringJtaSynchronizationAdapter, exposing JTA Synchronization ifc on top of a Spring TransactionSynchronization * added "timeout" attribute to Transactional annotation, allowing to specify a timeout in seconds within the annotation Package org.springframework.util * optimized "ObjectUtils.nullSafeToString" implementation to return a given String right away Package org.springframework.validation * added "ignoreInvalidFields" flag to DataBinder, allowing to ignore inaccessible fields (null value in nested path) Package org.springframework.web * redefined Servlet/PortletRequestUtils to treat empty parameter values as valid for Strings ("") and booleans (false) * moved RequestScope/SessionScope and RequestContextListener from "web.context.scope" to "web.context.request" * added WebRequest abstraction, with ServletWebRequest and PortletWebRequest implementations * added WebRequestInterceptor interface, for generic request interceptors (independent of Servlet/Portlet) * added support for WebRequestInterceptors to Servlet/Portlet MVC HandlerMappings (through "interceptors" property) * renamed PortletBean to GenericPortletBean * HttpServletBean/GenericPortletBean override "getXXXXletName"/"getXXXXletContext" to return null when no config set yet * added "defaultLocale" property to CookieLocaleResolver and SessionLocaleResolver, for fallback to an explicit locale Changes in version 2.0 RC2 (6.7.2006) ------------------------------------- General * added showcases to "samples" directory * various documentation clarifications * restored compatibility with IBM JDK 1.3 (with respect to referring to constants defined in implemented interfaces) Package org.springframework.aop * JdkDynamicAopProxy delegates "equals"/"hashCode" calls to target if "equals"/"hashCode" is defined on proxy interface * Advisors used in combination with an advisor auto-proxy creator can now use beans which get adviced themselves * moved AbstractAutoProxyCreator's "shouldSkip" check from "isInfrastructureClass" to "postProcessAfterInitialization" * reworked AbstractAdvisorAutoProxyCreator to avoid fetching of all candidate Advisors on startup * AbstractAdvisorAutoProxyCreator performs BeanFactory-based prototype cycle check instead of control flow check Package org.springframework.beans * factored out SingletonBeanRegistry interface from ConfigurableBeanFactory interface * factored out DefaultSingletonBeanRegistry base class from AbstractBeanFactory * added "isCurrentlyInCreation" method to ConfigurableBeanFactory interface * reworked AbstractBeanFactory to allow for prototype cycle check for current thread * fixed AbstractBeanFactory's "isBeanNameUsed" to correctly synchronize access to "dependentBeanMap" * AbstractAutowireCapableBeanFactory creates "depends-on" beans even before resolving a bean's class * AbstractAutowireCapableBeanFactory does not apply bean post-processors to "synthetic" beans * AbstractAutowireCapableBeanFactory accepts null values returned from BeanPostProcessors * added "synthetic" flag to AbstractBeanDefinition, for marking beans as internal infrastructure beans * XmlBeanDefinitionReader uses given ResourceLoader/ApplicationContext's ClassLoader for schema resolution * MethodInvokingFactoryBean returns "void.class" instead of "VoidType.class" for void methods Package org.springframework.context * AbstractApplicationContext uses the ClassLoader of its parent ApplicationContext (if any) as default * turned ApplicationObjectSupport's "getApplicationContext()" method from public to protected (for consistency) Package org.springframework.core * NestedXxxException classes build nicer messages in case of root cause with no base exception message * added "getClassLoader()" method to ResourceLoader, exposing the ClassLoader for direct access * adapted PathMatchingResourcePatternResolver to always use the ResourceLoader's ClassLoader * added "getResourcePatternResolver(ResourceLoader)" utility method to ResourcePatternUtils Package org.springframework.jdbc * reworked JDBC 3.0 savepoint support to use self-generated savepoint names (to avoid unnamed savepoints on IBM DB2) * removed "S0" from default SQL state list in SQLStateSQLExceptionTranslator: it does not mean bad SQL on MS SQL Server * SqlQuery and SqlUpdate correctly handle a named parameter with a list of values now Package org.springframework.jms * added support for durable subscriptions to message listener containers, driven by "durableSubscriptionName" property Package org.springframework.jmx * MBeanRegistrationSupport only logs a warning (no error) when an MBean does not exist anymore when trying to unregister Package org.springframework.orm * LocalContainerEntityManagerFactoryBean detects and reads all "META-INF/persistence.xml" files on the class path * LocalContainerEntityManagerFactoryBean determines persistence unit root URL based on each "persistence.xml" location * JdoTransactionManager uses JDO 2.0's rollback-only facility if available * JpaTransactionManager uses JPA's rollback-only facility now, for better integration with the persistence provider * JpaTransactionManager throws UnexpectedRollbackException in case of JPA RollbackException thrown from commit * refined JPA exception translation to throw EmptyResultDataAccessException in case of JPA NoResultException * refined JPA exception translation to throw IncorrectResultSizeDataAccessException in case of JPA NonUniqueResult * refined JPA exception translation to throw DataIntegrityViolationException in case of JPA EntityExistsException * refined JPA exception translation to throw InvalidDataAccessResourceUsageException in case of JPA TransactionRequired * refined Hib exception translation to throw InvalidDataAccessApiUsageException in case of Hibernate ObjectDeleted * refined Hib exception translation to throw IncorrectResultSizeDataAccessException in case of Hibernate NonUniqueResult Package org.springframework.remoting * JaxRpcPortClientInterceptor/JaxRpcPortProxyFactoryBean allow for direct "customPropertyMap[myKey]" access Package org.springframework.scheduling * Quartz SchedulerFactoryBean uses given "nonTransactionalDataSource" as default DataSource if no "dataSource" specified Package org.springframework.test * AbstractTransactionalSpringContextTests properly ends a started transaction early if "onSetupInTransaction" fails Package org.springframework.transaction * JtaTransactionManager explicitly only calls "UserTransaction.setRollbackOnly()" if the transaction is still active Package org.springframework.validation * clarified that "Errors.reject" always registers a global error for the entire target object * "Errors.rejectValue" now accepts an empty field name to indicate the current object itself rather than a field of it Package org.springframework.web * added/moved constants for all Servlet spec include/forward request attributes to WebUtils * added "getWebApplicationContext"/"getAutowireMode"/"getDependencyCheck" methods to Autowiring(Tiles)RequestProcessor * DispatcherServlet logs its page-not-found warnings with the actual lookup URL even for import requests * InternalResourceView exposes all forward request attributes (delegating to "WebUtils.exposeForwardRequestAttributes") * RequestContext's "getContextPath()" always exposes the context path for the originating request now * added "getQueryString" method to RequestContext, exposing query string for originating request (even after forward) * fixed various JSP form tag issues Changes in version 2.0 RC1 (20.6.2006) -------------------------------------- General * completed reference documentation * fixed various documentation issues * spring.jar includes all standard modules except for the Hibernate2 support (which has been superseded by Hibernate3) * basic download only contains reference PDF: no HTML variant and API docs anymore (only in -with-dependencies now!) Package org.springframework.aop * fixed AspectJAutoProxyCreator to avoid NPE in case of abstract beans without bean class specified Package org.springframework.beans * FactoryBeans are allowed to return null values now, with FactoryBeanNotInitializedException to be thrown by themselves * fixed AbstractBeanFactory's "getType" to avoid NPE in case of a bean definition without bean class * AbstractBeanFactory uses inverse order of bean instantiation for shutdown even without dependency relationships * fixed DefaultListableBeanFactory to not call "FactoryBean.getObject()" for prototype if bean class not resolved yet * avoid ClassNotFoundException in case of explicit type specified on "value" tag * resolve target type of a TypedStringValue lazily, consistent with the handling of bean classes * moved parsing-related support classes from "beans.factory"/"beans.factory.support" to "beans.factory.parsing" Package org.springframework.core * StaticLabeledEnum offers its "readResolve" method with protected visibility, to kick in for subclasses as well Package org.springframework.ejb * fixed AbstractSlsbInvokerInterceptor to reobtain createMethod in case of cacheHome="false"/lookupHomeOnStartup="true" Package org.springframework.jms * added "cacheSessions" flag to DefaultMessageListenerContainer, to be turned off for reobtaining Sessions per receive * added "handleListenerSetupFailure" callback to DefaultMessageListenerContainer, a sibling of "handleListenerException" * DefaultMessageListenerContainer invokes a specified JMS ExceptionListener for listener setup failures as well Package org.springframework.orm * removed LocalSessionFactoryBean's early "buildMappings" call to avoid side effects with AnnotationSessionFactoryBean * HibernateTransactionManager explicitly disconnects a pre-bound Session after a transaction (on Hibernate 3.1+) * Hibernate Open-Session-In-View's deferred close mode always switches its Sessions to FlushMode.NEVER until closing * refined HibernateTemplate to never register a Session for deferred close in case of "alwaysUseNewSession"=true * removed special Session reconnection check for Hibernate 3.1 RC1 * renamed ContainerEntityManagerFactoryBean to "LocalContainerEntityManagerFactoryBean" * fixed LocalContainerEntityManagerFactoryBean to always look for "META-INF/persistence.xml" in class path by default * JpaTransactionManager autodetects the JDBC DataSource of the target EntityManagerFactory Package org.springframework.samples * added JPA support to PetClinic: EntityManagerClinic and JpaTemplateClinic, with TopLink Essentials as default provider Package org.springframework.scheduling * added "jobListenerNames" bean property to MethodInvokingJobDetailFactoryBean Package org.springframework.scripting * fixed "spring-lang.xsd" to allow for multiple nested property elements Package org.springframework.web * fixed (the deprecated) BindUtils to not call "ValidatorUtils.invokeValidator" if no Validator given * fixed Servlet/PortletRequestAttributes to correctly update accessed attributes * turned WebContentGenerator's method constants public again, for calling "setSupportedMethods" in subclasses * FrameworkPortlet now catches all RuntimeException/Errors and rethrows them as PortletException * PortletContentGenerator response preparation operates on RenderRequest and RenderResponse only * changed Portlet HandlerInterceptor interface to have explicit callback methods for action/render requests * Portlet HandlerInterceptorAdapter allows to adapt the specific action/render callback methods to general callbacks * Portlet OpenXxxInViewInterceptors just wrap the render request, not the action request anymore * VelocityView and FreeMarkerView do not override content type previously set on HTTP response anymore (on Servlet 2.4+) * moved content type handling from VelocityView and FreeMarkerView up to AbstractTemplateView * fixed various JSP form tag issues Changes in version 2.0 M5 (1.6.2006) ------------------------------------ General * spring.jar is now all-encompassing, including all modules (with the exception of mock and aspects) * spring-aop.jar does not contain AOP Alliance interfaces (in contrast to spring.jar); explicitly add aopalliance.jar Package org.springframework.aop * reworked support for scoped proxies to build on scoping support in core BeanFactory * removed incomplete support for ScopedObject handles and persistent scopes * removed deprecated AttributesPooling/Prototype/ThreadLocalTargetSourceCreator * removed unused Class argument from ParameterNameDiscoverer's "getParameterNames(Method)" * reworked ProxyFactoryBean's "setProxyInterfaces" method from String array to Class array * reworked ProxyFactoryBean to use the ClassLoader passed in through BeanClassLoaderAware * factored out AbstractSingletonProxyFactoryBean from TransactionProxyFactoryBean Package org.springframework.beans * introduced lazy loading (and lazy validation) of bean classes in standard bean factories and bean definition readers * redefined ListableBeanFactory's "includeFactoryBeans" flag for "getBean(Name)sOfType" into "allowEagerInit" * introduced BeanClassLoaderAware interface, for passing the factory's class loader to beans that resolve class names * reworked all FactoryBeans that resolve class names to leverage the BeanClassLoaderAware mechanism * PropertyPlaceholderConfigurer is able to resolve placeholders in lazily loaded bean class names * added support for PropertyEditorRegistrars to ConfigurableBeanFactory, for non-synchronized usage of custom editors * CustomEditorConfigurer supports PropertyEditorRegistrars, to be applied to its containing BeanFactory * reworked ConfigurableBeanFactoryUtils into ResourceEditorRegistrar * added "postProcessPropertyValues" callback method to InstantiationAwareBeanPostProcessor interface * reworked RequiredBeanFactoryPostProcessor into RequiredAnnotationBeanPostProcessor, properly handling bean inheritance * added scoping support to core BeanFactory, for creating raw target beans in arbitrary scopes * added "scope" attribute at bean level to XML bean definition format, superseding singleton="true"/"false" * renamed XmlBeanDefinitionReader's (Default)XmlBeanDefinitionParser SPI to (Default)BeanDefinitionDocumentReader * renamed XmlBeanDefinitionParserHelper to BeanDefinitionParserDelegate * re-introduced Spring 1.2 XmlBeanDefinitionParser SPI for backwards compatibility in case of "parserClass" specified Package org.springframework.context * synchronized AbstractApplicationContext's "refresh()" method, for hot refreshing in concurrent environments Package org.springframework.core * renamed GenericsHelper to GenericCollectionTypeResolver, more clearly reflecting its actual role * AnnotationUtils discovers annotations inherited via bridge methods now, through the new BridgeMethodResolver Package org.springframework.dao * added generic PersistenceExceptionTranslator mechanism, supported by the JpaDialect abstraction for JPA providers * added PersistenceExceptionTranslationPostProcessor, for automatic translation to DataAccessExceptions Package org.springframework.instrument * introduced class instrumentation support based on standard ClassFileTransformers (used by JPA SPI support) * introduced LoadTimeWeaver abstraction for instrumentation-aware ClassLoaders plus throwaway ClassLoader support Package org.springframework.jdbc * refined default SQL error codes for DB2 and HSQLDB * removed deprecated special check for DB2 error codes - always use "DB2*" as database product name for DB2 * reworked SimpleJdbcDaoSupport/NamedParameterJdbcDaoSupport initialization to work without afterPropertiesSet as well Package org.springframework.orm * Hibernate3 LocalSessionFactoryBean explicitly calls "buildMappings()" to prepare Configuration metadata for subclasses * fixed JpaTransactionManager to not cause an NPE when the creation of a transactional EntityManager raises an exception * fixed JpaInterceptor to actually bind a new EntityManager to the thread again (worked in M3, didn't work in M4) * fixed EntityManagerFactoryUtils's "convertJpaAccessException" to always return rather than throw DataAccessExceptions * added full support for JPA SPI, in the form of a ContainerEntityManagerFactoryBean with LoadTimeWeaver support * added JpaVendorAdapter abstraction, with out-of-the-box TopLinkJpaVendorAdapter and HibernateJpaVendorAdapter * added PersistenceAnnotationPostProcessor, processing EJB3-style @PersistenceUnit and @PersistenceContext annotations Package org.springframework.test * added support classes for annotation-based tests in general and for JPA-based tests in particular Package org.springframework.transaction * added "failEarlyOnGlobalRollbackOnly" flag to AbstractPlatformTransactionManager, for consistent fail-early behavior Package org.springframework.util * "ClassUtils.isPresent" logs exception message only instead of full stacktrace for classes that haven't been found * introduced PatternMatchUtils, for unified matching of Spring's typical "xxx*", "*xxx" and "*xxx*" pattern styles Package org.springframework.validation * reworked ValidationUtils to not accept a null Validator for "invokeValidator" anymore * added "setDisallowedFields" method to DataBinder, for specifying disallowed fields instead of allowed fields Package org.springframework.web * reworked mvc RequestHandler interface into HttpRequestHandler in root web package, to minimize module dependencies * reworked RequestMethodNotSupportedException into HttpRequestMethodNotSupportedException in root web package * reworked SessionRequiredException into HttpSessionRequiredException and PortletSessionRequiredException * added HttpRequestHandlerServlet to "web.context.support" package, for exposing a single HttpRequestHandler bean * dropped "getCause()" method from NestedServletException, to avoid conflicts with JDK-1.4-based ServletException class * added support for request and session scopes to all WebApplicationContexts * moved StaticPortletApplicationContext from test tree over to main source tree * fixed SimpleMappingExceptionResolver to use local "exceptionMappings" reference * factored out reusable "prepareBinder" method in BaseCommandController, for easier overriding of "createBinder" * InternalResourceView exposes Servlet 2.4 forward request attributes even for Servlet 2.3- * added "getOriginatingRequestUri" method to UrlPathHelper, detecting the Servlet 2.4 request URI attribute in a forward * refined JSP form tag library Changes in version 2.0 M4 (23.4.2006) ------------------------------------- General * included "tiger" and "aspectj" source trees in source build (spring-src.zip) * included spring-src.zip in both release distributions as a convenience * basic distribution doesn't include build script and exploded source trees anymore Package org.springframework.aop * fixed Cglib2AopProxy to register an explicitly given ClassLoader with the CGLIB Enhancer * deprecated Commons Attributes based TargetSourceCreators (PoolingAttribute, PrototypeAttribute, ThreadLocalAttribute) * fixed CustomizableTraceInterceptor to expose the actual invocation time for exception messages * added "trackAllInvocations" flag to JamonPerformanceMonitorInterceptor, for gathering statistics without logging * auto-proxying works for objects created by FactoryBeans as well (rather than just on FactoryBean instances themselves) * BeanNameAutoProxyCreator always proxies exposed objects, with "&beanName" syntax for proxying FactoryBean instances * renamed "aspectj.autoproxy.AspectJAutoProxyCreator" to "aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" Package org.springframework.beans * BeanUtils throws explicit BeanInstantiationException in case of bean instantiation failure * deprecated BeanUtils's "isAssignable" methods in favor of new "isAssignable"/"isAssignableValue" methods on ClassUtils * fixed BeanWrapperImpl to convert a null input for an array type to a null value rather than an array with null element * fixed BeanWrapperImpl to apply property-specific editors to elements even for collections without generic type * refined BeanWrapperImpl to apply map key conversion on property access as well, not just on property setting * refined BeanWrapperImpl to inject original collections as far as possible (i.e. unless element conversion necessary) * refined BeanWrapperImpl to correctly detect element type of collections with parameterization in superclass/interface * BeanWrapperImpl does not register a StringArrayPropertyEditor by default anymore * fixed BeanWrapperImpl to convert a ManagedProperties instance into a plain Properties instance before applying it * fixed BeanWrapperImpl to fall back to approximate collection/map type if it cannot reinstantiate given collection/map * fixed BeanArrayPropertyEditor to translate null value to null byte array * added CharArrayPropertyEditor to translate String value into char array * CharacterEditor supports unicode specification passed in as literal String, for example "\u00F6" * refined FileEditor to treat absolute file paths as straight files (no ResourceLoader), for Spring 1.2 compatibility * PropertyPlaceholderConfigurer catches and logs SecurityException on system property access, continuing resolution * FieldRetrievingFactoryBean is able to access non-public fields as well * added "propertiesArray" bean property to PropertiesFactoryBean, for merging multiple local Properties instances * fixed AbstractBeanFactory to avoid potential deadlock on singleton destruction with concurrent singleton creation * AbstractBeanFactory always registers inner beans with a unique name, adapting overlapping names accordingly * AbstractBeanFactory caches objects returned from "FactoryBean.getObject()" now, in case of a singleton object * BeanPostProcessor's "postProcessAfterInitialization" gets applied to objects created by FactoryBeans as well * BeanPostProcessor's "postProcessAfterInitialization" gets applied after "postProcessBeforeInstantiation" as well * fixed DefaultListableBeanFactory to not preinstantiate bean definition if explicit singleton object already registered * added "loadBeanDefinitions(String[] locations)" method to BeanDefinitionReader and AbstractBeanDefinitionReader * added Requiered annotation and RequiredBeanFactoryPostProcessor, allowing to enforce required bean properties Package org.springframework.context * refined AbstractMessageSource to resolve arguments eagerly, for message defined in parent and msg arg defined in child * added (String[], Class) constructors to ClassPathXmlApplicationContext, allowing to load relative to a specified class Package org.springframework.core * refined NestedXxxException to be serialization-compatible with Spring 1.2 * refined NestedXxxException to properly handle null message in root cause, through using the cause's "toString()" * fixed FileSystemResource/UrlResource to retain leading "../" parts in paths, building correct relative paths for them * ResourceEditor resolves placeholders in resource locations against system environment variables as well Package org.springframework.dao * introduced PermissionDeniedDataAccessException, thrown for valid operation that was rejected due to lack of permission Package org.springframework.jdbc * added "permissionDeniedCodes" category to SQLErrorCodes, with default code 229 for MS SQL Server in sql-error-codes * JdbcTemplate's "queryForString"/"queryForInt"/etc methods correctly detect incorrect result sizes even for null values * turned JdbcTemplate's "query(PreparedStatementCreator,PreparedStatementSetter,ResultSetExtractor rse)" method public * JdbcTemplate does not check static SQL for bind parameters anymore, to avoid overhead of double parsing * improved JdbcTemplate's logging of ignored SQLWarnings, including SQL state and error code in the log output * refined NativeJdbcExtractorAdapter to retry with DatabaseMetaData Connection if extraction failed (for Hibernate 3.1) * added NamedParameterJdbcTemplate which provides named parameters support for query and update functionality * added "allowsUnusedParameters()" and "checkCompiled()" methods to RdbmsOperation, for better customizing in subclasses * refined StoredProcedure to accept unused entries in given parameter Maps by default * added named parameters support to SqlQuery/SqlUpdate hierarchy of classes Package org.springframework.jms * AbstractMessageListenerContainer prefers SessionAwareMessageListener over MessageListener (if both are implemented) * added "exceptionListener" property to AbstractMessageListenerContainer, accepting a standard JMS ExceptionListener * added "handleListenerException" template method to AbstractMessageListenerContainer, by default logging at error level * fixed DefaultMessageListenerContainer to properly use separate invokers per thread, for actually concurrent Sessions * fixed ServerSessionMessageListenerContainer(102) to use "createSession(Connection)" method to avoid JMS 1.1 dependency * added MessageListenerAdapter(102), delegating to listener methods that operate on content types (String, byte array) Package org.springframework.jmx * reworked NotificationListenerBean to avoid overloaded bean property setters for "mappedObjectNames" Package org.springframework.mail * refined JavaMailSenderImpl to use "Session.getInstance(properties, null)", for compatibility with (old) JavaMail 1.1 Package org.springframework.mock * added overloaded constructors to MockFilterConfig, using a MockServletContext instead of a ServletContext argument Package org.springframework.orm * updated JDO API 2.0 jar to 2.0 RC1 from the Apache JDO project * updated JPA API 1.0 jar to build 40 from the GlassFish project * fixed LocalSessionFactoryBean's "updateDatabaseSchema" to declare the correct exception (DataAccessException) * fixed BlobStringType for Hibernate2/3 to correctly handle SQL NULL * refined JDO PersistenceManagerFactoryUtils to explicitly suspend pre-bound PM in the course of transaction suspension * refined JPA EntityManagerFactoryUtils to explicitly suspend pre-bound EM in the course of transaction suspension * removed support for obsolete "EntityManagerFactory.getEntityManager()" method from LocalEntityManagerFactoryBean * added "entityManagerInterface" property to SharedEntityManagerAdapter, for exposing a vendor-extended interface * adapted OpenEntityManagerInViewFilter/Interceptor to not specify obsolete PersistenceContextType.EXTENDED anymore * fixed JpaDaoSupport's "setEntityManager" method to accept an EntityManager instead of an EntityManagerFactory * removed "getEntityManager()"/"getEntityManagerFactory()" accessor methods from JpaDaoSupport * removed "allowCreate" flag from JpaTemplate, always allowing creation (analogous to shared EntityManager) * added "exceptionConversionEnabled" flag to HibernateInterceptor, TopLinkInterceptor, JdoInterceptor, JpaInterceptor Package org.springframework.remoting * HTTP invoker and RMI invoker fill the client-side portion of the stack trace into transferred exceptions now * RmiClientInterceptorUtils throws clearer exception message in case of proxy mismatch (for underlying RMI stubs) * added "setContentType" configuration method to HttpInvokerServiceExporter and AbstractHttpInvokerRequestExecutor * built client-side HTTP GZIP response support into SimpleHttpInvokerRequestExecutor/CommonsHttpInvokerRequestExecutor * JaxRpcPortClientInterceptor synchronizes creation of JAX-RPC Calls, to make dynamic invocations with Axis thread-safe * refined JaxRpcPortClientInterceptor to only use JAX-RPC port if "portInterface" specified (prefer dynamic invocations) * added "setCustomPropertyMap" method to JaxRpcPortClientInterceptor/ProxyFactoryBean, accepting String-Object pairs * added AxisBeanMappingServicePostProcessor to "jaxrpc.support" package, for declarative registration of bean mappings Package org.springframework.scheduling * refined Quartz SchedulerFactoryBean to re-register the associated JobDetail when overwriting a JobDetailAwareTrigger * fixed Quartz SchedulerFactoryBean to handle potential cluster race condition on trigger registration Package org.springframework.scripting * AOP-based auto-proxying works for scripted objects as well now * added "lang" namespace for XML schema definitions, providing configuration for beans written in dynamic languages Package org.springframework.transaction * AbstractPlatformTransactionManager logs "Should roll back transaction but cannot" message at debug level (not warn) * TransactionInterceptor logs application exception at error level if commit throws an exception Package org.springframework.util * added null-safe hashCode and toString methods to ObjectUtils (analogous to JDK 1.5), moved over from Spring Modules * fixed StringUtils's "endsWithIgnoreCase" to correctly handle any String length * fixed CollectionsUtils's "hasUniqueObject" to correctly handle null values * refined NumberUtils to perform a value-in-range check for any Number returned from a NumberFormat * reworked MethodInvoker to match arguments against parameter types when searching for a matching method Package org.springframework.validation * renamed SimpleMapBindingResult to MapBindingResult * DataBinder does not use a default StringArrayPropertyEditor anymore, to nicely handle select list entries with commas * fixed ValidationUtils's "invokeValidator" to work correctly even in case of a null reference as object to be validated * added BindingResultUtils, providing convenience methods for looking up BindingResults in a model Map Package org.springframework.web * refined GenericFilterBean to fully support initialization as bean in a Spring bean factory (without FilterConfig) * refined OncePerRequestFilter to fall back to bean name or fully qualified class name if no filter name is available * refined FrameworkServlet to log a request handling failure at debug level rather than error level * refined AbstractRefreshablePortletApplicationContext to take PortletContext from PortletConfig if not explicitly set * factored out "handleNoSuchRequestHandlingMethod" method in MultiActionController, to be overridden in subclasses * fixed SimpleMappingExceptionResolver to correctly check the depth of all exception mappings before choosing a view * refined SimpleMappingExceptionResolver to only apply a "defaultStatusCode" to a top-level request (not to an include) * added "clearCache()" method to AbstractCachingViewResolver, for removing all cached view objects * optimized BeanNameViewResolver to avoid internal throwing and catching of NoSuchBeanDefinitionExceptions * ExpressionEvaluationManager supports concatenated expressions (e.g. "${var1}text${var2}") on all JSP 2.0 engines * added optional caching of JSP 2.0 Expressions, driven by "cacheJspExpressions" context-param in web.xml (true/false) * "javaScriptEscape" feature of Spring tags correctly escapes "" inside a literal value * fixed JSP SelectTag to correctly handle null values * AbstractJasperReportsView and subclasses require JasperReports 1.0.1 or higher (removed backwards compatibility check) * fixed AbstractJasperReportsView and subclasses to be compatible with J2EE <1.4 (avoid response.setCharacterEncoding) * AbstractJasperReportsView autodetects a JDBC DataSource in the model, as alternative to specifying it in configuration * Struts ContextLoaderPlugIn ignores "Action.setServlet(ActionServlet)" method when performing a dependency check * optimized Struts Delegating(Tiles)RequestProcessor to avoid unnecessary NoSuchBeanDefinitionException throw+catch * added Autowiring(Tiles)RequestProcessor, autowiring created Actions (configurable through ActionServlet init-params) Changes in version 2.0 M3 (8.3.2006) ------------------------------------ Package org.springframework.aop * AbstractBeanFactoryBasedTargetSource offers explicit "setTargetClass" method, else determines target class on demand * renamed AbstractLazyInitTargetSource to AbstractLazyCreationTargetSource * renamed AbstractPerformanceMonitorInterceptor to AbstractMonitoringInterceptor * refined DebugInterceptor to keep its count in a field of type long instead of int, with "long getCount()" accessor * fixed DebugInterceptor to properly synchronize access to its count field in a multithreading environment Package org.springframework.beans * factored out extended PropertyAccessor and ConfigurablePropertyAccessor interfaces from BeanWrapper/BeanWrapperImpl * BeanWrapperImpl supports PropertyEditors exposed by PropertyDescriptors (typically from BeanInfo classes) * BeanWrapperImpl passes a null value to a PropertyEditor's "setValue" method, allowing for conversion of null values * changed MutablePropertyValues's "addPropertyValue" signature back to void, to remain binary compatible with Spring 1.2 * fixed PropertyTypeConverter to never build "null[...]" property paths that lead to exceptions in "findCustomEditor" * fixed ArgumentConvertingMethodInvoker to perform conversion attempts on a copy of the argument array (not the source) * added "nullAsEmptyCollection" flag to CustomCollectionEditor, allowing to convert a null value to an empty Collection * added "containsLocalBean" method to HierarchicalBeanFactory interface, refactored from AbstractApplicationContext * fixed AbstractBeanFactory to use canonical bean name (id) for prototype creation, exposing it to BeanPostProcessors * fixed AbstractBeanFactory to destroy a failed bean completely, including dependent beans (in case of eager references) * fixed AbstractBeanFactory's definition caching to allow for proper placeholder substitution even with parent/child * added "configureBean" method to AutowireCapableBeanFactory, fully configuring an instance based on a bean definition * DefaultListableBeanFactory does not instantiate "factory-bean" references anymore, not even for eager-init singletons * re-added support for deprecated "class" property to PropertiesBeanDefinitionReader, alongside "(class)" * DefaultXmlBeanDefinitionParser considers "" as default namespace as well, for compatibility with the Oracle XML parser Package org.springframework.context * AbstractApplicationContext discovers its context MessageSource as "messageSource" bean even through an alias Package org.springframework.core * added "getRootCause()" method to NestedRuntime/CheckedException, for retrieving the innermost exception * refined PropertiesLoaderUtils to use a URLConnection with "setUseCaches(false)", to avoid jar file locking on Windows Package org.springframework.jdbc * added further default SQL error codes for MS SQL, MySQL, and Oracle * refined DataSourceUtils to expect an "afterCompletion" callback from a different thread (in case of JTA transaction) Package org.springframework.jms * reworked DefaultMessageListenerContainer to allow for breaking the receive loop into smaller, schedulable tasks * DefaultMessageListenerContainer defaults "maxMessagesPerTask" to 1 for short-lived-preferring SchedulingTaskExecutor * renamed ServerSessionMessageListenerContainer's "maxMessages" to "maxMessagesPerTask", for consistency Package org.springframework.jmx * fixed MBeanServerConnectionFactoryBean to avoid potential initialization of unused JMX Connector on shutdown Package org.springframework.jndi * added "defaultObject" property to JndiObjectFactoryBean, allowing to fall back to default object if JNDI lookup fails Package org.springframework.mock * MockServletContext's "getResourcePaths" correctly resolves directories as paths that end with a slash * MockHttpServletResponse detects charset specification in "setContentType" and sets character encoding accordingly * fixed AbstractTransactionalSpringContextTests's "startNewTransaction" to initialize "complete" to "!defaultRollback" Package org.springframework.orm * Hibernate LocalSessionFactoryBean offers protected "executeSchemaStatement" method for overriding the failure handling * fixed JpaTemplate's "findByNamedQuery" to correctly apply parameter indexes starting from 1 Package org.springframework.scheduling * added SchedulingTaskExecutor interface, letting an executor declare a preference for short-lived tasks * all thread-pool-backed executors implement SchedulingTaskExecutor to expose a preference for short-lived tasks * added SchedulingAwareRunnable interface, exposing an "isLongLived" flag (analogous to CommonJ's "isDaemon") * CommonJ WorkManagerTaskExecutor/DelegatingWork exposes SchedulingAwareRunnable's "isLongLived" flag appropriately * fixed TimerFactoryBean to properly initialize even without "scheduledTimerTasks" configured Package org.springframework.scripting * fixed ScriptFactoryPostProcessor to let scripts receive bean references up the entire container hierarchy Package org.springframework.transaction * added CompositeTransactionAttributeSource and "setTransactionAttributeSources([])" method for TransactionInterceptor * JtaTransactionManager autodetects JNDI location "java:pm/TransactionManager" on Borland and Sun application servers Package org.springframework.util * fixed ResponseTimeMonitorImpl to properly synchronize access to its instance variables in a multithreading environment Package org.springframework.validation * added further accessors to Errors interface: hasFieldErrors(), getFieldErrorCount(), getFieldErrors(), getFieldError() * introduced BindingResult interface, as extension of the Errors interface * reworked BindException to implement the BindingResult interface, wrapping an existing BindingResult * added BeanPropertyBindingResult and SimpleMapBindingResult implementations, based on a refactoring of BindException * added "BindingResult getBindingResult()" method to DataBinder, deprecating the "BindException getErrors()" method * adapted BindingErrorProcessor interface to operate on a BindingResult instead of a BindException * added support for direct field access in the form of DirectFieldBindingResult and DataBinder's "initDirectFieldAccess" Package org.springframework.web * changed WebApplicationContext's "ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE" to actually start with the package name * ContextLoader throws IllegalStateException if there is already a root application context present * fixed DispatcherServlet to keep and restore previous thread-bound LocaleContext and RequestAttributes * added overloaded "getModelAndView" method with HttpServletRequest argument to SimpleMappingExceptionResolver * added "cookieSecure" property to CookieGenerator, indicating that cookies should only be sent using HTTPS connections * added schema support for configuring a SimpleUrlHandlerMapping using spring-web.xsd * renamed "Handler" interface to "RequestHandler", to differentiate it from the dispatcher's generic "handler" concept * moved ControllerClassNameHandlerMapping from package "web.servlet.mvc.mapping" to "web.servlet.mvc" * added "useDirectFieldAccess()" template method to BaseCommandController, for initializing the DataBinder accordingly * added overloaded "onFormChange" method with BindException argument to SimpleFormController * MultiActionController does not consider "handleRequest" itself as handler method (to avoid potential stack overflow) * added full JSP 1.2 form tag library in package "web.servlet.tags", complementing the existing base tag library * upgraded VelocityToolboxView to use Velocity Tools 1.2+ API and avoid using deprecated earlier API * added VelocityLayoutViewResolver, a convenience subclass of VelocityViewResolver with support for VelocityLayoutView * added protected "callNextHandlerInChain" method to DecoratingNavigationHandler, to be called by subclasses Changes in version 2.0 M2 (1.2.2006) ------------------------------------ Overall * all of Spring must be built on JDK 1.5 now; the test suite is still able to run on JDK 1.4 and 1.3 Package org.springframework.aop * added equals/hashCode implementations to all pointcuts and advisors * removed restriction on proxying protected methods from Cglib2AopProxy * allowed AopUtils's "invokeJoinpointUsingReflection" to invoke protected methods * added "autodetectInterfaces" to ProxyFactoryBean, for TransactionProxyFactoryBean style behavior (is the default now!) * refined ProxyFactoryBean to lazily initialize a singleton proxy, to let "getObjectType()" expose the type beforehand * improved performance of IntroductionInfoSupport by faster determination of whether method is on introduced interface * refined ThreadLocalTargetSource's synchronization to guarantee thread-safe destruction on shutdown * added "hideProxyClassNames" property to AbstractTraceInterceptor, to log with target class instead of proxy class * added "target.dynamic" package to support dynamic refresh of object instances * added BeanFactoryRefreshableTargetSource to allow object instances to be refreshed with new instances from BeanFactory * AspectJ binding from pointcut expressions to arbitrary advice method arguments now working * support for introductions using AspectJ @DeclareParents * support for new AspectJ 5 "pertypewithin" aspect instantiation model * completed implementation of @AspectJ integration class MethodInvocationProceedingJoinPoint Package org.springframework.beans * fixed PropertyAccessorUtils's "getLastNestedPropertySeparatorIndex" to correctly handle property paths without dot * added overloaded constructor to StringArrayPropertyEditor, allowing to specify a custom separator for String splitting * BeanWrapperImpl keeps registered editors in a linked Map: the first registered editor that matches will be used * BeanWrapperImpl caches registered editors that match superclass or interface, to avoid repeated assignable-from checks * added support for bean properties with generic Collections/Maps, auto-converting to their element/key/value type * added support for constructor arguments with generic Collections/Maps, auto-converting to their element/key/value type * added "merge" attribute to "list"/"set/"map"/"props", for merging of collection values across parent/child definitions * added "default-merge" attribute to "beans" element to allow control of collection merging at the file level * changed FileEditor's behavior to consider input text as standard Spring resource location (instead of plain filename) * added "postProcessAfterInstantiation" method to InstantiationAwareBeanPostProcessor * fixed AbstractBeanFactory to correctly delegate to parent BeanFactory from "isFactoryBean" * optimized AbstractBeanFactory to avoid internal NoSuchBeanDefinitionException throw+catch as far as possible * AbstractBeanFactory caches merged bean definitions, for efficient prototype child creation and CGLIB class reuse * reworked AbstractBeanFactory's currently-in-creation check to log debug message when unfinished singleton is returned * added "allowCircularReferences" flag to AbstractAutowireCapableBeanFactory, to disallow circular references completely * DefaultListableBeanFactory's "getBeansOfType" logs BeanCurrentlyInCreationException message instead of stacktrace * refined DefaultXmlBeanDefinitionParser to explicity check for empty ref name and throw meaningful exception * DefaultXmlBeanDefinitionParser wraps unexpected exceptions in BeanDefinitionStoreException with context info * inner bean parsing/instantiation exceptions get wrapped in outer exceptions with appropriate context information * moved general bean wiring support from "beans.factory.aspectj" to "beans.factory.wiring"/"beans.factory.annotation" * renamed AspectJ AnnotationBeanConfigurer to AnnotationBeanConfigurerAspect * deprecated BeanFactoryBootstrap in favor of using a BeanFactoryLocator or a custom bootstrap class Package org.springframework.context * refined AbstractApplicationContext to never register more than one JVM shutdown hook * deprecated ConsoleListener, since it doesn't serve any purpose Package org.springframework.core * JdkVersion explicitly detects JDK 1.6 and 1.7 as well (does not mis-detect 1.6 as 1.3 anymore) * refined Jdk13ControlFlow to be compatible with GNU ClassPath (whose stacktrace has a whitespace after the method name) * added NestedIOException, deriving from java.io.IOException and adding NestedCheckedException-style root cause handling * refined AbstractResource to work around "FilterInputStream.close()" NPE, simply catching Throwable and ignoring it * PathMatchingResourcePatternResolver considers URL protocol "wsjar" as jar file (to load from WebSphere-managed jars) * ResourceArrayPropertyEditor can translate a set/list of patterns into a Resource array (rather than just one pattern) * split previous AnnotationUtils delegatetetetete into core.annotation.AnnotationUtils and beans.annotation.AnnotationBeanUtils Package org.springframework.jdbc * DataSourceTransactionManager only attempts to release Connection if not pre-bound (to avoid inappropriate log message) * TransactionAwareDataSourceProxy works correctly in combination with JdbcTemplate and transaction suspend/resume now * fixed SingleColumnRowMapper to explicitly check "ResultSet.wasNull()" after "getInt"/"getLong"/"getFloat" etc * turned visibility of "org.springframework.jdbc.core.StatementCreatorUtils" to package-protected * removed ResultReader interface (sub-interface of RowCallbackHandler): use RowMapper instead * reworked RowMapperResultReader adapter into RowMapperResultSetExtractor * reworked ResultSetSupportingSqlParameter to expose a RowMapper directly through a "getRowMapper()" method * reworked SqlQuery and subclasses to work with a RowMapper instead of a ResultReader -> "newRowMapper" template method * fixed BatchSqlUpdate's constructor that takes a "batchSize" argument to correctly interpret it as batch size * added "trackRowsAffected" property to BatchSqlUpdate, allowing to turn off the row counts list to save memory * refined JdbcBeanDefinitionReader to offer constructors with BeanDefinitionRegistry and PropertiesBeanDefinitionReader Package org.springframework.jmx * fixed MBeanExporter to work correctly with an "excludedBeans" list that it not sorted by bean name ascending * fixed "persistPeriod" default to be -1 even in ManagedResource attribute (not just in ManagedResource annotation) Package org.springframework.mock * made "servletContextName" and "portletContextName" configurable in MockServletContext respectively MockPortletContext * added "set/removeParameter" methods to MockHttpServletRequest, allowing to replace/remove existing parameters * added alternative MockPortalContext constructor that accepts custom PortletMode and WindowState lists * reworked MockActionResponse and MockPortletURL to check against list of supported PortletModes/WindowStates Package org.springframework.orm * SqlMapClientTemplate always works with SqlMapSession and provided Connection to enable proper batching in all cases * added "configLocations" property to LocalSessionFactoryBean for Hibernate3, allowing to load multiple config files * LocalSessionFactoryBean supports cache regions specified through "entity/collectionCacheStrategies" (on Hibernate 3.1) * LocalSessionFactoryBean supports multiple event listeners per type through "eventListeners" (on Hibernate 3.1) * added optional SpringSessionContext for Hibernate 3.1, to plug Spring into "getCurrentSession()" without proxying * added "replicate" convenience methods to HibernateTemplate for both Hibernate2 and Hibernate3 * added BlobStringType with configurable character encoding for both Hibernate2 and Hibernate3 * updated Spring's JDO 2.0 support to JDO API 2.0 beta (as provided by Apache, corresponding to JPOX 1.1.0-beta-6) * added full support for Java Persistence API 1.0 (JPA) Public Final Draft, in package "org.springframework.orm.jpa" Package org.springframework.samples * updated "views.properties" files in all sample applications to use "(class)" and "(parent)" * renamed PetClinic's "Entity" base class to "BaseEntity", to avoid name collision with the JPA Entity annotation * marked JPetStore's OrderForm, AccountForm and UserSession as Serializable Package org.springframework.scheduling * removed special Quartz 1.3 check from SchedulerFactoryBean: requires Quartz 1.4 or higher now * added support for Quartz 1.5's merged JobDataMap to QuartzJobBean, falling back to plain JobDataMap on Quartz 1.4 Package org.springframework.scripting * introduced scripting package based on ScriptFactory and ScriptSource abstractions * added support for BeanShell, Groovy and JRuby scripted objects Package org.springframework.test * fixed AbstractDependencyInjectionSpringContextTests's "populateProtectedVariables" to avoid incorrect warnings * added "startNewTransaction()" method to AbstractTransactionalSpringContextTests Package org.springframework.transaction * refined AbstractPlatformTransactionManager to suspend synchronizations before the actual transaction (not after) * fixed AbstractPlatformTransactionManager to serialize all relevant state * fixed TransactionInterceptor to correctly serialize TransactionAspectSupport state * marked AnnotationTransactionAttributeSource as Serializable Package org.springframework.ui * added ModelMap, providing "addObject" methods that auto-generate model attribute names according to conventions * added "defaultEncoding" bean property to FreeMarkerConfigurationFactory(Bean), inherited by FreeMarkerConfigurer * added overloaded methods to JasperReportsUtils to allow exporter parameter to be specified for specific formats Package org.springframework.util * ClassUtils's "forName(String)" method uses "getDefaultClassLoader()" instead of thread context ClassLoader only * fixed "StringUtils.delimitedListToStringArray" to properly handle an empty String as delimiter * refined StopWatch to not add new lines for "shortSummary()" but rather only for "prettyPrint()" * fixed ConcurrencyThrottleSupport to serialize all relevant state Package org.springframework.validation * DataBinder registers suppressed fields in BindException, which offers a "getSuppressedFields()" accessor now Package org.springframework.web * "contextConfigLocation" params in "web.xml" support "${...}" style placeholders for system properties * deprecated BindUtils and BindInitializer in package "web.bind" in favor of direct ServletRequestDataBinder usage * deprecated RequestUtils in package "web.bind" in favor of ServletRequestUtils * renamed RequestUtils in package "web.portlet.bind" to PortletRequestUtils * reworked MultipartException to derive from NestedIOException instead of NestedServletException, for Portlet reuse * upgraded CommonsMultipartResolver to Commons FileUpload 1.1 (not using deprecated FileUpload 1.0 API anymore) * added PortletMultipartResolver abstraction, with CommonsPortletMultipartResolver implementation as default * added multipart support to PortletRequestDataBinder, with factored-out common functionality in WebDataBinder * reworked RequestContextHolder to hold a RequestAttributes facade instead of a full HttpServletRequest * added RequestContextHolder support to DispatcherPortlet, to enable Request/SessionScopeMap with portlets * refactored RequestHandledEvent into RequestHandledEvent base class and ServletRequestHandledEvent subclass * renamed FrameworkPortlet's RequestHandledEvent to PortletRequestHandledEvent, a subclass of RequestHandledEvent * PortletBean ignores init-params that do not match bean properties, analogous to HttpServletBean * DispatcherServlet does not log handler exceptions at warn level anymore but rather only at debug level * fixed DispatcherPortlet to properly support an exposed View object in a given ModelAndView * reworked Servlet ModelAndView and Portlet ModelAndView to fully support ModelMap's conventional attribute names * added HttpSessionMutexListener and "WebUtils.getSessionMutex", used by AbstractController's "synchronizeOnSession" * added "PortletUtils.getSessionMutex", used by the Portlet AbstractController's "synchronizeOnSession" * added "FacesContextUtils.getSessionMutex", to make HttpSessionMutexListener's session mutex available to JSF code * turned AbstractController's "passAllParametersToRenderPhase"/"clearAllRenderParameters" into PortletUtils methods * added "propertyEditorRegistrars" property to BaseCommandController, for applying PropertyEditorRegistrars * added "propertyEditorRegistrars" property to Portlet BaseCommandController, for applying PropertyEditorRegistrars * added "bindingErrorProcessor" property to Portlet BaseCommandController, for configurable BindingErrorProcessor * turned AbstractCommandController's and AbstractFormController's "handleRequestInternal" methods non-final * refactored AbstractFormController's session form check into one single place, throwing SessionRequiredException * reworked MultiActionController's "bind" and "createBinder" to work on HttpServletRequest instead of ServletRequest * deprecated MultiActionController's "initBinder(ServletRequest...)" in favor of "initBinder(HttpServletRequest...)" * refined ParameterMethodNameResolver to treat an empty method name as no name at all, letting the default kick in * added protected accessors for UrlBasedViewResolver's bean properties, allowing subclasses to access the settings * added "argumentSeparator" property to MessageTag, allowing to specify a custom separator instead of the default comma * added "useSingleModelNameAsRoot" property to AbstractXlstView, allowing to enforce the value of the "root" property * added RequestToViewNameTranslator strategy to allow DispatcherServlet to auto-generate view names where necessary * added DefaultRequestToViewNameTranslator to provide intuitive defaults for automatic view name generation * refined Struts DelegatingActionProxy and Delegating(Tiles)RequestProcessor to fall back to root WebApplicationContext * added DelegatingNavigationHandlerProxy and DelegatingPhaseListenerMulticaster to JSF support (used by Spring Web Flow) Changes in version 2.0 M1 (22.12.2005) -------------------------------------- Overall * removed all deprecated classes and methods * removed support for iBATIS SQL Maps 1.3 (if you haven't done so already, upgrade to iBATIS SQL Maps 2.0/2.1!) * added explicit support for Hibernate 3.1 while remaining compatible with Hibernate 3.0 (as far as possible) * factored out "spring-jdo", "spring-hibernate2/3", "spring-toplink", "spring-ojb" jars (not in "spring.jar" anymore!) * distributed first AspectJ aspects (for transaction management and DI of objects not instantiated by Spring container) Package org.springframework.aop * added support for AspectJ pointcut expressions, specified in AspectJ pointcut language * added support for AspectJ aspect implementations, both for classic AspectJ style and the AspectJ 5 annotation style * added @Configurable annotation plus BeanConfigurer aspect to allow injection on any arbitrary object through AspectJ * added AopNamespaceHandler to support dedicated "aop:*" XML tags Package org.springframework.beans * added intelligent error messages to BeanWrapperImpl when properties are not found * fixed BeanWrapperImpl to pass its "extractOldValueForEditor" setting on to nested BeanWrappers * refined BeanWrapperImpl to perform the accessible checking for read/write methods before every invocation * changed "MutablePropertyValues.addPropertyValue(String, Object)" to return 'this' * removed deprecated "getBeanDefinitionNames(type)" method from ListableBeanFactory and BeanFactoryUtils * added "createBean" and "initializeBean" methods to AutowireCapableBeanFactory interface * fixed AbstractBeanFactory to allow child bean definitions to refer to a parent via its alias name * DefaultListableBeanFactory is able to call non-public factory methods as well * PropertiesBeanDefinitionReader trims String values for special keys such as "(class)", "(parent)", etc * added "default-init-method" and "default-destroy-method" attributes to the XML bean definition format * added support for XSD-driven XML bean definitions, with pluggable namespace handlers * added UtilNamespaceHandler to support dedicated "util:*" XML tags Package org.springframework.core * introduced TaskExecutor abstraction, as strategy interface for the execution of Runnables * added SyncTaskExecutor and SimpleAsyncTaskExecutor as simple default implementations of the TaskExecutor interface Package org.springframework.context * added "getAutowireCapableBeanFactory()" accessor to ApplicationContext interface, for direct access without casting * refined AbstractApplicationContext's lifecycle behavior to properly ignore repeated "close()" calls * moved DefaultListableBeanFactory's cleanup on "preInstantiateSingletons()" behavior to AbstractApplicationContext * reworked SimpleApplicationEventMulticaster to delegate to a TaskExecutor, using a SyncTaskExecutor as default Package org.springframework.dao * introduced EmptyResultDataAccessException as specific subclass of IncorrectResultSizeDataAccessException Package org.springframework.jdbc * added further error codes for Oracle and MySQL to default "sql-error-codes.xml" file * OracleLobHandler lazily initializes Oracle driver classes, always loading via the actual Connection's class loader * fixed DataSourceUtils to correctly re-suspend a Connection even if the Connection hasn't been used since resume * fixed JdbcTemplate to extract the JDBC Connection for CallableStatementCreators if a NativeJdbcExtractor has been set * factored out protected "getColumnMapRowMapper" and "getSingleColumnRowMapper" hooks within JdbcTemplate * SingleColumnRowMapper throws specific IncorrectResultSetColumnCountException in case of invalid column count * SingleColumnRowMapper explicitly calls "ResultSet.getBigDecimal()" if the required type is BigDecimal * added SimpleJdbcTemplate with ParameterizableRowMapper for Java 5, leveraging varargs and generics Package org.springframework.jms * SimpleMessageConverter accepts a passed-in raw JMS Message and returns a raw JMS Message if content type is unknown * added DefaultMessageListenerContainer mechanism for async message reception via the plain JMS MessageConsumer API * added SimpleMessageListenerContainer mechanism for async message reception via the plain JMS MessageListener API * added ServerSessionMessageListenerContainer mechanism for async message reception via the JMS ServerSessionPool API Package org.springframework.jmx * introduced MBeanExportOperations interface, providing a programmatic facility for registering MBeans on MBeanExporter * introduced MBeanExportException as unified exception hierarchy for MBeanExporter and MBeanExportOperations * MBeanExporter no longer ignores autodetected MBeans with invalid object names: specify appropriate "excludedBeans" * added support for registering NotificationListeners with the MBeanServer * added @ManagedNotification(s) annotation (and corresponding Commons attributes) for describing notification MBeanInfo * extended static MBeanInfoAssemblers to support configuration of Notification metadata * added NotificationPublisher(Aware) to support publication of JMX Notifications from Spring-managed beans * added MBeanExporter option to have Spring extend ObjectNames to ensure they are unique per-instance * added MBeanExporter option to have Spring expose the ClassLoader of the managed resource before MBean invocations Package org.springframework.jndi * added JndiNamespaceHandler to support dedicated "jndi:*" XML tags Package org.springframework.orm * JdoTransactionManager does explicit "isActive()" check before attempting a rollback, to avoid illegal state exception * HibernateTransactionManager autodetects Hibernate 3.1 to support its native transaction timeout * removed "save" operations with explicit id argument from HibernateTemplate (following Hibernate 3.1's removal) * upgraded FilterDefinitionFactoryBean to Hibernate 3.1 (which changed its FilterDefinition in an incompatible fashion) * upgraded IdTransferringMergeEventListener to Hibernate 3.1 (which changed its listener API in an incompatible fashion) * Hibernate LocalSessionFactoryBean exposes its DataSource on "SessionFactory.close()", for potential schema export Package org.springframework.remoting * RmiServiceExporter performs explicit RMI unexport if binding to the registry failed, to avoid dangling exports * JaxRpcPortClientInterceptor/ProxyFactoryBean apply given JaxRpcServicePostProcessors to existing JAX-RPC Service too * HttpInvokerServiceExporter, HessianServiceExporter and BurlapServiceExporter implement Handler instead of Controller * HttpInvokerRequestExecutor is allowed to throw any Exception, not just IOException and ClassNotFoundException Package org.springframework.scheduling * TimerFactoryBean creates a non-daemon Timer by default, to let running tasks finish after Timer was cancelled * added TimerTaskExecutor adapter for accessing a "java.util.Timer" through the TaskExecutor interface * added "taskExecutor" property to Quartz SchedulerFactoryBean, for replacing Quartz's default thread pool * added SimpleThreadPoolTaskExecutor for Quartz, allowing to define Quartz's default thread pool as Spring TaskExecutor * added scheduling-style support for the JDK 1.5 ThreadPoolExecutor mechanism in the "java.util.concurrent" package * added ConcurrentTaskExecutor adapter for accessing a JDK 1.5 Executor through the TaskExecutor interface * added scheduling-style support for the CommonJ TimerManager API, as supported by WebLogic 9 and WebSphere 6 * added WorkManagerTaskExecutor adapter for accessing a CommonJ WorkManager through the TaskExecutor interface Package org.springframework.samples * upgraded JPetStore (standard and annotation version) to use the new XML schema namespaces "aop", "tx" and "jndi" Package org.springframework.test * added AbstractModelAndViewTests, a convenience super class for testing ModelAndView objects Package org.springframework.transaction * JtaTransactionManager only invokes rollback if transaction is still active (some JTA providers eagerly terminate) * added TransactionNamespaceHandler to support dedicated "tx:*" XML tags Package org.springframework.util * added "isNull()" methods to Assert class * added "setPathSeparator" method to AntPathMatcher, allowing to override the default path separator "/" * fixed AntPathMatcher to correctly treat "*" right after separator, i.e. to accept path "/test/" for pattern "/test/*" * WeakReferenceMonitor uses a daemon thread, to avoid a hanging thread even if weak references have not been released * changed ConcurrencyThrottleSupport's default "concurrencyLimit" to -1 (keeping ConcurrencyThrottleInterceptor at 1) Package org.springframework.web * use NestedServletException wherever a root cause gets wrapped by a ServletException (for nicer root cause handling) * WebApplicationContext interface does not extend ThemeSource anymore; implementing ThemeSource is now optional * introduced ServletConfigAware interface, for getting access to a Framework/DispatcherServlet's ServletConfig object * SimpleServletPostProcessor configures Servlets with DispatcherServlet's ServletConfig by default (can be turned off) * introduced Handler interface as alternative to Controller, with no ModelAndView and only throwing Servlet/IOException * AbstractCachingViewResolver guarantees at-most-once instantiation of each View instance (-> extended synchronization) * added "currentFormObject" template method to AbstractFormController, for post-processing of a session form object * "RequestContextUtils.getLocale(request)" falls back to the accept-header Locale if no LocaleResolver found * FixedLocaleResolver returns the JVM's default Locale if no explicit default Locale specified * VelocityView converts Velocity's MethodInvocationException to a Spring NestedServletException with original root cause