Release Spring Framework 3.0.7.RELEASE

Following the move to git, empty dirs are not tracked. Add .gitignore
files as necessary to keep the ant build happy.

.gitignore

@@ -0,0 +1,12 @@
+.springBeans
+.DS_Store
+target
+integration-repo
+ivy-cache
+jmx.log
+jxl.log
+jmx.log
+org.springframework.jdbc/derby.log
+org.springframework.spring-parent/.classpath
+org.springframework.spring-parent/.project
+org.springframework.test/test-output/

build-spring-framework/build.xml

@@ -1,24 +1,33 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project name="build-spring-framework" default="precommit">
 
-	<path id="bundles">
+	<path id="unit.test.bundles">
 		<pathelement location="../org.springframework.instrument"/>
-		<pathelement location="../org.springframework.instrument.classloading"/>
+		<pathelement location="../org.springframework.instrument.tomcat"/>
 		<pathelement location="../org.springframework.core"/>
 		<pathelement location="../org.springframework.expression"/>
 		<pathelement location="../org.springframework.beans"/>
 		<pathelement location="../org.springframework.aop"/>
 		<pathelement location="../org.springframework.context"/>
 		<pathelement location="../org.springframework.transaction"/>
+		<pathelement location="../org.springframework.oxm"/>
 		<pathelement location="../org.springframework.jms"/>
-		<pathelement location="../org.springframework.aspects"/>
 		<pathelement location="../org.springframework.jdbc"/>
 		<pathelement location="../org.springframework.web"/>
 		<pathelement location="../org.springframework.orm"/>
 		<pathelement location="../org.springframework.context.support"/>
+		<pathelement location="../org.springframework.aspects"/>
 		<pathelement location="../org.springframework.web.servlet"/>
 		<pathelement location="../org.springframework.web.portlet"/>
 		<pathelement location="../org.springframework.test"/>
+		<pathelement location="../org.springframework.web.struts"/>
+	</path>
+
+	<path id="bundles">
+		<pathelement location="../org.springframework.spring-parent"/>
+		<pathelement location="../org.springframework.asm"/>
+		<path refid="unit.test.bundles" />
+		<pathelement location="../org.springframework.integration-tests"/>
 		<pathelement location="../org.springframework.spring-library"/>
 	</path>
 
@@ -28,6 +37,45 @@
 	<import file="${basedir}/publish-documentation.xml"/>
 	<import file="${basedir}/../spring-build/multi-bundle/default.xml"/>
 
-	<target name="precommit" depends="clean,clean-integration,test"/>
+	<target name="precommit" depends="clean, clean-integration, test"/>
+
+	<presetdef name="javadoc.links">
+		<javadoc>
+			<link href="http://java.sun.com/javase/6/docs/api"/>
+			<link href="http://java.sun.com/j2ee/1.4/docs/api"/>
+			<link href="http://aopalliance.sourceforge.net/doc"/>
+			<!-- Caucho Burlap/Hessian -->
+			<link href="http://cglib.sourceforge.net/apidocs"/>
+			<!-- EasyMock -->
+			<link href="http://ehcache.sourceforge.net/apidocs"/>
+			<link href="http://freemarker.sourceforge.net/docs/api/"/>
+			<link href="http://www.hibernate.org/hib_docs/v3/api"/>
+			<!-- iBATIS -->
+			<!-- iText -->
+			<!-- Commons Attributes -->
+			<link href="http://jakarta.apache.org/commons/collections/apidocs-COLLECTIONS_3_0/"/>
+			<link href="http://jakarta.apache.org/commons/dbcp/apidocs/"/>
+			<link href="http://jakarta.apache.org/commons/fileupload/apidocs/"/>
+			<link href="http://jakarta.apache.org/commons/httpclient/apidocs/"/>
+			<link href="http://jakarta.apache.org/commons/logging/apidocs/"/>
+			<link href="http://jakarta.apache.org/commons/pool/apidocs/"/>
+			<!-- JasperReports -->
+			<!-- JDO -->
+			<!-- JMX -->
+			<!-- JOTM -->
+			<!-- JPA -->
+			<!-- JSF -->
+			<link href="http://junit.sourceforge.net/javadoc_40/"/>
+			<link href="http://logging.apache.org/log4j/docs/api/"/>
+			<link href="http://jakarta.apache.org/regexp/apidocs/"/>
+			<link href="http://jakarta.apache.org/poi/apidocs/"/>
+			<link href="http://portals.apache.org/pluto/multiproject/portlet-api/apidocs/"/>
+			<link href="http://www.opensymphony.com/quartz/api/"/>
+			<link href="http://struts.apache.org/struts-doc-1.2.9/api/"/>
+			<link href="http://java.sun.com/javase/6/docs/jre/api/net/httpserver/spec/"/>
+			<link href="http://tiles.apache.org/framework/apidocs/"/>
+			<link href="http://velocity.apache.org/engine/devel/apidocs/"/>
+		</javadoc>
+	</presetdef>
 
 </project>

build-spring-framework/package-top-level.xml

@@ -15,21 +15,22 @@
 			<property name="target.dir" value="${package.docs.dir}"/>
 		</ant>
 
-		<!--ant dir="../spring-framework-reference" target="doc" inheritAll="false">
-			<property name="package.output.dir" value="${package.output.dir}"/>
-			<propertyset>
-				<propertyref builtin="commandline"/>
-			</propertyset>
-			<property name="timestamp" value="${timestamp}"/>
-		</ant>
+		<!-- Reference Document START-->
+		<path id="doc.projects">
+			<path location="${basedir}/../spring-framework-reference"/>
+		</path>
 
-		<subant target="package" verbose="true" buildpath="../spring-framework-reference">
+		<all-bundles target="doc" buildpathRef="doc.projects"/>
+
+		<delete>
+		  <fileset dir="${basedir}/../spring-framework-reference" includes="**/*.zip"/>
+		</delete>
+
+		<all-bundles target="package" buildpathRef="doc.projects">
 			<property name="package.output.dir" value="${package.output.dir}"/>
-			<propertyset>
-				<propertyref builtin="commandline"/>
-			</propertyset>
-			<property name="timestamp" value="${timestamp}"/>
-		</subant-->
+		</all-bundles>
+
+		<!-- Reference Document END-->
 
 		<copy todir="${package.output.dir}">
 			<fileset dir="${basedir}/resources"/>
@@ -37,10 +38,9 @@
 
 		<copy todir="${package.output.dir}/projects">
 			<fileset dir="${basedir}/..">
-				<exclude name="**/target/**"/>
+				<exclude name="*/target/**"/>
 				<exclude name="integration-repo/**"/>
 				<exclude name="ivy-cache/**"/>
-				<!--exclude name="ivy-cache/repository/org.apache.velocity/org.apache.velocity.docbookframework.dist/**"/-->
 				<exclude name="spring-build/lib/docbook/**" />
 				<exclude name="**/*OLD*/**"/>
 			</fileset>
@@ -55,19 +55,19 @@
 		<zip destfile="${package.output.file}">
 			<zipfileset dir="${package.dir}">
 				<exclude name="${package.basename}/docs/**"/>
-				<exclude name="${package.basename}/projects/ivy-cache/**"/>
 			</zipfileset>
 		</zip>
 		
 		<zip destfile="${artifacts.dir}/${package.basename}-with-docs.zip">
-			<zipfileset dir="${package.dir}">
-				<exclude name="${package.basename}/projects/ivy-cache/**"/>
-			</zipfileset>
+			<zipfileset dir="${package.dir}"/>
 		</zip>
 
-		<!--zip destfile="${artifacts.dir}/${package.basename}-with-dependencies.zip">
-			<zipfileset dir="${package.dir}"/>
-		</zip-->
+		<zip destfile="${artifacts.dir}/${package.basename}-dependencies.zip">
+			<zipfileset dir="${basedir}/../ivy-cache/repository">
+				<exclude name="org.apache.velocity/org.apache.velocity.docbookframework.dist/**"/>
+			</zipfileset>
+		</zip>
+		
 	</target>
 
-</project>
+</project>

build-spring-framework/publish-documentation.xml

@@ -3,10 +3,10 @@
 
 <!-- Main targets -->
 	<target name="publish-documentation" depends="publish-documentation.init">
-		<sshexec host="spring02.managed.contegix.com" username="${username}" keyfile="${key.file}" passphrase="${passphrase}"
+		<sshexec host="static.springsource.org" username="${username}" keyfile="${key.file}" passphrase="${passphrase}"
 				command="mkdir /opt/www/domains/springframework.org/www/htdocs/spring/docs/${bundle.version}"/>
 
-		<scp remoteToDir="${username}@spring02.managed.contegix.com:/opt/www/domains/springframework.org/www/htdocs/spring/docs/${bundle.version}"
+		<scp remoteToDir="${username}@static.springsource.org:/opt/www/domains/springframework.org/www/htdocs/spring/docs/${bundle.version}"
 				keyfile="${key.file}" passphrase="${passphrase}" sftp="true" verbose="true">
 			<fileset dir="${package.output.dir}">
 				<include name="changelog.txt" />
@@ -16,7 +16,7 @@
 			<fileset dir="${package.docs.dir}" />
 		</scp>
 
-		<sshexec host="spring02.managed.contegix.com" username="${username}" keyfile="${key.file}" passphrase="${passphrase}"
+		<sshexec host="static.springsource.org" username="${username}" keyfile="${key.file}" passphrase="${passphrase}"
 				command="rm /opt/www/domains/springframework.org/www/htdocs/spring/docs/3.0.x ; ln -s /opt/www/domains/springframework.org/www/htdocs/spring/docs/${bundle.version} /opt/www/domains/springframework.org/www/htdocs/spring/docs/3.0.x"/>
 	</target>
 

build-spring-framework/publish-top-level.xml

@@ -7,7 +7,7 @@
 	<target name="publish-package" depends="aws.init">
 		<checksum file="${package.output.file}" algorithm="sha1"/>
 		<checksum file="${artifacts.dir}/${package.basename}-with-docs.zip" algorithm="sha1"/>
-		<!--checksum file="${artifacts.dir}/${package.basename}-with-dependencies.zip" algorithm="sha1"/-->
+		<checksum file="${artifacts.dir}/${package.basename}-dependencies.zip" algorithm="sha1"/>
 		
 		<aws:s3 accessKey="${accessKey}" secretKey="${secretKey}">
 			<upload bucketName="dist.${bucket.basename}" file="${package.output.file}"
@@ -30,15 +30,15 @@
 			<upload bucketName="dist.${bucket.basename}" file="${artifacts.dir}/${package.basename}-with-docs.zip.sha1"
 					toFile="${adjusted.release.type}/${project.key}/${package.basename}-with-docs.zip.sha1" publicRead="true"/>
 
-			<!--upload bucketName="dist.${bucket.basename}" file="${artifacts.dir}/${package.basename}-with-dependencies.zip"
-					toFile="${adjusted.release.type}/${project.key}/${package.basename}-with-dependencies.zip" publicRead="true">
+			<upload bucketName="dist.${bucket.basename}" file="${artifacts.dir}/${package.basename}-dependencies.zip"
+					toFile="${adjusted.release.type}/${project.key}/${package.basename}-dependencies.zip" publicRead="true">
 				<metadata name="project.name" value="Spring Framework"/>
 				<metadata name="release.type" value="${release.type}"/>
 				<metadata name="bundle.version" value="${bundle.version}"/>
-				<metadata name="package.file.name" value="${package.basename}-with-dependencies.zip"/>
+				<metadata name="package.file.name" value="${package.basename}-dependencies.zip"/>
 			</upload>
-			<upload bucketName="dist.${bucket.basename}" file="${artifacts.dir}/${package.basename}-with-dependencies.zip.sha1"
-					toFile="${adjusted.release.type}/${project.key}/${package.basename}-with-dependencies.zip.sha1" publicRead="true"/-->
+			<upload bucketName="dist.${bucket.basename}" file="${artifacts.dir}/${package.basename}-dependencies.zip.sha1"
+					toFile="${adjusted.release.type}/${project.key}/${package.basename}-dependencies.zip.sha1" publicRead="true"/>
 		</aws:s3>
 	</target>
 </project>

build-spring-framework/resources/changelog.txt

@@ -1,6 +1,673 @@
 SPRING FRAMEWORK CHANGELOG
 ==========================
-http://www.springframework.org
+http://www.springsource.org
+
+
+Changes in version 3.0.7 (2011-12-22)
+-------------------------------------
+
+* fixed GenericTypeResolver to consistently return null if not resolvable
+* added proper "contentLength()" implementation to ByteArrayResource
+* refined Resource "exists()" check for HTTP URLs to always return false for 404 status
+* LocaleEditor and StringToLocaleConverter do not restrict variant part through validation
+* LinkedCaseInsensitiveMap overrides putAll method as well (for IBM JDK 1.6 compatibility)
+* ConversionService prevents Converter from trying to convert to a subtype of its actual target type
+* ConversionService is able to work with "Collections.emptyList()" as target type (again)
+* CollectionCollection/MapToMapConverter preserve original Collection/Map if no converted elements
+* fixed nested element conversion with a DataBinder + ConversionService + PropertyEditor
+* restored DataBinder's ability to bind to an auto-growing List with unknown element type
+* optimized DefaultListableBeanFactory's PropertyDescriptor caching for concurrent access
+* context:property-placeholder's "file-encoding" attribute value is being applied correctly
+* SpringValidatorAdapter accepts non-indexed set paths (for Hibernate Validator compatibility)
+* fixed AbstractAsyncExecutionAspect's setExecutor method to correctly wrap in a TaskExecutorAdapter
+* @Transactional qualifiers match against transaction manager definitions in parent contexts as well
+* TransactionSynchronizationManager eagerly cleans up void ResourceHolders on any access
+* updated H2 error codes in sql-error-codes.xml
+* fixed NamedParameterJdbcTemplate to use correct maximum type for queryForInt/Long
+* SimpleJdbcTestUtils executeSqlScript properly closes its LineNumberReader after use
+* Hibernate synchronization properly unbinds Session even in case of afterCompletion exception
+* JDO PersistenceManager synchronization performs close attempt after completion (if necessary)
+* JPA EntityManagerFactoryUtils silently ignores IllegalArgumentExceptions from setHint calls
+* added "forwarder" property to ConnectorServerFactoryBean, accepting an MBeanServerForwarder
+* JmsInvokerClientInterceptor/FactoryBean always uses createConnection/createSession when on JMS 1.1
+* RmiClientInterceptor detects nested SocketException as connect failure as well
+* Servlet/PortletContextResource's getFile prefers "file:" URL resolution over calling getRealPath
+* Portlet session mutex uses global session attribute to be shared among all portlets in the session
+* fixed ServletServerHttpRequest to reconstruct from "request.getParameterMap()" for form POST only
+* fixed @RequestMapping header matching to correctly process negated header conditions
+* added "getObjectMapper()" accessor to MappingJacksonHttpMessageConverter
+* ResourceHttpRequestHandler sends content without content-type header if no media type found
+* AbstractCachingViewResolver allows for caching unresolved view names ("cacheUnresolved"=true)
+* fixed "formMultiSelect"/"formCheckboxes" FreeMarker macros to compare against actual field value
+
+
+Changes in version 3.0.6 (2011-08-18)
+-------------------------------------
+
+* fixed aspects bundle to declare dependencies for @Async aspect as well
+* ProxyCreationContext uses "ThreadLocal.remove()" over "ThreadLocal.set(null)" as well
+* DefaultListableBeanFactory is only deserializable through a SerializedBeanFactoryReference
+* DefaultListableBeanFactory's getBean(name, type) attempts type conversion if necessary
+* DefaultListableBeanFactory allows for init methods to register further bean definitions (again)
+* XmlBeanDefinitionReader accepts description subelement within map entry as well (as per the XSD)
+* ConfigurationClassPostProcessor supports use of same processor instance with several factories
+* fixed potential InjectionMetadata NPE when using SpringBeanAutowiringInterceptor
+* SpringBeanAutowiringSupport is able to process @Value annotations on any given target instance
+* overridden @PersistenceContext annotations on subclass methods are being processed correctly
+* BeanDefinitionVisitor now actually visits factory method names
+* restored support for String-to-ContextResource conversion
+* restored original GenericConversionService behavior with respect to empty collections/maps
+* restored original FormattingConversionService behavior with respect to the use of subtypes
+* added "formatters" property to FormattingConversionServiceFactoryBean
+* collection/array conversion returns original collection if possible (instead of first element)
+* fixed collection element resolution when using a ConversionService with a DataBinder
+* DataBinder uses a default limit of 256 for array/collection auto-growing
+* added "autoGrowNestedPaths" property to ConfigurableWebBindingInitializer
+* Servlet/PortletRequestDataBinder perform unwrapping for MultipartRequest as well
+* fixed AbstractBindingResult to avoid NPE in "hashCode()" if target is null
+* fixed several HttpHeaders issues (charset handling, quoting/unquoting)
+* SimpleClientHttpRequest uses fixed-length streaming mode (always sets content-length header)
+* added "connectTimeout" and "readTimeout" properties to Simple/CommonsClientHttpRequestFactory
+* explicit status code in RedirectView respected in HTTP 1.0 compatibility mode
+* FormHttpMessageConverter correctly processes POST requests
+* ResourceHttpRequestHandler does not set Content-Length header for 304 response
+* ResourceHttpRequestHandler detects invalid directory traversal in given path
+* LocaleChangeInterceptor validates locale values in order to prevent XSS vulnerability
+* HtmlUtils properly escapes single quotes as well
+* added support for web.xml context-param "springJspExpressionSupport" (explicit "true"/"false")
+* ContextLoader and FrameworkServlet support "contextId" parameter for custom serialization id
+* RemoteExporter uses an opaque proxy for 'serviceInterface' (no AOP interfaces exposed)
+* added "acceptProxyClasses" flag to RemoteInvocationSerializingExporter
+* refined WebLogic RMI descriptor to only mark 'getTargetInterfaceName' method as idempotent
+* EhCacheManagerFactoryBean properly closes "ehcache.xml" input stream, if any
+* revised JMS CachedConnectionFactory to avoid unnecessary rollback calls on Session return
+* fixed JMS CachedConnectionFactory to fully synchronize its Session list
+* fixed NamedParameterJdbcTemplate's handling of arrays as query parameters
+* fixed JPA 2.0 timeout hints to correctly specify milliseconds
+* updated Quartz package to support Quartz 1.8 as well (note: not supporting Quartz 2.0 yet)
+* fixed @Rule execution order in SpringJUnit4ClassRunner to match standard JUnit 4 behavior
+
+
+Changes in version 3.0.5 (2010-10-20)
+-------------------------------------
+
+* support for Hibernate 3.6 final
+* added core serializer abstraction with default implementations using Java Serialization
+* consistent use of JDK 1.5's "ThreadLocal.remove()" over "ThreadLocal.set(null)"
+* fixed JodaTimeContextHolder to use a non-inheritable ThreadLocal and expose a reset method
+* revised "ClassUtils.isAssignable" semantics to cover primitives vs wrappers in both directions
+* optimized AnnotationUtils findAnnotation performance for repeated search on same interfaces
+* ConversionService protects itself against infinite recursion in ObjectToCollectionConverter
+* fixed TypeDescriptor to correctly resolve nested collections and their element types
+* BeanWrapper does not attempt to populate Map values on access (just auto-grows Map itself)
+* fixed Autowired/CommonAnnotationBeanPostProcessor to prevent race condition in skipping check
+* fixed @Value injection to correctly cache temporary null results for non-singleton beans
+* ApplicationContext registers context-specific ClassArrayEditor for its bean ClassLoader
+* refined ApplicationContext singleton processing to not fail for manually registered null instances
+* fixed ApplicationContext event processing for repeated invocations to non-singleton listener beans
+* optimized @Bean error messages for static factory methods as well as for argument type mismatches
+* modified expression parsing to pass full TypeDescriptor context through to ConversionService calls
+* adapted expression parser's Constructor/MethodResolver to accept TypeDescriptors instead of raw types
+* SpEL supports projection on any kind of Collection (not just on Lists and arrays)
+* SpEL MapAccessor consistently rejects "target.key" style access to Maps if no such key is found
+* SpEL method invocations prefer method with fewest parameters (e.g. no-arg over vararg)
+* AspectJExpressionPointcut uses bean ClassLoader for initializing the AspectJ pointcut parser
+* added AnnotationAsyncExecutionAspect as AspectJ-based variant of @Async processing
+* added mode="proxy"/"aspectj" and proxy-target-class options to task:annotation-driven
+* JDBC bundle uses local ClassLoader as bean ClassLoader for "sql-error-codes.xml" parsing
+* EmbeddedDatabaseFactory shuts down database when failing to populate it in "initDatabase()"
+* embedded database support now also works with Derby >= 10.6
+* "jdbc:embedded-database" uses id as database name to allow multiple ones in parallel
+* ResourceDatabasePopulator throws descriptive ScriptStatementFailedException with resource details
+* added configurable Connection/Statement/ResultSet target types to Jdbc4NativeJdbcExtractor
+* added OracleJdbc4NativeJdbcExtractor with pre-configured Oracle JDBC API types
+* DefaultLobHandler's "wrapAsLob" mode works with PostgreSQL's "getAsciiStream()" requirement
+* ResultSetWrappingSqlRowSet (as used by JdbcTemplate's "queryForRowSet") supports column labels now
+* LocalSessionFactoryBean's "entityCacheStrategies" works with region names on Hibernate 3.6 as well
+* fixed DefaultMessageListenerContainer's no-message-received commit to work without Session caching
+* DefaultMessageListenerContainer's skips no-message-received commit on Tibco (avoiding a deadlock)
+* JaxWsPortClientInterceptor does not fall back to annotation-specified name as portName anymore
+* UriTemplate is serializable now
+* fixed AnnotationMethodHandlerAdapter's caching to avoid concurrency issues in RequestMappingInfo
+* fixed @MVC processing of parameter-level annotations to work with interface-based proxies again
+* revised @RequestParam processing to support CSV-to-array/collection binding with ConversionService
+* fixed EvalTag's EvaluationContext caching to properly handle JSP tag caching across requests
+* AbstractJasperReportsView only sets locale model attributes if not present already
+* DispatcherPortlet throws custom NoHandlerFoundException instead of misleading UnavailableException
+* DispatcherPortlet copies all action parameters to render parameters in case of an action exception
+* DispatcherPortlet's default resource serving explicitly prevents access to WEB-INF and META-INF
+* Portlet @ExceptionHandler methods allow for writing the response directly (like in the Servlet case)
+* MockHttpServletRequest/HttpSession/etc returns independent Enumeration from "getAttributeNames()"
+
+
+Changes in version 3.0.4 (2010-08-19)
+-------------------------------------
+
+* support for Hibernate Core 3.6, Hibernate Validator 4.1, EclipseLink 2.1, EHCache 2.2
+* OSGi manifest version range accepts EHCache 2.x as well
+* added "contentLength()" method to Resource abstraction
+* URL-based Resource variants introspect "last-modified" and "content-length" response headers
+* refined "exists()" check for UrlResource (HEAD request) and ClassPathResource (URL resolution)
+* ConversionService is able to deal with empty collections and nested collections (fixed regression)
+* ConversionService properly handles nested Resource arrays in Map values (fixed regression)
+* ConversionService does not accidentally use copy constructor for same type
+* fixed double ConversionFailedException nesting for ObjectToObjectConverter invocations
+* BeanWrapper preserves annotation information for individual array/list/map elements
+* Spring's constructor resolution consistently finds non-public multi-arg constructors
+* revised constructor argument caching, avoiding a race condition for converted argument values
+* SpEL passes full collection type context (generics, annotations) to ConversionService
+* SpEL 'select last' operator now works consistently with maps
+* BeanWrapper/DataBinder's "autoGrowNestedPaths" works for Maps as well
+* fixed concurrency issue in TypedStringValue, showing for nested typed Maps in prototype beans
+* fixed WeakReferenceMonitor to never stop its monitoring thread if an entry has been registered
+* fixed CronTrigger to correctly parse month parts expressed as numbers (1-12 instead of 0-11)
+* TaskExecutorFactoryBean (as used by task:executor) exposes full ThreadPoolTaskExecutor type
+* JmsResourceHolder does not ignore IllegalStateException from locally synchronized transaction
+* fixed JMS CachingConnectionFactory to correctly cache a producer without fixed destination as well
+* DefaultMessageListenerContainer triggers Session commit even if no message has been received
+* DefaultMessageListenerContainer supports client id setting even for non-shared Connections
+* Spring's MessageEndpointFactory classes are now JCA 1.6 compliant as well
+* AbstractJaxWsServiceExporter supports "bindingType" bean property, overriding @BindingType
+* AbstractJaxWsServiceExporter supports "webServiceFeatures" bean property on JAX-WS 2.2
+* JaxWsPortProxyFactoryBean takes "wsdlDocumentUrl", "namespaceUri" etc defaults from @WebService
+* Jaxb2Marshaller's "marshallerProperties" Map accepts any value type
+* SpringTemplateLoader for FreeMarker supports last-modified timestamp through Resource abstraction
+* HibernateJpaDialect correctly closes borrowed connections even for nested JDBC executions
+* DefaultJdoDialect supports JDO 3.0 query timeout facility (as supported by DataNucleus 2.1)
+* transaction names based on method id from most specific method (target class instead of interface)
+* added "validationMessageSource" to LocalValidatorFactoryBean, for Spring-based validation messages
+* Spring field error arguments include actually declared annotation attributes in alphabetical order
+* JSR-303 Pattern message resolvable through Spring MessageSource (despite special characters) 
+* DispatcherServlet applies default view name translation to error views as well
+* mvc:annotation-driven reliably detects JSR-303 and JAXB2 in an OSGi environment as well
+* revised @MVC handler method resolution with respect to handler methods on generic interfaces
+* @MVC handler methods reliably resolve MultipartRequest arguments with HiddenHttpMethodFilter
+* WebDataBinder and @MVC request params detect and introspect MultipartFile arrays as well
+* fixed @PathVariable regression in combination with ConversionService usage on DataBinder
+* @CookieValue returns decoded cookie value in a Servlet environment (analogous to @RequestParam)
+* MVC HandlerExceptionResolvers prevent caching for exception views if preventResponseCaching=true
+* @ExceptionHandler works for inherited method and CGLIB proxies on Portlet controllers as well
+* Portlet @MVC's implicit render model will be updated at the end of the event phase
+* Portlet AbstractController consistently uses session mutex if "synchronizeOnSession" is active
+* PortletWrappingController supports Portlet 2.0 resource and event requests as well
+* fixed JSP EvalTag to render null result as empty String instead of "null" String
+* JSP EvalTag resolves "@myBeanName" references in expressions against the WebApplicationContext
+* added support for static resource serving: ResourceHttpRequestHandler, mvc:resources
+* revised DispatcherServlet's last-modified handling to properly work with scoped controllers
+* MockMultipartHttpServletRequest pre-defines method "POST" and content type "multipart/form-data"
+
+
+Changes in version 3.0.3 (2010-06-15)
+-------------------------------------
+
+* Spring autodetects JodaTime 1.3 or higher (as required), ignoring older JodaTime versions
+* clarified that Spring's Jackson support requires Jackson 1.3 or higher
+* JPA 2.0 support tested and supported with Hibernate 3.5.2 and OpenJPA 2.0.0 GA as well
+* revised VFS support for Spring's component scanning to work on JBoss AS 6.0.0 M3 as well
+* fixed URIEditor's URI construction to consider fragment as well
+* added default InputSourceEditor for SAX InputSource construction with a URL String as system id
+* CachedIntrospectionResults only caches GenericTypeAwarePropertyDescriptors if fully safe
+* revised BeanWrapper's exception wrapping to consistently handle ConversionExceptions
+* DefaultListableBeanFactory checks for alias circle on registerAlias (avoiding endless loop)
+* ConversionService is able to apply Converters to interface-based array elements
+* ConversionService fully supports conversion from String to MediaType now (through 'valueOf')
+* revised exception handling in ObjectToObjectConverter, avoiding InvocationTargetExceptions
+* a context ConversionService is able to override an ApplicationContext's resource editors
+* refined LifecycleProcessor exception handling, properly wrapping a start exception from a bean
+* revised DefaultLifecycleProcessor's handling of circular dependencies to avoid stack overflow
+* fixed constructor argument caching for prototypes with multiple constructor matches
+* specific detection of CGLIB subclasses in order to properly handle CGLIB interfaces
+* registerDependentBean resolves to the canonical bean name in order to handle alias references
+* fixed registerResolvableDependency mechanism to correctly handle non-serializable factory objects
+* added "expose-proxy" attribute to aop namespace (enforcing AopContext proxy exposure with CGLIB)
+* revised AbstractInterceptorDrivenBeanDefinitionDecorator for further alignment with auto-proxying
+* BeanDefinitionVisitor/PropertyPlaceholderConfigurer finds and resolves values in arrays as well
+* property placeholders can deal with nested expressions which happen to use the same suffix
+* SpEL's Elvis operator is able to deal with #{${myProp}?:defaultValue} case if myProp is empty
+* introduced EmbeddedValueResolverAware callback interface for convenient placeholder resolution
+* @Transactional qualifier value matches against @Qualifier annotations on @Bean methods as well
+* setTransactionIsolation on JDBC Connection only called when actually necessary (for PostgreSQL)
+* added limit for parsed SQL cache to NamedParameterJdbcTemplate (default is 256; configurable) 
+* CachingConnectionFactory detects destination equality for WebSphere MQ as well (using toString)
+* DefaultPersistenceUnitManager's getPersistenceUnitInfo method has 2.5 compatible signature again
+* DefaultMessageListenerContainer reacts to maxConcurrentConsumers reduction for long-lived tasks
+* added "idleConsumerLimit" bean property to DefaultMessageListenerContainer (default is 1)
+* AsyncAnnotationBeanPostProcessor consistently adds @Async processing as first Advisor in the chain
+* ScheduledTaskRegistrar (as used for @Scheduled processing) properly shuts down its default executor
+* CronTrigger defensively protects itself against accidental re-fires if a task runs too early
+* MailSendException includes all messages as failed messages in case of a connect failure
+* added support for JAX-WS 2.1 WebServiceFeatures to JaxWsPortClientInterceptor/PortProxyFactoryBean
+* added XmlAwareFormHttpMessageConverter, taking over the 3.0.2-introduced XML multipart support
+* ServletContextResourcePatternResolver handles "/WEB-INF/lib/*.jar!/**/context.xml" style patterns
+* fixed MVC mapping regression for servlet url-pattern "/" case on servers other than WebSphere
+* MVC mappings properly apply even to welcome file entries that forward to a DispatcherServlet
+* fixed @ExceptionHandler resolution in case of multiple matches at different inheritance levels
+* revised Portlet SessionStatus.setComplete() to avoid re-exposure of attributes in render phase
+* shortened Portlet MVC's implicit model render parameter name to "implicitModel"
+* added convenient "checkRefresh" bean property to TilesConfigurer
+* TilesConfigurer's "definitionsFactoryClass" property applies common Tiles DefinitionsFactory setup
+* JSP FormTag calculates proper default form action even when using a rewrite filter on WebSphere
+* JSP HiddenInputTag allows for using common HTML attributes (equivalent to LabelTag)
+* fixed JSP ErrorsTag to avoid invalid "*.errors" id, using form object name as id prefix instead
+* fixed JSP SelectTag's support for rendering enum constants
+* JSP Radiobutton/CheckboxesTag utilizes PropertyEditor/ConversionService for label rendering
+* MockHttpServletResponse supports multiple includes
+
+
+Changes in version 3.0.2 (2010-04-02)
+-------------------------------------
+
+* fixed cross-module version ranges in OSGi manifests
+* fixed contents of org.springframework.web.struts jar
+* upgraded to Hibernate Validator 4.0.2 and Jackson 1.4.2
+* compatibility with Hibernate 3.5 final (native and also as a JPA 2.0 provider)
+* compatibility with OpenJPA 2.0 (support for JPA 2.0 persistence.xml versioning)
+* compatibility with Hessian 4.0 (in terms of exception propagation)
+* compatibility with JasperReports 3.x (in terms of resource management)
+* restored full compatibility with Servlet 2.4 containers on all VMs
+* PropertyEditor lookup fallback works on Google App Engine as well
+* fixed TypeDescriptor/MethodParameter toString for all cases in debug log messages
+* widened AbstractFactoryBean's "getObjectType" signature to return any Class as well
+* BeanPostProcessors are allowed to return a null bean value in the middle of the chain
+* autowire="byType" ignores parameter name when choosing a primary bean, as defined
+* ObjectFactoryCreatingFactoryBean creates a serializable ObjectFactory reference
+* added ProviderCreatingFactoryBean, exposing a serializable JSR-330 Provider reference
+* "conversionService" bean will be ignored if it is not of type ConversionService
+* revised AbstractInterceptorDrivenBeanDefinitionDecorator for alignment with auto-proxying
+* SimpleJdbcCall's "returningResultSet" accepts any plain RowMapper now
+* added public "validateDatabaseSchema" method to Hibernate LocalSessionFactoryBean
+* HibernateJpaDialect borrows JDBC Connection on demand (supporting aggressive release)
+* JCA listener containers delegate to wrapped Transaction handle (for Geronimo compatibility)
+* @Transactional qualifiers work in unit tests as well (TransactionalTestExecutionListener)
+* @Value processing works in test instances (using the test context framework) as well now
+* @DirtiesContext is now inherited for class-level usage
+* NativeWebRequest detects native MultipartRequest when decorated by HiddenHttpMethodFilter
+* WebRequestInterceptor exposes HttpServletResponse through NativeWebRequest (after downcast)
+* WebContentInterceptor does not restrict HTTP methods by default anymore
+* WebApplicationObjectSupport's initServletContext will be called only once in any scenario
+* DispatcherPortlet passes handler instance into HandlerExceptionResolver for action exception
+* DispatcherPortlet applies preHandleRender callbacks in case of action exception as well
+* UrlPathHelper cuts off trailing servlet-path slashes for root mappings (on WebSphere)
+* introduced support for HttpEntity and ResponseEntity wrappers, adding context to body values
+* fixed DataBinder's conversion error handling for direct field access with ConversionService
+* @InitBinder methods support all applicable Spring 3.0 parameter annotations as well
+* fixed @RequestParam(required=false) regression for @InitBinder methods
+* @ExceptionHandler methods consistently receive original exception
+* fixed indexed property binding regression in form tag library
+* fixed @Configurable issue with null bean name
+
+
+Changes in version 3.0.1 (2010-02-18)
+-------------------------------------
+
+* upgraded to AspectJ 1.6.8
+* full support for JPA 2.0 persistence schema and PersistenceUnitInfo SPI
+* support for JPA PersistenceContext/Unit injection on Google App Engine
+* support for Hibernate 3.5 (as native Hibernate API and as JPA 2.0 provider)
+* support for Tiles 2.2.1 (preserving compatibility with Tiles 2.1.2 and above)
+* consistent treatment of unresolvable placeholders for Resource and Resource array properties
+* ConversionFailedException exDLBFposes offending value through public "getValue()" method
+* fixed BeanFactory's "getBeansWithAnnotation" to ignore beans with non-determinable type
+* widened FactoryBean's "getObjectType" signature to return any Class (Class<?>)
+* do not ever consider Object as a candidate type for autowiring by type (autowire="byType") 
+* BeanDefinitionReader and ClassPath/FileSystemXmlApplicationContext use varargs where possible
+* introduced BeanDefinitionRegistryPostProcessor extension to BeanFactoryPostProcessor
+* @Configuration classes support definition of BeanFactoryPostProcessor beans
+* component-scan's scoped-proxy attribute applies to scope-annotated singleton beans as well
+* generic ApplicationListener event type gets detected through AOP proxy as well
+* ApplicationListeners will only be executed once per event (even for scripted objects)
+* ApplicationListeners will get detected lazily as well (e.g. on @Bean's concrete result)
+* inner bean ApplicationListeners will be invoked through their proxy (if any)
+* fixed SimpleApplicationEventMulticaster's retriever caching to allow for proper removal
+* context-specific "conversionService" bean may refer to annotation-configured converter beans
+* refined DefaultLifecycleProcessor's start/stop logging and stop exception handling
+* DefaultLifecycleProcessor allows for overriding specific hooks in subclasses
+* BeanNameAutoProxyCreator detects alias matches for specified bean names
+* proxies with AspectJ pointcuts are fully serializable within a BeanFactory now
+* SharedEntityManagerCreator's EntityManager proxies are fully serializable now
+* Query call chaining works with shared EntityManager proxy outside of transaction as well
+* TransactionInterceptor is able to serialize "transactionManagerBeanName" as well
+* non-matching @Transactional qualifier value will lead to IllegalStateException
+* fixed WebSphereUowTransactionManager regression: correctly roll back in case of exception
+* JndiObjectFactoryBean explicitly only chooses public interfaces as default proxy interfaces
+* added vararg variants of query methods to JdbcTemplate (as known from SimpleJdbcTemplate)
+* MBeanClientInterceptor/MBeanProxyFactoryBean understands CompositeData/TabularData arrays
+* added "workManagerMBeanName" property to JBossWorkManagerTaskExecutor
+* task:executor's id value is now used as thread name prefix of ThreadPoolTaskExecutor
+* fixed @Scheduled processing to kick in once only even in an ApplicationContext hierarchy
+* fixed MediaType's Comparable behavior to do a full comparison, aligned with equals behavior
+* added "sortBySpecificity" method to MediaType, for typical use with accept header matching
+* MimeMessageHelper encodes from, to, cc, bcc String addresses with given encoding as well
+* changed HttpStatus.REQUEST_TOO_LONG constant to REQUEST_ENTITY_TOO_LARGE
+* relaxed generic Class declaration in HttpMessageConverter's canRead/canWrite/read signatures
+* fixed "mvc:view-controller" to work in a fully isolated fashion on Spring Dynamic Modules
+* DefaultRequestToViewNameTranslator strips trailing slashes as well (can also be turned off)
+* @RequestParam/RequestHeader/CookieValue's defaultValue allows for declaring empty String
+* @SessionAttributes works when used on an annotated controller interface with AOP proxying
+* WebRequest is a resolvable dependency in Servlet/Portlet web application contexts
+* revised JSP-based views to never fail when trying to set Servlet API forward attributes
+* lenient evaluation of boolean 'true' attribute expressions in JSP form tag library
+* added new spring:eval tag for evaluating SpEL expressions from JSP pages
+* SpringBeanAutowiringSupport works in extra ClassLoaders as well (e.g. WebLogic JAX-WS)
+
+
+Changes in version 3.0.0.GA (2009-12-16)
+----------------------------------------
+
+* component scanning autodetects the new EE 6 "javax.annotation.ManagedBean" stereotype
+* updated JPA 2.0 support to the final spec (tested compatibility with EclipseLink 2.0 GA)
+* full support for GlassFish V3 GA (includes component scanning and load-time weaving)
+* upgraded to JRuby 1.4 (while remaining compatible with JRuby 1.1 and above)
+* bean property names are matched leniently ("title" and "Title"; "ISBN" and "iSBN")
+* bean properties of type enum array/collection can be populated with comma-separated String
+* removed getBeansWithAnnotation(Class,boolean,boolean) method from ListableBeanFactory
+* PropertyPlaceholderConfigurer is compatible with Spring 2.5 extensions (again)
+* SmartLifecycle beans will get auto-started on demand even if marked as lazy-init
+* MBeanExporter detects FactoryBean-exported resources independent from declaration order
+* refactored SpelExpressionParser to accept SpelParserConfiguration object with boolean flags
+* revised TypeDescriptor's valueOf and forObject factory methods with some level of caching
+* revised GenericConverter's "getConvertibleTypes" signature to return Set of ConvertiblePair
+* GenericConversionService prefers matches against inherited interfaces over superclasses
+* renamed ConverterRegistry's addGenericConverter(GenericConverter) method to addConverter
+* no default converters for Object-to-Map and Map-To-Object anymore
+* default converter for String-to-Properties parsing only applies for actual Properties objects
+* default ObjectToStringConverter only stringifies objects that indicate proper toString behavior
+* added "converters" property to FormattingConversionServiceFactoryBean as well
+* full support for formatters and formatting annotations on array/collection elements
+* no default number formatter (relying on plain java.lang.Number parsing and rendering)
+* no default formatters for Date/Calendar (requiring explicit use of @DateTimeFormat)
+* BeanValidationPostProcessor runs in before-initialization phase (before init methods) by default
+* removed MultipartRequest mixin interface again (avoiding a package dependency cycle)
+* revised RestTemplate method signatures to accept Object values instead of just Strings
+* revised path variable extraction to properly deal with dots in variable values (again)
+* reintroduced createBinder template method in Servlet/Portlet AnnotationMethodHandlerAdapter
+
+
+Changes in version 3.0.0.RC3 (2009-12-01)
+-----------------------------------------
+
+* prepared for Grails and ROO requirements
+* restored compatibility with Apache CXF
+* fixed bean definition import via "classpath*:" URLs
+* added chaining-capable "add" method to MutablePropertyValues
+* constructor arguments can be overridden by name in child bean definitions
+* BeanDefinitions return isSingleton()=true by default again, with scope name empty
+* init/destroy methods get processed in the order of declaration at each hierarchy level
+* fixed lookup of LifecycleProcessor bean in a Spring Dynamic Modules environment
+* refined lifecycle processing through introduction of startup/shutdown phases
+* fixed transaction synchronization setup with TransactionAwareDataSourceProxy involved
+* added support for Hibernate 3.3 RegionFactory cache SPI to LocalSessionFactoryBean
+* JSR-303 SpringValidatorAdapter uses field name as first argument (analogous to bind errors)
+* replaced DefaultConversionService with ConversionServiceFactory(Bean)
+* revised FormatterRegistry interface and FormattingConversionServiceFactoryBean setup
+* mvc:annotation-driven exposes default Validator and ConversionService as top-level beans
+* mvc:annotation-driven registers applicable HttpMessageConverters by default, if available
+* added interceptors support to mvc namespace, for path-based interceptor mappings
+
+
+Changes in version 3.0.0.RC2 (2009-11-13)
+-----------------------------------------
+
+* updated to final versions of JSR-330 "javax.inject" and JSR-303 "javax.validation" APIs
+* full compliance with the JSR-330 TCK (i.e. full compliance with the final specification)
+* support for Hibernate Validator 4.0 GA (as the JSR-303 reference implementation)
+* added support for load-time weaving in JBoss 5.x
+* added support for recent EHCache 1.6 configuration properties to EHCacheFactoryBean
+* added AnnotatedBeanDefinitionReader helper for programmatic registration of annotated classes
+* added AnnotationConfig(Web)ApplicationContext for convenient registration/scanning of classes
+* added GenericXmlApplicationContext with flexible configuration options for its XML support
+* AbstractApplicationContext can also start up in case of system properties access failure
+* internal MergedBeanDefinitionPostProcessors apply after all other post-processors
+* inner beans detected as ApplicationListeners as well (only supported for inner singletons)
+* child bean definition's scope attribute can be inherited from parent bean definition now
+* introduced SmartLifecycle interface with auto-startup and shutdown order support
+* introduced LifecycleProcessor delegate, customizable through "lifecycleProcessor" bean
+* MessageListenerContainers and Quartz SchedulerFactoryBean start up on refresh instead of init
+* added initialize-database tag to jdbc namespace for populating external data sources with data
+* PathMatchingResourcePatternResolver leniently ignores non-existing root directories
+* DefaultConversionService understands "on"/"off", "yes"/"no", "1"/"0" as boolean values
+* CustomEditorConfigurer supports PropertyEditor instances again (with deprecation warning)
+* revised MethodParameter's annotation accessor methods
+* ClassUtils is now parameterized with Class<?> and Class<T> where appropriate
+* DataBinder now accepts var-args to set allowed, disallowed, and required fields
+* DataBinder auto-grows nested paths on traversal (avoiding NullValueInNestedPathException)
+* fixed enum binding regression with WebRequestDataBinder (as used by @MVC data binding now)
+* fixed FieldError to expose rejected input value as String value instead of as array
+* JSR-303 Validator will only register validation failures if no binding failure happened
+* ContentNegotiatingViewResolver works with ignoreAcceptHeader and defaultContentType as well
+* added Spring MVC namespace, with convenient mvc:annotation-driven configuration element
+* default number and datetime formatters configured when using the Spring MVC namespace
+* full support for datetime formatting using the Joda Time library (automatically enabled)
+* added convenient @NumberFormat and @DateTimeFormat annotations for declarative formatting
+* implicit T.valueOf(S) and constructor T(S) lookup if no explicit S->T converter matches
+* AbstractExcelView is compatible with Apache POI 3.0 as well as 3.5 now
+* TilesConfigurer only sets up EL support if JSP 2.1 is present (for JSP 2.0 compatibility)
+* re-introduced Struts 1.x support ("org.springframework.web.struts") in deprecated form
+* deprecated scheduling support for JDK 1.3 Timer ("org.springframework.scheduling.timer")
+* deprecated remoting support for JAX-RPC (in favor of JAX-WS)
+
+
+Changes in version 3.0.0.RC1 (2009-09-25)
+-----------------------------------------
+
+* upgraded to CGLIB 2.2, AspectJ 1.6.5, Groovy 1.6.3, EHCache 1.6.2, JUnit 4.7, TestNG 5.10
+* introduced early support for JSR-330 "javax.inject" annotations (for autowiring)
+* introduced early support for JSR-303 Bean Validation (setup and MVC integration)
+* added default editors for "java.util.Currency" and "java.util.TimeZone"
+* refined PathMatchingResourcePatternResolver's treatment of non-readable directories
+* PathMatchingResourcePatternResolver understands VFS resources (i.e. works on JBoss 5.x)
+* revised AccessControlContext access from BeanFactory
+* AbstractBeanDefinitionParser can deal with null return value as well
+* PropertyOverrideConfigurer's "ignoreInvalidKeys" ignores invalid property names as well
+* PropertyPlaceholderConfigurer supports "${myKey:myDefaultValue}" defaulting syntax
+* BeanFactory's default type conversion falls back to String constructor on target type
+* BeanFactory tries to create unknown collection implementation types via default constructor
+* BeanFactory supports ObjectFactory as a dependency type for @Autowired and @Value
+* BeanFactory supports JSR-330 Provider interface as a dependency type for @Inject
+* BeanFactory prefers local primary bean to primary bean in parent factory
+* protected @Autowired method can be overridden with non-annotated method to suppress injection
+* private @Autowired methods with same signature will be called individually across a hierarchy
+* @PostConstruct processed top-down (base class first); @PreDestroy bottom-up (subclass first)
+* ConfigurationClassPostProcessor detect @Bean methods on registered plain bean classes as well
+* support for default "conversionService" bean in an ApplicationContext
+* MBeanServerFactoryBean returns JDK 1.5 platform MBeanServer for agent id "" (empty String)
+* changed NamedParameter/SimpleJdbcOperations parameter signatures to accept any Map value type 
+* refined logging in JMS SingleConnectionFactory and DefaultMessageListenerContainer
+* introduced "ui.format" package as an alternative to PropertyEditors for data binding
+* @RequestMapping annotation now supported for annotated interfaces (and JDK proxies) as well
+* @RequestParam and co support placeholders and expressions in their defaultValue attributes
+* @Value expressions supported as MVC handler method arguments as well (against request scope)
+* JSR-303 support for validation of @MVC handler method arguments driven by @Valid annotations
+* refined response handling for @ExceptionHandler methods
+* @ResponseStatus usage in handler methods detected by RedirectView
+* all @SessionAttributes get exposed to the model before handler method execution
+* @Event/ResourceMapping uniquely mapped to through event/resource id, even across controllers
+* MultipartRequest is available as a mixin interface on (Native)WebRequest as well
+* removed outdated "cacheJspExpressions" feature from ExpressionEvaluationUtils
+* introduced common ErrorHandler strategy, supported by message listener container
+* Jpa/JdoTransactionManager passes resolved timeout into Jpa/JdoDialect's beginTransaction
+* HibernateJpaDialect applies timeout onto native Hibernate Transaction before begin call
+* Spring's Hibernate support is now compatible with Hibernate 3.5 beta 1 as well
+* Spring's JPA support is now fully compatible with JPA 2.0 as in EclipseLink 2.0.0.M7
+* SpringJUnit4ClassRunner is now compatible with JUnit 4.5, 4.6, and 4.7
+* SpringJUnit4ClassRunner once again supports collective timeouts for repeated tests
+* deprecated @NotTransactional annotation for test classes in favor of @BeforeTransaction
+
+
+Changes in version 3.0.0.M4 (2009-08-10)
+----------------------------------------
+
+* upgraded to JUnit 4.6, TestNG 5.9, and EasyMock 2.5.1
+* updated all Spring Framework OSGI manifests to list unversioned imports explicitly
+* relaxed several OSGi bundle dependencies (optional, extended version ranges)
+* revised Java 6 checks to test for the presence of specific Java 6 interfaces/classes only
+* replaced Commons Collections dependency with Spring-provided LinkedCaseInsensitiveMap
+* case-insensitive Maps and key Sets preserve original casing for introspection/logging
+* constructor argument type matching supports arrays and simple class names now
+* XML constructor-arg element allows for specifying a constructor argument by name now
+* XML import elements with relative resource patterns are supported as well now
+* introduced non-lenient constructor resolution mode for BeanDefinitions (for RFC-124)
+* revised DefaultListableBeanFactory's access control when running within a SecurityManager
+* BeanWrapper and DefaultListableBeanFactory accept a custom ConversionService now
+* DefaultListableBeanFactory references are serializable now when initialized with an id
+* scoped proxies are serializable now, for web scopes as well as for singleton beans
+* injected request/session references are serializable proxies for the current request now
+* Servlet/Portlet ApplicationContexts use a specific id based on servlet/portlet name
+* ReloadableResourceBundleMessageSource correctly calculates filenames for all locales now
+* @PostConstruct works for multiple private init methods of the same name in a hierarchy
+* @Primary/@Lazy/@DependsOn supported as meta-annotations as well
+* @Bean/@Scope etc supported as meta-annotations on factory methods as well now
+* @Required does not get processed on beans returned by @Bean factory methods
+* @Import detects and accepts existing configuration class of the desired type
+* @Transactional supports qualifier value for choosing between multiple transaction managers
+* WebSphereUowTransactionManager falls back to UOWManagerFactory lookup by default
+* JMS SingleConnectionFactory performs start call within connection monitor (for Oracle AQ)
+* @ManagedResource is marked as inherited now, for generic management-aware base classes
+* introduced dedicated @ManagedMetric annotation for metric attributes in a JMX environment
+* added task namespace with scheduler/executor configuration and scheduled task definitions
+* added jdbc namespace with embedded-database tag (supporting HSQL, H2, and Derby)
+* Hibernate AnnotationSessionFactoryBean detects Hibernate's special @Entity annotation too
+* added SimpleJaxWsServiceExporter workaround for WebLogic 10.3's address format requirements
+* added support for @WebServiceProvider annotation to Spring's JaxWsServiceExporters
+* updated Hessian support for Hessian 3.2 compatibility (requiring Hessian 3.2 or above now)
+* updated Tiles support for Tiles 2.1 compatibility (requiring Tiles 2.1.2 or above now)
+* Velocity/FreeMarker/TilesViewResolver only returns a view if the target resource exists now
+* @DirtiesContext is now supported at the test class level with configurable class modes
+* added beforeTestClass() and afterTestClass() to the TestExecutionListener API
+* ProfileValueUtils now enforces class-level overrides for @IfProfileValue
+* @ContextConfiguration's loader attribute is now inherited if not declared locally
+* TransactionalTestExecutionListener no longer flushes transactions before rolling back
+
+
+Changes in version 3.0.0.M3 (2009-05-06)
+----------------------------------------
+
+* Spring 3.0 includes reference documentation now
+* Spring 3.0 is shipping with proper Maven POMs now
+* updated to JRuby 1.2 (remaining compatible with JRuby 1.1 and above)
+* updated to Hessian 3.2.1 (remaining compatible with Hessian 3.1.3 and above)
+* updated to FreeMarker 2.3.15 (for exposure of FreeMarkerServlet-style HTTP scopes)
+* removed Axis 1.x support package, keeping basic JAX-RPC support only (next to JAX-WS)
+* introduced explicit XML array element in spring-beans-3.0.xsd
+* introduced new type conversion SPI and converter API in spring-core convert package
+* introduced annotated @Bean factory methods and JavaConfig-style @Configuration classes
+* introduced @Primary, @Lazy and @DependsOn annotations for scanned components
+* custom stereotype annotations can be meta-annotated with @Service, @Controller etc as well
+* @Scope and @Transactional are now supported as meta-annotations on custom annotations
+* @Autowired uses field/parameter name as fallback qualifier value
+* qualifier annotations can be used at method level as well (applying to all parameters)
+* @Value annotation can be used at method level as well (e.g. on bean property setters)
+* @Value values may use ${...} placeholders (driven by PropertyPlaceholderConfigurer)
+* @Resource names may use ${...} placeholders (driven by PropertyPlaceholderConfigurer)
+* fixed EL evaluation of prepared constructor arguments for repeated prototype creation
+* ConstructorArgumentValues exposed indexed arguments in the order of definition
+* AutowiredAnnotationBeanPostProcessor calculates cached arguments in a synchronized block
+* declarative destroy-method="..." specifications get validated at bean creation time
+* component-scan's "base-package" attribute supports spaces as separators as well
+* CachedIntrospectionResults always caches bean classes except in case of custom BeanInfo
+* GenericTypeResolver's type variable cache uses weak values (for OSGi compatibility)
+* fixed CachingMapDecorator to support garbage-collected weak references (again)
+* AOP ProxyFactory excludes non-public interfaces when autodetecting proxy interfaces
+* added DuplicateKeyException to DAO exception hierachy 
+* added EmbeddedDatabase support in spring-jdbc embedded package, with initial HSQL support
+* SessionAwareMessageListener supports generic declaration of concrete JMS Message type
+* RmiServiceExporter and RmiRegistryFactoryBean synchronize registry lookup/creation
+* added "unregisterManagedResource" method to MBeanExporter/MBeanExportOperations
+* TimerTaskExecutor creates non-daemon Timer and uses bean name as default Timer name
+* added TaskScheduler interface and Trigger abstraction
+* added ConcurrentTaskScheduler and ThreadPoolTaskScheduler
+* added CommonJ TimerManagerTaskScheduler
+* added CronTrigger implementation for cron expression support
+* renamed "contextProperties" attribute to "contextParameters" (matching web.xml naming)
+* "contextParameters" contains Servlet/PortletConfig parameters as well
+* added default "servletContext" and "servletConfig" environment beans
+* added default "portletContext" and "portletConfig" environment beans
+* added default web scope "application", wrapping a ServletContext/PortletContext
+* JSF FacesContext and ExternalContext are resolvable dependencies by default, if available
+* FacesRequestAttributes (as used by RequestContextHolder) can access global Portlet session
+* revised @RequestMapping semantics for REST support purposes
+* request handler methods with @ModelAttribute annotation always return a model attribute
+* introduced @ExceptionHandler annotation for used in annotated web controllers
+* introduced ModelAndViewResolver SPI for custom handler method return types
+* FreeMarkerView can be initialized with ServletContext only (e.g. for testing)
+* MockPortletSession supports destruction of session attributes on invalidation
+* completed upgrade of the TestContext Framework to JUnit 4.5
+* SpringJUnit4ClassRunner subclasses can now override the default ContextLoader class
+* added "value" alias for @ContextConfiguration's "locations" attribute
+
+
+Changes in version 3.0.0.M2 (2009-02-25)
+----------------------------------------
+
+* revised expression parser API design
+* added SimpleThreadScope implementation
+* refined OSGi version constraints for "javax.annotation" and "junit.framework"
+* "systemProperties" bean is not considered a default match for type Properties anymore
+* SimpleAliasRegistry's "getAliases" method returns transitive aliases now
+* SimpleAliasRegistry detects resolved aliases that loop back to the original name
+* PropertyPlaceholderConfigurer does not modify Map in case of equal String keys
+* improved NoClassDefFoundError handling during constructor resolution
+* inner class names in Java source style ("java.lang.Thread.State") supported as well
+* pre-converted property values are preserved more eagerly for re-created beans
+* prototype beans receive independent collection/array even when based on single value
+* registered plain singletons will be fully matched according to their qualifiers
+* @Qualifier value matching takes chained aliases of target beans into account as well
+* ASM-based AnnotationMetadata fully resolves class arguments and enums into Java types
+* ProceedingJoinPoint resolves parameter names using ASM-based parameter name discovery
+* MethodInvocations and ProceedingJoinPoints always expose original method (not bridge)
+* bridge method resolution works with Hibernate-generated CGLIB proxies as well
+* generic collection type resolution respects upper bound (e.g. ? extends Number) as well
+* TypeUtils detects variations of ParameterizedType/GenericArrayType assignability as well
+* ReflectionUtils findMethod detects methods on "java.lang.Object" as well
+* UrlResource eagerly closes HTTP connections in case of "getInputStream()" failure
+* PathMatchingResourcePatternResolver avoids NPE when initialized with null ClassLoader
+* all "taskExecutor" bean properties now accept any "java.util.concurrent.Executor"
+* added "Future submit(Runnable)" and "Future submit(Callable)" to AsyncTaskExecutor
+* SimpleAsyncTaskExecutor supports a custom "java.util.concurrent.ThreadFactory"
+* SchedulingTaskExecutor interface extends AsyncTaskExecutor now
+* added ThreadPoolExecutorFactoryBean (exposing the native ExecutorService interface)
+* added ExecutorServiceAdapter class as a standard wrapper for a Spring TaskExecutor
+* reduced backport-concurrent support to TaskExecutor adapters
+* added @Async annotation and AsyncAnnotationAdvisor (namespace support coming in M3)
+* EJB 3.1's @Asynchronous annotation gets detected and supported by default as well
+* ApplicationListener beans get obtained on demand, supporting non-singletons as well
+* ApplicationListeners will be called in the order according to the Ordered contract
+* generified ApplicationListener interface, narrowing the event type to be received
+* introduced SmartApplicationListener interface for supported event/source types
+* generified Transaction/Hibernate/Jdo/JpaCallback with generic "doInXxx" return type
+* HibernateOperations uses generic parameter/return types where possible
+* JdoOperations uses generic parameter/return types where possible (following JDO 2.1)
+* removed "flush" operation from JdoDialect (fully relying on JDO 2.0+ compliance now)
+* added JDO 2.1 compliant StandardPersistenceManagerProxy/SpringPersistenceManagerProxy
+* Spring-created EntityManagers support JPA 2.0 draft API ("unwrap", "getQueryBuilder")
+* Spring initiates JPA 2.0 query timeout with remaining Spring transaction timeout
+* added support for WebSphere's ResourceAdapter-managed messaging transactions
+* made SpringBeanAutowiringInterceptor callback signature compatible with WebSphere
+* WebSphereUowTransactionManager preserves original exception in case of rollback
+* added "flush()" method to TransactionStatus and TransactionSynchronization interfaces
+* test context manager automatically flushes transactions before rolling back
+* DefaultLobHandler uses explicit Blob/Clob access for reading when "wrapAsLob"=true
+* fixed JmsException/JmsUtils to fully avoid NPEs in case of cause messages being null
+* fixed MessageListenerAdapter's "getSubscriptionName()" to work without delegate as well
+* fixed HTTP invoker to support resolution of multi-level primitive array classes again
+* deprecated support for JMS 1.0.2 providers (JmsTemplate102 etc)
+* introduced top-level HTTP support package "org.springframework.http"
+* introduced RestTemplate facility in package "org.springframework.web.client"
+* introduced OXM support package (originating from Spring Web Services)
+* introduced OXM-based MarshallingMessageConverter for Spring JMS
+* introduced OXM-based MarshallingView for Spring MVC
+* refined @PathVariable handling in MVC handler methods
+* updated Spring Portlet MVC infrastructure and mocks for Portlet API 2.0
+* added resource and event methods to Portlet HandlerAdapter/HandlerInterceptor
+* added resolveException method for resource requests to HandlerExceptionResolver
+* introduced Resource/EventAwareController subinterfaces of Portlet Controller
+* introduced @Action/@Render/@Resource/@EventMapping annotations for Portlet MVC
+* added @RequestHeader support for Portlet MVC (based on Portlet request properties)
+* introduced @CookieValue annotation for Servlet and Portlet MVC handler methods
+* @RequestMapping type-level param constraints taken into account consistently
+* optional boolean parameters in MVC handler methods resolve to "false" if not present
+* "url" macro in "spring.ftl" performs standard Servlet URL encoding automatically
+
 
 Changes in version 3.0.0.M1 (2008-12-05)
 ----------------------------------------
@@ -16,6 +683,7 @@ Changes in version 3.0.0.M1 (2008-12-05)
 * removed ContextLoaderServlet and Log4jConfigServlet
 * deprecated form controller hierarchy in favor of @MVC form object handling
 * deprecated JUnit 3.8 test class hierarchy in favor of test context framework
+* revised TaskExecutor interface to extend "java.util.concurrent.Executor" now
 * introduced Spring EL parser in org.springframework.expression package
 * introduced #{...} expression support in bean definitions
 * introduced @Value annotation for embedded expression support

build-spring-framework/resources/notice.txt

@@ -1,6 +1,6 @@
    ======================================================================
    == NOTICE file corresponding to section 4 d of the Apache License,  ==
-   == Version 2.0, for the Spring Web Flow distribution.               ==
+   == Version 2.0, for the Spring Framework distribution.              ==
    ======================================================================
 
    This product includes software developed by
@@ -18,5 +18,5 @@
    The names "Spring", "Spring Framework", and "Spring Web Flow" must
    not be used to endorse or promote products derived from this
    software without prior written permission. For written permission,
-   please contact rod.johnson@interface21.com or juergen.hoeller@interface21.com.
+   please contact enquiries@springsource.com.
 

build-spring-framework/resources/readme.txt

@@ -1,28 +1,27 @@
-SPRING FRAMEWORK 3.0 M1 (December 2008)
----------------------------------------
-http://www.springframework.org
+SPRING FRAMEWORK 3.0.7 (December 2011)
+--------------------------------------
+http://www.springsource.org
 
 1. INTRODUCTION
----------------
 
-This is the first milestone of Spring 3.0 which is scheduled for final release in Q2 2009.
-This release updates the entire codebase for Java 5+ and introduces EL and REST support.
+Spring Framework 3.0 is the next generation of Spring: fully Java 5 based,
+EL enabled, REST enabled, and with support for JSR-330 (Dependency
+Injection) and JSR-303 (Bean Validation).
 
 2. RELEASE NOTES
-----------------
 
-This release comes without reference documentation. For the time being, please consult
-the provided javadoc for details on the new features.
+This release comes with complete reference documentation. For further
+details, consult the provided javadoc for specific packages and classes.
 
 3. DISTRIBUTION JAR FILES
--------------------------
 
-The Spring Framework module jar files can be found in the 'dist' directory. Note that
-this release does not contain a 'spring.jar' file anymore. Furthermore, the jar file
-names follow bundle repository conventions now.
+The Spring Framework module jar files can be found in the 'dist'
+directory. Note that this release does not contain a 'spring.jar' file
+anymore, in contrast to previous Spring generations. Furthermore, the jar
+file names now follow bundle repository conventions.
 
 4. GETTING STARTED
-------------------
 
-Check out the provided PetClinic sample application. It has been partially updated
-for Spring 3.0 already.
+Please consult the blog examples at http://blog.springsource.com as well
+as sections of interest in the reference documentation. Sample
+applications and related material are provided as separate downloads.

build.properties

@@ -1,22 +1,30 @@
-version=3.0.0
-release.type=integration
-natural.name=spring-framework
-project.name=Spring Framework
-project.key=SPR
-ivy.cache.dir=${basedir}/../ivy-cache
-integration.repo.dir=${basedir}/../integration-repo
-javadoc.exclude.package.names=org/springframework/samples/**
-javadoc.max.memory=256M
-
-# For when releasing
-#release.type=release
-#build.stamp=RELEASE
-
-# For when releasing milestones
-#release.type=milestone
-#build.stamp=M1
-
-# For development in trunk
-#release.type=integration
-
-
+version=3.0.7
+# osgi ranges
+spring.osgi.range.nq=${version:[=.=.=, =.=.+1)}
+spring.osgi.range="${spring.osgi.range.nq}"
+aj.osgi.range="[1.5.4, 2.0.0)"
+
+#
+#release.type=integration
+natural.name=spring-framework
+project.name=Spring Framework
+project.key=SPR
+ivy.cache.dir=${basedir}/../ivy-cache
+integration.repo.dir=${basedir}/../integration-repo
+license.dir=${basedir}/../build-spring-framework/resources
+javadoc.exclude.package.names=org/springframework/samples/**
+javadoc.max.memory=256M
+test.vm.args=-Xmx1024M -XX:MaxPermSize=512M -XX:+HeapDumpOnOutOfMemoryError
+compiler.args=-enableJavadoc -warn:none
+
+# For when releasing
+release.type=release
+build.stamp=RELEASE
+
+# For when releasing milestones
+#release.type=milestone
+#build.stamp=M1
+
+# For development in trunk
+#release.type=integration
+#build.stamp=BUILD-SNAPSHOT

build.versions

@@ -0,0 +1,5 @@
+#common dependency versions
+aspectj.version=1.6.8.RELEASE
+slf4j.version=1.5.3
+junit.version=4.7.0
+testng.version=5.10.0

ci-build.properties

@@ -0,0 +1,6 @@
+# properties used by Bamboo build plan at http://build.springframework.org/build/admin/buildConfiguration.action?buildKey=SPR-TRUNKQUICK
+# run in conjunction with ANT_OPTS='-XX:MaxPermSize=512m -Xmx1024m'
+compiler.args=-enableJavadoc -warn:none
+java.awt.headless=true
+ci.build=true
+test.vm.args=-XX:MaxPermSize=512m -Xmx1024m

eclipse-code-formatter.xml

@@ -0,0 +1,267 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<profiles version="11">
+<profile kind="CodeFormatterProfile" name="Spring" version="11">
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.align_type_members_on_columns" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_line_comments" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.tabulation.size" value="4"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_imports" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.continuation_indentation" value="2"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_binary_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_assignment" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_member_type" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" value="80"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.indent_parameter_description" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_html" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_source_code" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indentation.size" value="4"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.lineSplit" value="120"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_header" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_binary_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_field" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_block_comments" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_binary_expression" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.wrap_before_binary_operator" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_after_package" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode" value="enabled"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_after_imports" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.problem.assertIdentifier" value="error"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_empty_lines" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
+<setting id="org.eclipse.jdt.core.compiler.source" value="1.5"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.line_length" value="120"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.compliance" value="1.5"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.compact_else_if" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_switch" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.problem.enumIdentifier" value="error"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" value="false"/>
+<setting id="org.eclipse.jdt.core.compiler.codegen.targetPlatform" value="1.5"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_if" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.indent_root_tags" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_enum_constants" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.tabulation.char" value="tab"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_package" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_method" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_block" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" value="insert"/>
+</profile>
+</profiles>

org.springframework.aop/.classpath

@@ -1,19 +1,22 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src/main/java"/>
-	<classpathentry kind="src" path="src/main/resources"/>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java"/>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/resources"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="var" path="IVY_CACHE/org.aopalliance/com.springsource.org.aopalliance/1.0.0/com.springsource.org.aopalliance-1.0.0.jar" sourcepath="/IVY_CACHE/org.aopalliance/com.springsource.org.aopalliance/1.0.0/com.springsource.org.aopalliance-sources-1.0.0.jar"/>
-	<classpathentry kind="var" path="IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1/com.springsource.org.apache.commons.logging-1.1.1.jar" sourcepath="/IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1/com.springsource.org.apache.commons.logging-sources-1.1.1.jar"/>
-	<classpathentry kind="var" path="IVY_CACHE/com.jamonapi/com.springsource.com.jamonapi/2.4.0/com.springsource.com.jamonapi-2.4.0.jar" sourcepath="/IVY_CACHE/com.jamonapi/com.springsource.com.jamonapi/2.4.0/com.springsource.com.jamonapi-sources-2.4.0.jar"/>
-	<classpathentry kind="var" path="IVY_CACHE/net.sourceforge.cglib/com.springsource.net.sf.cglib/2.1.3/com.springsource.net.sf.cglib-2.1.3.jar" sourcepath="/IVY_CACHE/net.sourceforge.cglib/com.springsource.net.sf.cglib/2.1.3/com.springsource.net.sf.cglib-sources-2.1.3.jar"/>
-	<classpathentry kind="var" path="IVY_CACHE/org.apache.log4j/com.springsource.org.apache.log4j/1.2.15/com.springsource.org.apache.log4j-1.2.15.jar" sourcepath="/IVY_CACHE/org.apache.log4j/com.springsource.org.apache.log4j/1.2.15/com.springsource.org.apache.log4j-sources-1.2.15.jar"/>
-	<classpathentry kind="var" path="IVY_CACHE/org.junit/com.springsource.org.junit/4.5.0/com.springsource.org.junit-4.5.0.jar" sourcepath="/IVY_CACHE/org.junit/com.springsource.org.junit/4.5.0/com.springsource.org.junit-sources-4.5.0.jar"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/org.springframework.beans"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/org.springframework.core"/>
-	<classpathentry kind="var" path="IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.pool/1.3.0/com.springsource.org.apache.commons.pool-1.3.0.jar" sourcepath="/IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.pool/1.3.0/com.springsource.org.apache.commons.pool-sources-1.3.0.jar"/>
-	<classpathentry kind="var" path="IVY_CACHE/org.aspectj/com.springsource.org.aspectj.weaver/1.6.2.RELEASE/com.springsource.org.aspectj.weaver-1.6.2.RELEASE.jar"/>
-	<classpathentry kind="output" path="target/classes"/>
-</classpath>
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry kind="src" path="src/main/resources"/>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java"/>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/resources"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.aopalliance/com.springsource.org.aopalliance/1.0.0/com.springsource.org.aopalliance-1.0.0.jar" sourcepath="/IVY_CACHE/org.aopalliance/com.springsource.org.aopalliance/1.0.0/com.springsource.org.aopalliance-sources-1.0.0.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1/com.springsource.org.apache.commons.logging-1.1.1.jar" sourcepath="/IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1/com.springsource.org.apache.commons.logging-sources-1.1.1.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.easymock/com.springsource.org.easymock/2.5.1/com.springsource.org.easymock-2.5.1.jar" sourcepath="/IVY_CACHE/org.easymock/com.springsource.org.easymock/2.5.1/com.springsource.org.easymock-sources-2.5.1.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/com.jamonapi/com.springsource.com.jamonapi/2.4.0/com.springsource.com.jamonapi-2.4.0.jar" sourcepath="/IVY_CACHE/com.jamonapi/com.springsource.com.jamonapi/2.4.0/com.springsource.com.jamonapi-sources-2.4.0.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/net.sourceforge.cglib/com.springsource.net.sf.cglib/2.2.0/com.springsource.net.sf.cglib-2.2.0.jar" sourcepath="/IVY_CACHE/net.sourceforge.cglib/com.springsource.net.sf.cglib/2.1.3/com.springsource.net.sf.cglib-sources-2.1.3.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.apache.log4j/com.springsource.org.apache.log4j/1.2.15/com.springsource.org.apache.log4j-1.2.15.jar" sourcepath="/IVY_CACHE/org.apache.log4j/com.springsource.org.apache.log4j/1.2.15/com.springsource.org.apache.log4j-sources-1.2.15.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.junit/com.springsource.org.junit/4.7.0/com.springsource.org.junit-4.7.0.jar" sourcepath="/IVY_CACHE/org.junit/com.springsource.org.junit/4.7.0/com.springsource.org.junit-sources-4.7.0.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.pool/1.3.0/com.springsource.org.apache.commons.pool-1.3.0.jar" sourcepath="/IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.pool/1.3.0/com.springsource.org.apache.commons.pool-sources-1.3.0.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.aspectj/com.springsource.org.aspectj.weaver/1.6.8.RELEASE/com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar" sourcepath="IVY_CACHE/org.aspectj/com.springsource.org.aspectj.weaver/1.6.8.RELEASE/com.springsource.org.aspectj.weaver-sources-1.6.8.RELEASE.jar"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/org.springframework.beans"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/org.springframework.core"/>
+	<classpathentry kind="lib" path="/org.springframework.asm/target/artifacts/org.springframework.asm.jar" sourcepath="/org.springframework.asm/target/artifacts/org.springframework.asm-sources.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE"/>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

org.springframework.aop/.settings/org.eclipse.jdt.core.prefs

@@ -1,4 +1,4 @@
-#Fri Oct 24 15:07:09 EDT 2008
+#Wed Jul 15 00:01:31 PDT 2009
 eclipse.preferences.version=1
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
@@ -10,3 +10,259 @@ org.eclipse.jdt.core.compiler.debug.sourceFile=generate
 org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
 org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
 org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_assignment=0
+org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
+org.eclipse.jdt.core.formatter.comment.line_length=80
+org.eclipse.jdt.core.formatter.compact_else_if=true
+org.eclipse.jdt.core.formatter.continuation_indentation=2
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_empty_lines=false
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.lineSplit=80
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
+org.eclipse.jdt.core.formatter.tabulation.char=tab
+org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true

org.springframework.aop/.settings/org.eclipse.jdt.ui.prefs

@@ -0,0 +1,4 @@
+#Fri Dec 12 11:37:26 PST 2008
+eclipse.preferences.version=1
+formatter_profile=org.eclipse.jdt.ui.default.eclipse_profile
+formatter_settings_version=11

org.springframework.aop/aop.iml

@@ -11,96 +11,17 @@
     </content>
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="inheritedJdk" />
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$IVY_CACHE$/org.aopalliance/com.springsource.org.aopalliance/1.0.0/com.springsource.org.aopalliance-1.0.0.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$IVY_CACHE$/org.aopalliance/com.springsource.org.aopalliance/1.0.0/com.springsource.org.aopalliance-sources-1.0.0.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$IVY_CACHE$/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1/com.springsource.org.apache.commons.logging-1.1.1.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$IVY_CACHE$/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1/com.springsource.org.apache.commons.logging-sources-1.1.1.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$IVY_CACHE$/org.apache.commons/com.springsource.org.apache.commons.pool/1.4.0/com.springsource.org.apache.commons.pool-1.4.0.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$IVY_CACHE$/org.apache.commons/com.springsource.org.apache.commons.pool/1.4.0/com.springsource.org.apache.commons.pool-sources-1.4.0.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$IVY_CACHE$/org.aspectj/com.springsource.org.aspectj.weaver/1.6.2.RELEASE/com.springsource.org.aspectj.weaver-1.6.2.RELEASE.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$IVY_CACHE$/org.aspectj/com.springsource.org.aspectj.weaver/1.6.2.RELEASE/com.springsource.org.aspectj.weaver-sources-1.6.2.RELEASE.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$IVY_CACHE$/com.jamonapi/com.springsource.com.jamonapi/2.4.0/com.springsource.com.jamonapi-2.4.0.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$IVY_CACHE$/com.jamonapi/com.springsource.com.jamonapi/2.4.0/com.springsource.com.jamonapi-sources-2.4.0.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$IVY_CACHE$/net.sourceforge.cglib/com.springsource.net.sf.cglib/2.1.3/com.springsource.net.sf.cglib-2.1.3.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$IVY_CACHE$/net.sourceforge.cglib/com.springsource.net.sf.cglib/2.1.3/com.springsource.net.sf.cglib-sources-2.1.3.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$IVY_CACHE$/org.apache.log4j/com.springsource.org.apache.log4j/1.2.15/com.springsource.org.apache.log4j-1.2.15.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$IVY_CACHE$/org.apache.log4j/com.springsource.org.apache.log4j/1.2.15/com.springsource.org.apache.log4j-sources-1.2.15.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$IVY_CACHE$/org.junit/com.springsource.org.junit/4.5.0/com.springsource.org.junit-4.5.0.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="jar://$IVY_CACHE$/org.junit/com.springsource.org.junit/4.5.0/com.springsource.org.junit-sources-4.5.0.jar!/" />
-        </SOURCES>
-      </library>
-    </orderEntry>
     <orderEntry type="module" module-name="beans" />
     <orderEntry type="module" module-name="core" />
+    <orderEntry type="library" name="AOP Alliance" level="project" />
+    <orderEntry type="library" name="AspectJ" level="project" />
+    <orderEntry type="library" name="CGLIB" level="project" />
+    <orderEntry type="library" name="Commons Logging" level="project" />
+    <orderEntry type="library" name="Commons Pool" level="project" />
+    <orderEntry type="library" name="EasyMock" level="project" />
+    <orderEntry type="library" name="Jamon" level="project" />
+    <orderEntry type="library" name="JUnit" level="project" />
+    <orderEntry type="library" name="Log4j" level="project" />
   </component>
   <component name="copyright">
     <Base>

org.springframework.aop/build.xml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project name="org.springframework.aop">
 	<property file="${basedir}/../build.properties"/>
+	<property file="${basedir}/../build.versions"/>
 	<import file="${basedir}/../build-spring-framework/package-bundle.xml"/>
 	<import file="${basedir}/../spring-build/standard/default.xml"/>
 </project>

org.springframework.aop/ivy.xml

@@ -11,6 +11,7 @@
 
 	<configurations>
 		<include file="${spring.build.dir}/common/default-ivy-configurations.xml"/>
+		<conf name="commons-logging" extends="runtime" description="JARs needed to run with Commons Logging"/>
 		<conf name="aspectj" extends="runtime" description="JARs needed to run with AspectJ"/>
 		<conf name="bytecode-proxy" extends="runtime" description="JARs needed to run with CGLIB bytecode proxies"/>
 		<conf name="jamon" extends="runtime" description="JARs needed to run with JamonAPI"/>
@@ -20,20 +21,24 @@
 	<publications>
 		<artifact name="${ant.project.name}"/>
 		<artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
+		<artifact name="license" type="license" ext="txt"/>
+		<artifact name="notice" type="notice" ext="txt"/>
 	</publications>
 
 	<dependencies>
 		<dependency org="com.jamonapi" name="com.springsource.com.jamonapi" rev="2.4.0" conf="optional, jamon->compile"/>
-		<dependency org="net.sourceforge.cglib" name="com.springsource.net.sf.cglib" rev="2.1.3" conf="optional, bytecode-proxy->compile"/>
+		<dependency org="net.sourceforge.cglib" name="com.springsource.net.sf.cglib" rev="2.2.0" conf="optional, bytecode-proxy->compile"/>
 		<dependency org="org.aopalliance" name="com.springsource.org.aopalliance" rev="1.0.0" conf="compile->compile"/>
-		<dependency org="org.apache.commons" name="com.springsource.org.apache.commons.logging" rev="1.1.1" conf="compile->compile"/>
-		<dependency org="org.apache.commons" name="com.springsource.org.apache.commons.pool" rev="1.4.0" conf="optional, pooling->compile"/>
-		<dependency org="org.aspectj" name="com.springsource.org.aspectj.weaver" rev="1.6.2.RELEASE" conf="optional, aspectj->compile"/>
+		<dependency org="org.apache.commons" name="com.springsource.org.apache.commons.logging" rev="1.1.1" conf="compile, commons-logging->compile"/>
+		<dependency org="org.apache.commons" name="com.springsource.org.apache.commons.pool" rev="1.5.3" conf="optional, pooling->compile"/>
+		<dependency org="org.aspectj" name="com.springsource.org.aspectj.weaver" rev="${aspectj.version}" conf="optional, aspectj->compile"/>
 		<dependency org="org.springframework" name="org.springframework.beans" rev="latest.integration" conf="compile->compile"/>
 		<dependency org="org.springframework" name="org.springframework.core" rev="latest.integration" conf="compile->compile"/>
 		<!-- test dependencies -->
 		<dependency org="org.apache.log4j" name="com.springsource.org.apache.log4j" rev="1.2.15" conf="test->runtime"/>
-		<dependency org="org.junit" name="com.springsource.org.junit" rev="4.5.0" conf="test->runtime"/>
+		<dependency org="org.easymock" name="com.springsource.org.easymock" rev="2.5.1" conf="test->compile"/>
+		<dependency org="org.junit" name="com.springsource.org.junit" rev="${junit.version}" conf="test->runtime"/>
+		<dependency org="org.springframework" name="org.springframework.asm" rev="latest.integration" conf="test->runtime"/>
 	</dependencies>
 
 </ivy-module>

org.springframework.aop/pom.xml

@@ -1,46 +1,80 @@
-<?xml version="1.0"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<groupId>org.springframework</groupId>
-	<artifactId>org.springframework.aop</artifactId>
-	<packaging>jar</packaging>
-	<name>Spring Core Abstractions and Utilities</name>
-	<version>3.0.0.M1</version>
-	<repositories>
-		<repository>
-			<id>com.springsource.repository.bundles.external</id>
-			<name>SpringSource Enterprise Bundle Repository - External Bundle Releases</name>
-			<url>http://repository.springsource.com/maven/bundles/external</url>
-		</repository>		
-	</repositories>
-	<build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <source>1.5</source>
-                    <target>1.5</target>
-                </configuration>
-            </plugin>
-		</plugins>
-	</build>
-	<dependencies>
-		<dependency>
-			<groupId>commons-logging</groupId>
-			<artifactId>commons-logging</artifactId>
-			<version>1.1.1</version>
-		</dependency>
-		<dependency>
-		    <groupId>org.aopalliance</groupId>
-		    <artifactId>com.springsource.org.aopalliance</artifactId>
-		    <version>1.0.0</version>
-		</dependency>		
-		<dependency>
-		    <groupId>org.apache.commons</groupId>
-		    <artifactId>com.springsource.org.apache.commons.pool</artifactId>
-		    <version>1.4.0</version>
-			<optional>true</optional>
-		</dependency>
-	</dependencies>
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.springframework</groupId>
+  <artifactId>spring-aop</artifactId>
+  <packaging>jar</packaging>
+  <version>3.0.7.RELEASE</version>
+  <parent>
+    <groupId>org.springframework</groupId>
+    <artifactId>spring-parent</artifactId>
+    <relativePath>../org.springframework.spring-parent</relativePath>
+    <version>3.0.7.RELEASE</version>
+  </parent>
+
+  <dependencies>
+    <dependency>
+      <groupId>com.jamonapi</groupId>
+      <artifactId>jamon</artifactId>
+      <version>2.4</version>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>cglib</groupId>
+      <artifactId>cglib-nodep</artifactId>
+      <version>2.2</version>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>aopalliance</groupId>
+      <artifactId>aopalliance</artifactId>
+      <version>1.0</version>
+      <scope>compile</scope>
+    </dependency>
+    <!-- common logging dependency is in spring-core -->
+    <dependency>
+      <groupId>commons-pool</groupId>
+      <artifactId>commons-pool</artifactId>
+      <version>1.5.3</version>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>org.aspectj</groupId>
+      <artifactId>aspectjweaver</artifactId>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-asm</artifactId>
+      <version>${project.version}</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-beans</artifactId>
+      <version>${project.version}</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-core</artifactId>
+      <version>${project.version}</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>log4j</groupId>
+      <artifactId>log4j</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.easymock</groupId>
+      <artifactId>easymock</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

org.springframework.aop/src/main/java/org/springframework/aop/ClassFilter.java

@@ -34,7 +34,7 @@ public interface ClassFilter {
 	 * @param clazz the candidate target class
 	 * @return whether the advice should apply to the given target class
 	 */
-	boolean matches(Class clazz);
+	boolean matches(Class<?> clazz);
 
 
 	/**

org.springframework.aop/src/main/java/org/springframework/aop/DynamicIntroductionAdvice.java

@@ -43,6 +43,6 @@ public interface DynamicIntroductionAdvice extends Advice {
 	 * @param intf the interface to check
 	 * @return whether the advice implements the specified interface
 	 */
-	boolean implementsInterface(Class intf);
+	boolean implementsInterface(Class<?> intf);
 
 }

org.springframework.aop/src/main/java/org/springframework/aop/MethodMatcher.java

@@ -57,7 +57,7 @@ public interface MethodMatcher {
 	 * the candidate class must be taken to be the method's declaring class)
 	 * @return whether or not this method matches statically
 	 */
-	boolean matches(Method method, Class targetClass);
+	boolean matches(Method method, Class<?> targetClass);
 
 	/**
 	 * Is this MethodMatcher dynamic, that is, must a final call be made on the
@@ -86,7 +86,7 @@ public interface MethodMatcher {
 	 * @return whether there's a runtime match
 	 * @see MethodMatcher#matches(Method, Class)
 	 */
-	boolean matches(Method method, Class targetClass, Object[] args);
+	boolean matches(Method method, Class<?> targetClass, Object[] args);
 
 
 	/**

org.springframework.aop/src/main/java/org/springframework/aop/TargetClassAware.java

@@ -34,6 +34,6 @@ public interface TargetClassAware {
 	 * (typically a proxy configuration or an actual proxy).
 	 * @return the target Class, or <code>null</code> if not known
 	 */
-	Class getTargetClass();
+	Class<?> getTargetClass();
 
 }

org.springframework.aop/src/main/java/org/springframework/aop/TargetSource.java

@@ -1,5 +1,5 @@
 /*<
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -39,7 +39,7 @@ public interface TargetSource extends TargetClassAware {
 	 * target class.
 	 * @return the type of targets returned by this {@link TargetSource}
 	 */
-	Class getTargetClass();
+	Class<?> getTargetClass();
 
 	/**
 	 * Will all calls to {@link #getTarget()} return the same object?

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AbstractAspectJAdvice.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,7 @@ package org.springframework.aop.aspectj;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -139,9 +140,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 
 	private boolean argumentsIntrospected = false;
 
-	// The actual type is java.lang.reflect.Type,
-	// but for JDK 1.4 compatibility we use Object as the static type.
-	private Object discoveredReturningGenericType;
+	private Type discoveredReturningGenericType;
 	// Note: Unlike return type, no such generic information is needed for the throwing type,
 	// since Java doesn't allow exception types to be parameterized.
 
@@ -295,7 +294,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		return this.discoveredReturningType;
 	}
 
-	protected Object getDiscoveredReturningGenericType() {
+	protected Type getDiscoveredReturningGenericType() {
 		return this.discoveredReturningGenericType;
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJAfterReturningAdvice.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -69,21 +69,11 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice implement
 	 */
 	private boolean shouldInvokeOnReturnValueOf(Method method, Object returnValue) {
 		Class type = getDiscoveredReturningType();
-		Object genericType = getDiscoveredReturningGenericType();
+		Type genericType = getDiscoveredReturningGenericType();
 		// If we aren't dealing with a raw type, check if  generic parameters are assignable.
 		return (ClassUtils.isAssignableValue(type, returnValue) &&
-				(genericType == null || genericType == type || GenericTypeMatcher.isAssignable(genericType, method)));
-	}
-
-
-	/**
-	 * Inner class to avoid a static JDK 1.5 dependency for generic type matching.
-	 */
-	private static class GenericTypeMatcher {
-
-		public static boolean isAssignable(Object genericType, Method method) {
-			return TypeUtils.isAssignable((Type) genericType, method.getGenericReturnType());
-		}
+				(genericType == null || genericType == type ||
+						TypeUtils.isAssignable(genericType, method.getGenericReturnType())));
 	}
 
 }

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/AspectJExpressionPointcut.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,11 +16,13 @@
 
 package org.springframework.aop.aspectj;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
 import java.lang.reflect.Method;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.aopalliance.intercept.MethodInvocation;
 import org.apache.commons.logging.Log;
@@ -28,6 +30,7 @@ import org.apache.commons.logging.LogFactory;
 import org.aspectj.weaver.BCException;
 import org.aspectj.weaver.patterns.NamePattern;
 import org.aspectj.weaver.reflect.ReflectionWorld;
+import org.aspectj.weaver.reflect.ShadowMatchImpl;
 import org.aspectj.weaver.tools.ContextBasedMatcher;
 import org.aspectj.weaver.tools.FuzzyBoolean;
 import org.aspectj.weaver.tools.JoinPointMatch;
@@ -51,6 +54,7 @@ import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
@@ -74,28 +78,24 @@ import org.springframework.util.StringUtils;
 public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {
 
-	private static final Set<PointcutPrimitive> DEFAULT_SUPPORTED_PRIMITIVES = new HashSet<PointcutPrimitive>();
+	private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<PointcutPrimitive>();
 
 	static {
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);
-		DEFAULT_SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);
 	}
 
 
 	private static final Log logger = LogFactory.getLog(AspectJExpressionPointcut.class);
 
-	private final Map<Method, ShadowMatch> shadowMatchCache = new HashMap<Method, ShadowMatch>();
-
-	private PointcutParser pointcutParser;
-
 	private Class pointcutDeclarationScope;
 
 	private String[] pointcutParameterNames = new String[0];
@@ -104,26 +104,15 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 	private BeanFactory beanFactory;
 
-	private PointcutExpression pointcutExpression;
+	private transient PointcutExpression pointcutExpression;
+
+	private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
 
 
 	/**
 	 * Create a new default AspectJExpressionPointcut.
 	 */
 	public AspectJExpressionPointcut() {
-		this(DEFAULT_SUPPORTED_PRIMITIVES);
-	}
-
-	/**
-	 * Create a new AspectJExpressionPointcut with the given supported primitives.
-	 * @param supportedPrimitives Set of {@link org.aspectj.weaver.tools.PointcutPrimitive}
-	 * instances
-	 */
-	public AspectJExpressionPointcut(Set supportedPrimitives) {
-		this.pointcutParser =
-				PointcutParser.getPointcutParserSupportingSpecifiedPrimitivesAndUsingContextClassloaderForResolution(
-						supportedPrimitives);
-		this.pointcutParser.registerPointcutDesignatorHandler(new BeanNamePointcutDesignatorHandler());
 	}
 
 	/**
@@ -133,7 +122,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * @param paramTypes the parameter types for the pointcut
 	 */
 	public AspectJExpressionPointcut(Class declarationScope, String[] paramNames, Class[] paramTypes) {
-		this(DEFAULT_SUPPORTED_PRIMITIVES);
 		this.pointcutDeclarationScope = declarationScope;
 		if (paramNames.length != paramTypes.length) {
 			throw new IllegalStateException(
@@ -198,15 +186,30 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * Build the underlying AspectJ pointcut expression.
 	 */
 	private PointcutExpression buildPointcutExpression() {
+		PointcutParser parser = initializePointcutParser();
 		PointcutParameter[] pointcutParameters = new PointcutParameter[this.pointcutParameterNames.length];
 		for (int i = 0; i < pointcutParameters.length; i++) {
-			pointcutParameters[i] = this.pointcutParser.createPointcutParameter(
+			pointcutParameters[i] = parser.createPointcutParameter(
 					this.pointcutParameterNames[i], this.pointcutParameterTypes[i]);
 		}
-		return this.pointcutParser.parsePointcutExpression(
+		return parser.parsePointcutExpression(
 				replaceBooleanOperators(getExpression()), this.pointcutDeclarationScope, pointcutParameters);
 	}
 
+	/**
+	 * Initialize the underlying AspectJ pointcut parser.
+	 */
+	private PointcutParser initializePointcutParser() {
+		ClassLoader cl = (this.beanFactory instanceof ConfigurableBeanFactory ?
+				((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() :
+				Thread.currentThread().getContextClassLoader());
+		PointcutParser parser =
+				PointcutParser.getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(
+						SUPPORTED_PRIMITIVES, cl);
+		parser.registerPointcutDesignatorHandler(new BeanNamePointcutDesignatorHandler());
+		return parser;
+	}
+
 	/**
 	 * If a pointcut expression has been specified in XML, the user cannot
 	 * write <code>and</code> as "&&" (though &amp;&amp; will work).
@@ -214,12 +217,13 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * <p>This method converts back to <code>&&</code> for the AspectJ pointcut parser.
 	 */
 	private String replaceBooleanOperators(String pcExpr) {
-		pcExpr = StringUtils.replace(pcExpr," and "," && ");
-		pcExpr = StringUtils.replace(pcExpr, " or ", " || ");
-		pcExpr = StringUtils.replace(pcExpr, " not ", " ! ");
-		return pcExpr;
+		String result = StringUtils.replace(pcExpr, " and ", " && ");
+		result = StringUtils.replace(result, " or ", " || ");
+		result = StringUtils.replace(result, " not ", " ! ");
+		return result;
 	}
 
+
 	/**
 	 * Return the underlying AspectJ pointcut expression.
 	 */
@@ -228,7 +232,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		return this.pointcutExpression;
 	}
 
-
 	public boolean matches(Class targetClass) {
 		checkReadyToMatch();
 		try {
@@ -243,15 +246,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	public boolean matches(Method method, Class targetClass, boolean beanHasIntroductions) {
 		checkReadyToMatch();
 		Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
-		ShadowMatch shadowMatch = null;
-		try {
-			shadowMatch = getShadowMatch(targetMethod, method);
-		}
-		catch (ReflectionWorld.ReflectionWorldException ex) {
-			// Could neither introspect the target class nor the proxy class ->
-			// let's simply consider this method as non-matching.
-			return false;
-		}
+		ShadowMatch shadowMatch = getShadowMatch(targetMethod, method);
 
 		// Special handling for this, target, @this, @target, @annotation
 		// in Spring - we can optimize since we know we have exactly this class,
@@ -279,17 +274,8 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 	public boolean matches(Method method, Class targetClass, Object[] args) {
 		checkReadyToMatch();
-		ShadowMatch shadowMatch = null;
-		ShadowMatch originalShadowMatch = null;
-		try {
-			shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
-			originalShadowMatch = getShadowMatch(method, method);
-		}
-		catch (ReflectionWorld.ReflectionWorldException ex) {
-			// Could neither introspect the target class nor the proxy class ->
-			// let's simply consider this method as non-matching.
-			return false;
-		}
+		ShadowMatch shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
+		ShadowMatch originalShadowMatch = getShadowMatch(method, method);
 
 		// Bind Spring AOP proxy to AspectJ "this" and Spring AOP target to AspectJ target,
 		// consistent with return of MethodInvocationProceedingJoinPoint
@@ -364,24 +350,38 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	}
 
 	private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
-		synchronized (this.shadowMatchCache) {
-			ShadowMatch shadowMatch = this.shadowMatchCache.get(targetMethod);
-			if (shadowMatch == null) {
-				try {
-					shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
-				}
-				catch (ReflectionWorld.ReflectionWorldException ex) {
-					// Failed to introspect target method, probably because it has been loaded
-					// in a special ClassLoader. Let's try the original method instead...
-					if (targetMethod == originalMethod) {
-						throw ex;
+		// Avoid lock contention for known Methods through concurrent access...
+		ShadowMatch shadowMatch = this.shadowMatchCache.get(targetMethod);
+		if (shadowMatch == null) {
+			synchronized (this.shadowMatchCache) {
+				// Not found - now check again with full lock...
+				shadowMatch = this.shadowMatchCache.get(targetMethod);
+				if (shadowMatch == null) {
+					try {
+						shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
 					}
-					shadowMatch = this.pointcutExpression.matchesMethodExecution(originalMethod);
+					catch (ReflectionWorld.ReflectionWorldException ex) {
+						// Failed to introspect target method, probably because it has been loaded
+						// in a special ClassLoader. Let's try the original method instead...
+						if (targetMethod == originalMethod) {
+							shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
+						}
+						else {
+							try {
+								shadowMatch = this.pointcutExpression.matchesMethodExecution(originalMethod);
+							}
+							catch (ReflectionWorld.ReflectionWorldException ex2) {
+								// Could neither introspect the target class nor the proxy class ->
+								// let's simply consider this method as non-matching.
+								shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
+							}
+						}
+					}
+					this.shadowMatchCache.put(targetMethod, shadowMatch);
 				}
-				this.shadowMatchCache.put(targetMethod, shadowMatch);
 			}
-			return shadowMatch;
 		}
+		return shadowMatch;
 	}
 
 
@@ -460,11 +460,10 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 	/**
 	 * Matcher class for the BeanNamePointcutDesignatorHandler.
-	 *
 	 * <p>Dynamic match tests for this matcher always return true,
 	 * since the matching decision is made at the proxy creation time.
 	 * For static match tests, this matcher abstains to allow the overall
-	 * pointcut to match even when negation is used with the bean() poitncut.
+	 * pointcut to match even when negation is used with the bean() pointcut.
 	 */
 	private class BeanNameContextMatcher implements ContextBasedMatcher {
 
@@ -530,4 +529,18 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		}
 	}
 
+
+	//---------------------------------------------------------------------
+	// Serialization support
+	//---------------------------------------------------------------------
+
+	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+		// Rely on default serialization, just initialize state after deserialization.
+		ois.defaultReadObject();
+
+		// Initialize transient fields.
+		// pointcutExpression will be initialized lazily by checkReadyToMatch()
+		this.shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
+	}
+
 }

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/MethodInvocationProceedingJoinPoint.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@
 package org.springframework.aop.aspectj;
 
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 
 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
@@ -26,6 +27,7 @@ import org.aspectj.lang.reflect.SourceLocation;
 import org.aspectj.runtime.internal.AroundClosure;
 
 import org.springframework.aop.ProxyMethodInvocation;
+import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
 import org.springframework.util.Assert;
 
 /**
@@ -44,6 +46,7 @@ import org.springframework.util.Assert;
  * @author Rod Johnson
  * @author Juergen Hoeller
  * @author Adrian Colyer
+ * @author Ramnivas Laddad
  * @since 2.0
  */
 public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint, JoinPoint.StaticPart {
@@ -129,37 +132,34 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 		return ProceedingJoinPoint.METHOD_EXECUTION;
 	}
 
+	public int getId() {
+		// TODO: It's just an adapter but returning 0 might still have side effects...
+		return 0;
+	}
+
 	public JoinPoint.StaticPart getStaticPart() {
 		return this;
 	}
-	
 
 	public String toShortString() {
-		return "execution(" + this.methodInvocation.getMethod().getName() + ")";
+		return "execution(" + getSignature().toShortString() + ")";
 	}
 
 	public String toLongString() {
-		return getClass().getName() + ": execution: [" + this.methodInvocation + "]";
+		return "execution(" + getSignature().toLongString() + ")";
 	}
 
-	@Override
 	public String toString() {
-		return getClass().getName() + ": " + toShortString();
+		return "execution(" + getSignature().toString() + ")";
 	}
 
 
 	/**
 	 * Lazily initialized MethodSignature.
 	 */
-	private class MethodSignatureImpl implements Signature, MethodSignature {
+	private class MethodSignatureImpl implements MethodSignature {
 
-		public String toShortString() {
-			return methodInvocation.getMethod().getName();
-		}
-
-		public String toLongString() {
-			return methodInvocation.getMethod().toString();
-		}
+		private volatile String[] parameterNames;
 
 		public String getName() {
 			return methodInvocation.getMethod().getName();
@@ -190,15 +190,75 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 		}
 
 		public String[] getParameterNames() {
-			// TODO consider allowing use of ParameterNameDiscoverer, or tying into
-			// parameter names exposed for argument binding...
-			throw new UnsupportedOperationException(
-					"Parameter names cannot be determined unless compiled by AspectJ compiler");
+			if (this.parameterNames == null) {
+				this.parameterNames = (new LocalVariableTableParameterNameDiscoverer()).getParameterNames(getMethod());
+			}
+			return this.parameterNames;
 		}
 
 		public Class[] getExceptionTypes() {
 			return methodInvocation.getMethod().getExceptionTypes();
 		}
+
+		public String toShortString() {
+			return toString(false, false, false, false);
+		}
+
+		public String toLongString() {
+			return toString(true, true, true, true);
+		}
+
+		public String toString() {
+			return toString(false, true, false, true);
+		}
+
+		private String toString(boolean includeModifier, boolean includeReturnTypeAndArgs,
+				boolean useLongReturnAndArgumentTypeName, boolean useLongTypeName) {
+			StringBuilder sb = new StringBuilder();
+			if (includeModifier) {
+				sb.append(Modifier.toString(getModifiers()));
+				sb.append(" ");
+			}
+			if (includeReturnTypeAndArgs) {
+				appendType(sb, getReturnType(), useLongReturnAndArgumentTypeName);
+				sb.append(" ");
+			}
+			appendType(sb, getDeclaringType(), useLongTypeName);
+			sb.append(".");
+			sb.append(getMethod().getName());
+			sb.append("(");
+			Class[] parametersTypes = getParameterTypes();
+			appendTypes(sb, parametersTypes, includeReturnTypeAndArgs, useLongReturnAndArgumentTypeName);
+			sb.append(")");
+			return sb.toString();
+		}
+
+		private void appendTypes(StringBuilder sb, Class<?>[] types,
+				boolean includeArgs, boolean useLongReturnAndArgumentTypeName) {
+			if (includeArgs) {
+				for (int size = types.length, i = 0; i < size; i++) {
+					appendType(sb, types[i], useLongReturnAndArgumentTypeName);
+					if (i < size - 1) {
+						sb.append(",");
+					}
+				}
+			}
+			else {
+				if (types.length != 0) {
+					sb.append("..");
+				}
+			}
+		}
+
+		private void appendType(StringBuilder sb, Class<?> type, boolean useLongTypeName) {
+			if (type.isArray()) {
+				appendType(sb, type.getComponentType(), useLongTypeName);
+				sb.append("[]");
+			}
+			else {
+				sb.append(useLongTypeName ? type.getName() : type.getSimpleName());
+			}
+		}
 	}
 
 

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/RuntimeTestWalker.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -73,7 +73,7 @@ class RuntimeTestWalker {
 		catch (IllegalAccessException illegalAccessEx) {
 			// Famous last words... but I don't see how this can happen given the
 			// makeAccessible call above
-			throw new IllegalStateException("Unable to access ShadowMatchImpl.runtimeTest field.");
+			throw new IllegalStateException("Unable to access ShadowMatchImpl.residualTest field");
 		}
 	}
 
@@ -83,15 +83,18 @@ class RuntimeTestWalker {
 	 * then it tests subtype sensitive vars.
 	 */
 	public boolean testsSubtypeSensitiveVars() {
-		return new SubtypeSensitiveVarTypeTestVisitor().testsSubtypeSensitiveVars(this.runtimeTest);
+		return (this.runtimeTest != null &&
+				new SubtypeSensitiveVarTypeTestVisitor().testsSubtypeSensitiveVars(this.runtimeTest));
 	}
 
 	public boolean testThisInstanceOfResidue(Class thisClass) {
-		return new ThisInstanceOfResidueTestVisitor(thisClass).thisInstanceOfMatches(this.runtimeTest);
+		return (this.runtimeTest != null &&
+				new ThisInstanceOfResidueTestVisitor(thisClass).thisInstanceOfMatches(this.runtimeTest));
 	}
 
 	public boolean testTargetInstanceOfResidue(Class targetClass) {
-		return new TargetInstanceOfResidueTestVisitor(targetClass).targetInstanceOfMatches(this.runtimeTest);
+		return (this.runtimeTest != null &&
+				new TargetInstanceOfResidueTestVisitor(targetClass).targetInstanceOfMatches(this.runtimeTest));
 	}
 
 
@@ -139,8 +142,7 @@ class RuntimeTestWalker {
 			try {
 				Field varTypeField = ReflectionVar.class.getDeclaredField("varType");
 				ReflectionUtils.makeAccessible(varTypeField);
-				Integer varTypeValue = (Integer) varTypeField.get(v);
-				return varTypeValue.intValue();
+				return (Integer) varTypeField.get(v);
 			}
 			catch (NoSuchFieldException noSuchFieldEx) {
 				throw new IllegalStateException("the version of aspectjtools.jar / aspectjweaver.jar " +
@@ -150,7 +152,7 @@ class RuntimeTestWalker {
 			catch (IllegalAccessException illegalAccessEx) {
 				// Famous last words... but I don't see how this can happen given the
 				// makeAccessible call above
-				throw new IllegalStateException("Unable to access ReflectionVar.varType field.");
+				throw new IllegalStateException("Unable to access ReflectionVar.varType field");
 			}
 		}
 	}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/SimpleAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -84,7 +84,7 @@ public class SimpleAspectInstanceFactory implements AspectInstanceFactory {
 	 * <p>The default implementation simply returns <code>Ordered.LOWEST_PRECEDENCE</code>.
 	 * @param aspectClass the aspect class
 	 */
-	protected int getOrderForAspectClass(Class aspectClass) {
+	protected int getOrderForAspectClass(Class<?> aspectClass) {
 		return Ordered.LOWEST_PRECEDENCE;
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/SingletonAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -74,7 +74,7 @@ public class SingletonAspectInstanceFactory implements AspectInstanceFactory {
 	 * <p>The default implementation simply returns <code>Ordered.LOWEST_PRECEDENCE</code>.
 	 * @param aspectClass the aspect class
 	 */
-	protected int getOrderForAspectClass(Class aspectClass) {
+	protected int getOrderForAspectClass(Class<?> aspectClass) {
 		return Ordered.LOWEST_PRECEDENCE;
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/AbstractAspectJAdvisorFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -69,17 +69,12 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	 * Find and return the first AspectJ annotation on the given method
 	 * (there <i>should</i> only be one anyway...)
 	 */
-	protected static AspectJAnnotation findAspectJAnnotationOnMethod(Method aMethod) {
-		Class<? extends Annotation>[] classesToLookFor = (Class<? extends Annotation>[]) new Class[] {
-					Before.class, 
-					Around.class, 
-					After.class, 
-					AfterReturning.class, 
-					AfterThrowing.class, 
-					Pointcut.class
-				};
+	@SuppressWarnings("unchecked")
+	protected static AspectJAnnotation findAspectJAnnotationOnMethod(Method method) {
+		Class<? extends Annotation>[] classesToLookFor = new Class[] {
+				Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};
 		for (Class<? extends Annotation> c : classesToLookFor) {
-			AspectJAnnotation foundAnnotation = findAnnotation(aMethod, c);
+			AspectJAnnotation foundAnnotation = findAnnotation(method, c);
 			if (foundAnnotation != null) {
 				return foundAnnotation;
 			}
@@ -117,12 +112,11 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	 * when compiled by ajc with the -1.5 flag, yet they cannot be consumed by Spring AOP.
 	 */
 	public boolean isAspect(Class<?> clazz) {
-		return (AjTypeSystem.getAjType(clazz).isAspect() && 
-				hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
+		return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
 	}
 
 	private boolean hasAspectAnnotation(Class<?> clazz) {
-		return clazz.isAnnotationPresent(Aspect.class);
+		return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
 	}
 
 	/**
@@ -199,7 +193,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		// come first in the advice declaration.
 		int typeOffset = paramTypes.length - argNames.length;
 		for (int i = 0; i < ret.length; i++) {
-			ret[i] = paramTypes[i+typeOffset];			
+			ret[i] = paramTypes[i + typeOffset];
 		}
 		return ret;
 	}
@@ -212,7 +206,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		AtAfterReturning,
 		AtAfterThrowing,
 		AtAround
-	};
+	}
 
 
 	/**
@@ -221,9 +215,10 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	 */
 	protected static class AspectJAnnotation<A extends Annotation> {
 
-		private static Map<Class,AspectJAnnotationType> annotationTypes = new HashMap<Class,AspectJAnnotationType>();
+		private static final String[] EXPRESSION_PROPERTIES = new String[] {"value", "pointcut"};
 
-		private static final String[] EXPRESSION_PROPERTIES = new String[]{"value", "pointcut"};
+		private static Map<Class, AspectJAnnotationType> annotationTypes =
+				new HashMap<Class, AspectJAnnotationType>();
 
 		static {
 			annotationTypes.put(Pointcut.class,AspectJAnnotationType.AtPointcut);
@@ -235,47 +230,48 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		}
 
 		private final A annotation;
-		private AspectJAnnotationType annotationType;
-		private final String expression;
-		private final String argNames;
 
-		public AspectJAnnotation(A aspectjAnnotation) {
-			this.annotation = aspectjAnnotation;
-			for (Class type : annotationTypes.keySet()) {
-				if (type.isInstance(this.annotation)) {
-					this.annotationType = annotationTypes.get(type);
-					break;
-				}
-			}
-			if (this.annotationType == null) {
-				throw new IllegalStateException("Unknown annotation type: " + this.annotation.toString());
-			}
+		private final AspectJAnnotationType annotationType;
 
+		private final String pointcutExpression;
+
+		private final String argumentNames;
+
+		public AspectJAnnotation(A annotation) {
+			this.annotation = annotation;
+			this.annotationType = determineAnnotationType(annotation);
 			// We know these methods exist with the same name on each object,
 			// but need to invoke them reflectively as there isn't a common interface.
 			try {
-				this.expression = resolveExpression();
-				this.argNames = (String)
-						this.annotation.getClass().getMethod("argNames", (Class[]) null).invoke(this.annotation);
+				this.pointcutExpression = resolveExpression(annotation);
+				this.argumentNames = (String) annotation.getClass().getMethod("argNames").invoke(annotation);
 			}
 			catch (Exception ex) {
-				throw new IllegalArgumentException(aspectjAnnotation + " cannot be an AspectJ annotation", ex);
+				throw new IllegalArgumentException(annotation + " cannot be an AspectJ annotation", ex);
 			}
 		}
 
-		private String resolveExpression() throws Exception {
+		private AspectJAnnotationType determineAnnotationType(A annotation) {
+			for (Class type : annotationTypes.keySet()) {
+				if (type.isInstance(annotation)) {
+					return annotationTypes.get(type);
+				}
+			}
+			throw new IllegalStateException("Unknown annotation type: " + annotation.toString());
+		}
+
+		private String resolveExpression(A annotation) throws Exception {
 			String expression = null;
-			for (int i = 0; i < EXPRESSION_PROPERTIES.length; i++) {
-				String methodName = EXPRESSION_PROPERTIES[i];
+			for (String methodName : EXPRESSION_PROPERTIES) {
 				Method method;
 				try {
-					method = this.annotation.getClass().getDeclaredMethod(methodName);
+					method = annotation.getClass().getDeclaredMethod(methodName);
 				}
 				catch (NoSuchMethodException ex) {
 					method = null;
 				}
 				if (method != null) {
-					String candidate = (String) method.invoke(this.annotation);
+					String candidate = (String) method.invoke(annotation);
 					if (StringUtils.hasText(candidate)) {
 						expression = candidate;
 					}
@@ -293,11 +289,11 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		}
 
 		public String getPointcutExpression() {
-			return this.expression;
+			return this.pointcutExpression;
 		}
 
-		public String getArgNames() {
-			return this.argNames;
+		public String getArgumentNames() {
+			return this.argumentNames;
 		}
 
 		@Override
@@ -321,7 +317,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 			if (annotation == null) {
 				return null;
 			}
-			StringTokenizer strTok = new StringTokenizer(annotation.getArgNames(), ",");
+			StringTokenizer strTok = new StringTokenizer(annotation.getArgumentNames(), ",");
 			if (strTok.countTokens() > 0) {
 				String[] names = new String[strTok.countTokens()];
 				for (int i = 0; i < names.length; i++) {

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/AnnotationAwareAspectJAutoProxyCreator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Pattern;
 
+import org.springframework.aop.Advisor;
 import org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator;
 import org.springframework.beans.factory.ListableBeanFactory;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
@@ -78,9 +79,9 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 
 
 	@Override
-	protected List findCandidateAdvisors() {
+	protected List<Advisor> findCandidateAdvisors() {
 		// Add all the Spring advisors found according to superclass rules.
-		List advisors = super.findCandidateAdvisors();
+		List<Advisor> advisors = super.findCandidateAdvisors();
 		// Build Advisors for all AspectJ aspects in the bean factory.
 		advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
 		return advisors;

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/AspectJProxyFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ import org.springframework.aop.aspectj.AspectJProxyUtils;
 import org.springframework.aop.framework.AopConfigException;
 import org.springframework.aop.framework.ProxyCreatorSupport;
 import org.springframework.aop.support.AopUtils;
+import org.springframework.core.OrderComparator;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
@@ -116,10 +117,11 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	 * @see #makeAdvisorChainAspectJCapableIfNecessary()
 	 */
 	private void addAdvisorsFromAspectInstanceFactory(MetadataAwareAspectInstanceFactory instanceFactory) {
-		List advisors = this.aspectFactory.getAdvisors(instanceFactory);
+		List<Advisor> advisors = this.aspectFactory.getAdvisors(instanceFactory);
 		advisors = AopUtils.findAdvisorsThatCanApply(advisors, getTargetClass());
-		addAllAdvisors((Advisor[]) advisors.toArray(new Advisor[advisors.size()]));
-		makeAdvisorChainAspectJCapableIfNecessary();
+		AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(advisors);
+		OrderComparator.sort(advisors);
+		addAdvisors(advisors);
 	}
 
 	/**
@@ -154,18 +156,6 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 		return instanceFactory;
 	}
 
-	/**
-	 * Add any special-purpose {@link Advisor Advisors} needed for AspectJ support
-	 * to the chain. {@link #updateAdvisorArray() Updates} the {@link Advisor} array
-	 * and fires {@link #adviceChanged events}.
-	 */
-	private void makeAdvisorChainAspectJCapableIfNecessary() {
-		if (AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(getAdvisorsInternal())) {
-			updateAdvisorArray();
-			adviceChanged();
-		}
-	}
-
 	/**
 	 * Get the singleton aspect instance for the supplied aspect type. An instance
 	 * is created if one cannot be found in the instance cache.

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/AspectMetadata.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -67,13 +67,23 @@ public class AspectMetadata {
 	 * @param aspectClass the aspect class
 	 * @param aspectName the name of the aspect
 	 */
-	public AspectMetadata(Class aspectClass, String aspectName) {
+	public AspectMetadata(Class<?> aspectClass, String aspectName) {
 		this.aspectName = aspectName;
-		this.ajType = AjTypeSystem.getAjType(aspectClass);
-		
-		if (!this.ajType.isAspect()) {
+
+		Class<?> currClass = aspectClass;
+		AjType ajType = null;
+		while (!currClass.equals(Object.class)) {
+			AjType ajTypeToCheck = AjTypeSystem.getAjType(currClass);
+			if (ajTypeToCheck.isAspect()) {
+				ajType = ajTypeToCheck;
+				break;
+			}
+			currClass = currClass.getSuperclass();
+		}
+		if (ajType == null) {
 			throw new IllegalArgumentException("Class '" + aspectClass.getName() + "' is not an @AspectJ aspect");
 		}
+		this.ajType = ajType;
 		if (this.ajType.getDeclarePrecedence().length > 0) {
 			throw new IllegalArgumentException("DeclarePrecendence not presently supported in Spring AOP");
 		}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/BeanFactoryAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,8 +23,8 @@ import org.springframework.core.annotation.Order;
 import org.springframework.util.ClassUtils;
 
 /**
- * AspectInstanceFactory backed by a Spring
- * {@link org.springframework.beans.factory.BeanFactory}.
+ * {@link org.springframework.aop.aspectj.AspectInstanceFactory} implementation
+ * backed by a Spring {@link org.springframework.beans.factory.BeanFactory}.
  *
  * <p>Note that this may instantiate multiple times if using a prototype,
  * which probably won't give the semantics you expect. 
@@ -100,12 +100,12 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 	 * @see org.springframework.core.annotation.Order
 	 */
 	public int getOrder() {
-		Class type = this.beanFactory.getType(this.name);
+		Class<?> type = this.beanFactory.getType(this.name);
 		if (type != null) {
 			if (Ordered.class.isAssignableFrom(type) && this.beanFactory.isSingleton(this.name)) {
 				return ((Ordered) this.beanFactory.getBean(this.name)).getOrder();
 			}
-			Order order = (Order) type.getAnnotation(Order.class);
+			Order order = type.getAnnotation(Order.class);
 			if (order != null) {
 				return order.value();
 			}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/InstantiationModelAwarePointcutAdvisorImpl.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -58,18 +58,13 @@ class InstantiationModelAwarePointcutAdvisorImpl
 	
 	private String aspectName;
 	
-	private Boolean isBeforeAdvice = null;
+	private Boolean isBeforeAdvice;
 
-	private Boolean isAfterAdvice = null;
+	private Boolean isAfterAdvice;
 
 
-	public InstantiationModelAwarePointcutAdvisorImpl(
-			AspectJAdvisorFactory af, 
-			AspectJExpressionPointcut ajexp, 
-			MetadataAwareAspectInstanceFactory aif, 
-			Method method,
-			int declarationOrderInAspect,
-			String aspectName) {
+	public InstantiationModelAwarePointcutAdvisorImpl(AspectJAdvisorFactory af,  AspectJExpressionPointcut ajexp,
+			MetadataAwareAspectInstanceFactory aif,  Method method, int declarationOrderInAspect, String aspectName) {
 
 		this.declaredPointcut = ajexp;
 		this.method = method;

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/LazySingletonAspectInstanceFactoryDecorator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,11 +16,10 @@
 
 package org.springframework.aop.aspectj.annotation;
 
-import org.springframework.core.Ordered;
 import org.springframework.util.Assert;
 
 /**
- * Decorator to cause a MetadataAwareAspectInstanceFactory to instantiate only once.
+ * Decorator to cause a {@link MetadataAwareAspectInstanceFactory} to instantiate only once.
  *
  * @author Rod Johnson
  * @author Juergen Hoeller
@@ -30,7 +29,7 @@ public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwar
 
 	private final MetadataAwareAspectInstanceFactory maaif;
 
-	private Object materialized;
+	private volatile Object materialized;
 
 
 	/**
@@ -42,30 +41,32 @@ public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwar
 		this.maaif = maaif;
 	}
 
+
 	public synchronized Object getAspectInstance() {
 		if (this.materialized == null) {
-			this.materialized = this.maaif.getAspectInstance();
+			synchronized (this) {
+				if (this.materialized == null) {
+					this.materialized = this.maaif.getAspectInstance();
+				}
+			}
 		}
 		return this.materialized;
 	}
 
-	public ClassLoader getAspectClassLoader() {
-		return this.maaif.getAspectClassLoader();
-	}
-
 	public boolean isMaterialized() {
 		return (this.materialized != null);
 	}
 
+	public ClassLoader getAspectClassLoader() {
+		return this.maaif.getAspectClassLoader();
+	}
+
 	public AspectMetadata getAspectMetadata() {
 		return this.maaif.getAspectMetadata();
 	}
 
 	public int getOrder() {
-		if (this.maaif instanceof Ordered) {
-			return ((Ordered) this.maaif).getOrder();
-		}
-		return Ordered.LOWEST_PRECEDENCE;
+		return this.maaif.getOrder();
 	}
 
 

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/SimpleMetadataAwareAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -57,8 +57,8 @@ public class SimpleMetadataAwareAspectInstanceFactory extends SimpleAspectInstan
 	 * @param aspectClass the aspect class
 	 */
 	@Override
-	protected int getOrderForAspectClass(Class aspectClass) {
-		Order order = (Order) aspectClass.getAnnotation(Order.class);
+	protected int getOrderForAspectClass(Class<?> aspectClass) {
+		Order order = aspectClass.getAnnotation(Order.class);
 		if (order != null) {
 			return order.value();
 		}
@@ -66,4 +66,3 @@ public class SimpleMetadataAwareAspectInstanceFactory extends SimpleAspectInstan
 	}
 
 }
-

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/SingletonMetadataAwareAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -58,8 +58,8 @@ public class SingletonMetadataAwareAspectInstanceFactory extends SingletonAspect
 	 * @see org.springframework.core.annotation.Order
 	 */
 	@Override
-	protected int getOrderForAspectClass(Class aspectClass) {
-		Order order = (Order) aspectClass.getAnnotation(Order.class);
+	protected int getOrderForAspectClass(Class<?> aspectClass) {
+		Order order = aspectClass.getAnnotation(Order.class);
 		if (order != null) {
 			return order.value();
 		}

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/package-info.java

@@ -0,0 +1,10 @@
+
+/**
+ *
+ * Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
+ * 
+ * <p>Normally to be used through an AspectJAutoProxyCreator rather than directly.
+ *
+ */
+package org.springframework.aop.aspectj.annotation;
+

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/annotation/package.html

@@ -1,9 +0,0 @@
-<html>
-<body>
-
-Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
-
-<p>Normally to be used through an AspectJAutoProxyCreator rather than directly.
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/autoproxy/AspectJPrecedenceComparator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -55,14 +55,14 @@ class AspectJPrecedenceComparator implements Comparator {
 	private static final int LOWER_PRECEDENCE = 1;
 	private static final int NOT_COMPARABLE = 0;
 
-	private final Comparator advisorComparator;
+	private final Comparator<? super Advisor> advisorComparator;
 
 
 	/**
 	 * Create a default AspectJPrecedenceComparator.
 	 */
 	public AspectJPrecedenceComparator() {
-		this.advisorComparator = new OrderComparator();
+		this.advisorComparator = OrderComparator.INSTANCE;
 	}
 
 	/**
@@ -70,7 +70,7 @@ class AspectJPrecedenceComparator implements Comparator {
 	 * for comparing {@link org.springframework.aop.Advisor} instances.
 	 * @param advisorComparator the Comparator to use for Advisors
 	 */
-	public AspectJPrecedenceComparator(Comparator advisorComparator) {
+	public AspectJPrecedenceComparator(Comparator<? super Advisor> advisorComparator) {
 		Assert.notNull(advisorComparator, "Advisor comparator must not be null");
 		this.advisorComparator = advisorComparator;
 	}
@@ -138,12 +138,8 @@ class AspectJPrecedenceComparator implements Comparator {
 	}
 
 	private boolean declaredInSameAspect(Advisor advisor1, Advisor advisor2) {
-		if (!(hasAspectName(advisor1) && hasAspectName(advisor2))) {
-			return false;
-		}
-		else {
-			return getAspectName(advisor1).equals(getAspectName(advisor2));
-		}
+		return (hasAspectName(advisor1) && hasAspectName(advisor2) &&
+				getAspectName(advisor1).equals(getAspectName(advisor2)));
 	}
 
 	private boolean hasAspectName(Advisor anAdvisor) {

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/autoproxy/package-info.java

@@ -0,0 +1,9 @@
+
+/**
+ *
+ * Base classes enabling auto-proxying based on AspectJ.
+ * Support for AspectJ annotation aspects resides in the "aspectj.annotation" package.
+ *
+ */
+package org.springframework.aop.aspectj.autoproxy;
+

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/autoproxy/package.html

@@ -1,8 +0,0 @@
-<html>
-<body>
-
-Base classes enabling auto-proxying based on AspectJ.
-Support for AspectJ annotation aspects resides in the "aspectj.annotation" package.
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/package-info.java

@@ -0,0 +1,15 @@
+
+/**
+ *
+ * AspectJ integration package. Includes Spring AOP advice implementations for AspectJ 5
+ * annotation-style methods, and an AspectJExpressionPointcut: a Spring AOP Pointcut
+ * implementation that allows use of the AspectJ pointcut expression language with the Spring AOP
+ * runtime framework.
+ * 
+ * <p>Note that use of this package does <i>not</i> require the use of the <code>ajc</code> compiler
+ * or AspectJ load-time weaver. It is intended to enable the use of a valuable subset of AspectJ
+ * functionality, with consistent semantics, with the proxy-based Spring AOP framework.
+ *
+ */
+package org.springframework.aop.aspectj;
+

org.springframework.aop/src/main/java/org/springframework/aop/aspectj/package.html

@@ -1,14 +0,0 @@
-<html>
-<body>
-
-AspectJ integration package. Includes Spring AOP advice implementations for AspectJ 5
-annotation-style methods, and an AspectJExpressionPointcut: a Spring AOP Pointcut
-implementation that allows use of the AspectJ pointcut expression language with the Spring AOP
-runtime framework.
-
-<p>Note that use of this package does <i>not</i> require the use of the <code>ajc</code> compiler
-or AspectJ load-time weaver. It is intended to enable the use of a valuable subset of AspectJ
-functionality, with consistent semantics, with the proxy-based Spring AOP framework.
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/config/AbstractInterceptorDrivenBeanDefinitionDecorator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,9 +21,9 @@ import java.util.List;
 import org.w3c.dom.Node;
 
 import org.springframework.aop.framework.ProxyFactoryBean;
-import org.springframework.beans.MutablePropertyValues;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinitionHolder;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.ManagedList;
@@ -34,22 +34,25 @@ import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
 
 /**
- * Base implementation for {@link org.springframework.beans.factory.xml.BeanDefinitionDecorator BeanDefinitionDecorators} wishing
- * to add an {@link org.aopalliance.intercept.MethodInterceptor interceptor} to the resulting
- * bean.
+ * Base implementation for
+ * {@link org.springframework.beans.factory.xml.BeanDefinitionDecorator BeanDefinitionDecorators}
+ * wishing to add an {@link org.aopalliance.intercept.MethodInterceptor interceptor}
+ * to the resulting bean.
  *
  * <p>This base class controls the creation of the {@link ProxyFactoryBean} bean definition
- * and wraps the original as an inner-bean definition for the <code>target</code> property of
- * {@link ProxyFactoryBean}.
+ * and wraps the original as an inner-bean definition for the <code>target</code> property
+ * of {@link ProxyFactoryBean}.
  *
  * <p>Chaining is correctly handled, ensuring that only one {@link ProxyFactoryBean} definition
- * is created. If a previous {@link org.springframework.beans.factory.xml.BeanDefinitionDecorator} already created the {@link org.springframework.aop.framework.ProxyFactoryBean}
- * then the interceptor is simply added to the existing definition.
+ * is created. If a previous {@link org.springframework.beans.factory.xml.BeanDefinitionDecorator}
+ * already created the {@link org.springframework.aop.framework.ProxyFactoryBean} then the
+ * interceptor is simply added to the existing definition.
  *
- * <p>Subclasses have only to create the <code>BeanDefinition</code> to the interceptor they
- * wish to add.
+ * <p>Subclasses have only to create the <code>BeanDefinition</code> to the interceptor that
+ * they wish to add.
  *
  * @author Rob Harrop
+ * @author Juergen Hoeller
  * @since 2.0
  * @see org.aopalliance.intercept.MethodInterceptor
  */
@@ -60,51 +63,54 @@ public abstract class AbstractInterceptorDrivenBeanDefinitionDecorator implement
 		
 		// get the root bean name - will be the name of the generated proxy factory bean
 		String existingBeanName = definitionHolder.getBeanName();
-		BeanDefinition existingDefinition = definitionHolder.getBeanDefinition();
+		BeanDefinition targetDefinition = definitionHolder.getBeanDefinition();
+		BeanDefinitionHolder targetHolder = new BeanDefinitionHolder(targetDefinition, existingBeanName + ".TARGET");
 
-		// delegate to subclass for interceptor def
+		// delegate to subclass for interceptor definition
 		BeanDefinition interceptorDefinition = createInterceptorDefinition(node);
 
 		// generate name and register the interceptor
 		String interceptorName = existingBeanName + "." + getInterceptorNameSuffix(interceptorDefinition);
-		BeanDefinitionReaderUtils.registerBeanDefinition(new BeanDefinitionHolder(interceptorDefinition, interceptorName), registry);
+		BeanDefinitionReaderUtils.registerBeanDefinition(
+				new BeanDefinitionHolder(interceptorDefinition, interceptorName), registry);
 
 		BeanDefinitionHolder result = definitionHolder;
 
-		if (!isProxyFactoryBeanDefinition(existingDefinition)) {
-
-			// create the proxy definitionHolder
+		if (!isProxyFactoryBeanDefinition(targetDefinition)) {
+			// create the proxy definition
 			RootBeanDefinition proxyDefinition = new RootBeanDefinition();
-			// create proxy factory bean definitionHolder
+			// create proxy factory bean definition
 			proxyDefinition.setBeanClass(ProxyFactoryBean.class);
-
-			// set up property values
-			MutablePropertyValues mpvs = new MutablePropertyValues();
-			proxyDefinition.setPropertyValues(mpvs);
-
+			proxyDefinition.setScope(targetDefinition.getScope());
+			proxyDefinition.setLazyInit(targetDefinition.isLazyInit());
 			// set the target
-			mpvs.addPropertyValue("target", existingDefinition);
-
+			proxyDefinition.setDecoratedDefinition(targetHolder);
+			proxyDefinition.getPropertyValues().add("target", targetHolder);
 			// create the interceptor names list
-			ManagedList interceptorList = new ManagedList();
-			mpvs.addPropertyValue("interceptorNames", interceptorList);
-
+			proxyDefinition.getPropertyValues().add("interceptorNames", new ManagedList<String>());
+			// copy autowire settings from original bean definition.
+			proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
+			proxyDefinition.setPrimary(targetDefinition.isPrimary());
+			if (targetDefinition instanceof AbstractBeanDefinition) {
+				proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
+			}
+			// wrap it in a BeanDefinitionHolder with bean name
 			result = new BeanDefinitionHolder(proxyDefinition, existingBeanName);
 		}
 
 		addInterceptorNameToList(interceptorName, result.getBeanDefinition());
-
 		return result;
-
 	}
 
+	@SuppressWarnings("unchecked")
 	private void addInterceptorNameToList(String interceptorName, BeanDefinition beanDefinition) {
-		List list = (List) beanDefinition.getPropertyValues().getPropertyValue("interceptorNames").getValue();
+		List<String> list = (List<String>)
+				beanDefinition.getPropertyValues().getPropertyValue("interceptorNames").getValue();
 		list.add(interceptorName);
 	}
 
 	private boolean isProxyFactoryBeanDefinition(BeanDefinition existingDefinition) {
-		return existingDefinition.getBeanClassName().equals(ProxyFactoryBean.class.getName());
+		return ProxyFactoryBean.class.getName().equals(existingDefinition.getBeanClassName());
 	}
 
 	protected String getInterceptorNameSuffix(BeanDefinition interceptorDefinition) {

org.springframework.aop/src/main/java/org/springframework/aop/config/AopConfigUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -93,7 +93,14 @@ public abstract class AopConfigUtils {
 	public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
 		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
 			BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
-			definition.getPropertyValues().addPropertyValue("proxyTargetClass", Boolean.TRUE);
+			definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
+		}
+	}
+
+	static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
+		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
+			BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
+			definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
 		}
 	}
 
@@ -113,7 +120,7 @@ public abstract class AopConfigUtils {
 		}
 		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
 		beanDefinition.setSource(source);
-		beanDefinition.getPropertyValues().addPropertyValue("order", Ordered.HIGHEST_PRECEDENCE);
+		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
 		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
 		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
 		return beanDefinition;

org.springframework.aop/src/main/java/org/springframework/aop/config/AopNamespaceUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -46,6 +46,11 @@ public abstract class AopNamespaceUtils {
 	 */
 	public static final String PROXY_TARGET_CLASS_ATTRIBUTE = "proxy-target-class";
 
+	/**
+	 * The <code>expose-proxy</code> attribute as found on AOP-related XML tags.
+	 */
+	private static final String EXPOSE_PROXY_ATTRIBUTE = "expose-proxy";
+
 
 	public static void registerAutoProxyCreatorIfNecessary(
 			ParserContext parserContext, Element sourceElement) {
@@ -98,11 +103,14 @@ public abstract class AopNamespaceUtils {
 
 	private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
 		if (sourceElement != null) {
-			boolean proxyTargetClass = Boolean.valueOf(
-					sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE)).booleanValue();
+			boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
 			if (proxyTargetClass) {
 				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
 			}
+			boolean exposeProxy = Boolean.valueOf(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
+			if (exposeProxy) {
+				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
+			}
 		}
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/config/AspectJAutoProxyBeanDefinitionParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -52,7 +52,7 @@ class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	private void addIncludePatterns(Element element, ParserContext parserContext, BeanDefinition beanDef) {
-		ManagedList includePatterns = new ManagedList();
+		ManagedList<TypedStringValue> includePatterns = new ManagedList<TypedStringValue>();
 		NodeList childNodes = element.getChildNodes();
 		for (int i = 0; i < childNodes.getLength(); i++) {
 			Node node = childNodes.item(i);
@@ -65,7 +65,7 @@ class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {
 		}
 		if (!includePatterns.isEmpty()) {
 			includePatterns.setSource(parserContext.extractSource(element));
-			beanDef.getPropertyValues().addPropertyValue("includePatterns", includePatterns);
+			beanDef.getPropertyValues().add("includePatterns", includePatterns);
 		}
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/config/ConfigBeanDefinitionParser.java

@@ -102,20 +102,17 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 
 		configureAutoProxyCreator(parserContext, element);
 
-		NodeList childNodes = element.getChildNodes();
-		for (int i = 0; i < childNodes.getLength(); i++) {
-			Node node = childNodes.item(i);
-			if (node.getNodeType() == Node.ELEMENT_NODE) {
-				String localName = node.getLocalName();
-				if (POINTCUT.equals(localName)) {
-					parsePointcut((Element) node, parserContext);
-				}
-				else if (ADVISOR.equals(localName)) {
-					parseAdvisor((Element) node, parserContext);
-				}
-				else if (ASPECT.equals(localName)) {
-					parseAspect((Element) node, parserContext);
-				}
+		List<Element> childElts = DomUtils.getChildElements(element);
+		for (Element elt: childElts) {
+			String localName = parserContext.getDelegate().getLocalName(elt);
+			if (POINTCUT.equals(localName)) {
+				parsePointcut(elt, parserContext);
+			}
+			else if (ADVISOR.equals(localName)) {
+				parseAdvisor(elt, parserContext);
+			}
+			else if (ASPECT.equals(localName)) {
+				parseAspect(elt, parserContext);
 			}
 		}
 
@@ -154,12 +151,12 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 
 			Object pointcut = parsePointcutProperty(advisorElement, parserContext);
 			if (pointcut instanceof BeanDefinition) {
-				advisorDef.getPropertyValues().addPropertyValue(POINTCUT, pointcut);
+				advisorDef.getPropertyValues().add(POINTCUT, pointcut);
 				parserContext.registerComponent(
 						new AdvisorComponentDefinition(advisorBeanName, advisorDef, (BeanDefinition) pointcut));
 			}
 			else if (pointcut instanceof String) {
-				advisorDef.getPropertyValues().addPropertyValue(POINTCUT, new RuntimeBeanReference((String) pointcut));
+				advisorDef.getPropertyValues().add(POINTCUT, new RuntimeBeanReference((String) pointcut));
 				parserContext.registerComponent(
 						new AdvisorComponentDefinition(advisorBeanName, advisorDef));
 			}
@@ -183,12 +180,12 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 					"'advice-ref' attribute contains empty value.", advisorElement, this.parseState.snapshot());
 		}
 		else {
-			advisorDefinition.getPropertyValues().addPropertyValue(
+			advisorDefinition.getPropertyValues().add(
 					ADVICE_BEAN_NAME, new RuntimeBeanNameReference(adviceRef));
 		}
 
 		if (advisorElement.hasAttribute(ORDER_PROPERTY)) {
-			advisorDefinition.getPropertyValues().addPropertyValue(
+			advisorDefinition.getPropertyValues().add(
 					ORDER_PROPERTY, advisorElement.getAttribute(ORDER_PROPERTY));
 		}
 
@@ -216,7 +213,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 			boolean adviceFoundAlready = false;
 			for (int i = 0; i < nodeList.getLength(); i++) {
 				Node node = nodeList.item(i);
-				if (isAdviceNode(node)) {
+				if (isAdviceNode(node, parserContext)) {
 					if (!adviceFoundAlready) {
 						adviceFoundAlready = true;
 						if (!StringUtils.hasText(aspectName)) {
@@ -264,12 +261,12 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	 * '<code>before</code>', '<code>after</code>', '<code>after-returning</code>',
 	 * '<code>after-throwing</code>' or '<code>around</code>'.
 	 */
-	private boolean isAdviceNode(Node aNode) {
+	private boolean isAdviceNode(Node aNode, ParserContext parserContext) {
 		if (!(aNode instanceof Element)) {
 			return false;
 		}
 		else {
-			String name = aNode.getLocalName();
+			String name = parserContext.getDelegate().getLocalName(aNode);
 			return (BEFORE.equals(name) || AFTER.equals(name) || AFTER_RETURNING_ELEMENT.equals(name) ||
 					AFTER_THROWING_ELEMENT.equals(name) || AROUND.equals(name));
 		}
@@ -317,18 +314,18 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 			List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {
 
 		try {
-			this.parseState.push(new AdviceEntry(adviceElement.getLocalName()));
+			this.parseState.push(new AdviceEntry(parserContext.getDelegate().getLocalName(adviceElement)));
 
 			// create the method factory bean
 			RootBeanDefinition methodDefinition = new RootBeanDefinition(MethodLocatingFactoryBean.class);
-			methodDefinition.getPropertyValues().addPropertyValue("targetBeanName", aspectName);
-			methodDefinition.getPropertyValues().addPropertyValue("methodName", adviceElement.getAttribute("method"));
+			methodDefinition.getPropertyValues().add("targetBeanName", aspectName);
+			methodDefinition.getPropertyValues().add("methodName", adviceElement.getAttribute("method"));
 			methodDefinition.setSynthetic(true);
 
 			// create instance factory definition
 			RootBeanDefinition aspectFactoryDef =
 					new RootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class);
-			aspectFactoryDef.getPropertyValues().addPropertyValue("aspectBeanName", aspectName);
+			aspectFactoryDef.getPropertyValues().add("aspectBeanName", aspectName);
 			aspectFactoryDef.setSynthetic(true);
 
 			// register the pointcut
@@ -341,7 +338,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 			advisorDefinition.setSource(parserContext.extractSource(adviceElement));
 			advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
 			if (aspectElement.hasAttribute(ORDER_PROPERTY)) {
-				advisorDefinition.getPropertyValues().addPropertyValue(
+				advisorDefinition.getPropertyValues().add(
 						ORDER_PROPERTY, aspectElement.getAttribute(ORDER_PROPERTY));
 			}
 
@@ -366,22 +363,22 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 			RootBeanDefinition methodDef, RootBeanDefinition aspectFactoryDef,
 			List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {
 
-		RootBeanDefinition adviceDefinition = new RootBeanDefinition(getAdviceClass(adviceElement));
+		RootBeanDefinition adviceDefinition = new RootBeanDefinition(getAdviceClass(adviceElement, parserContext));
 		adviceDefinition.setSource(parserContext.extractSource(adviceElement));
 
-		adviceDefinition.getPropertyValues().addPropertyValue(ASPECT_NAME_PROPERTY, aspectName);
-		adviceDefinition.getPropertyValues().addPropertyValue(DECLARATION_ORDER_PROPERTY, order);
+		adviceDefinition.getPropertyValues().add(ASPECT_NAME_PROPERTY, aspectName);
+		adviceDefinition.getPropertyValues().add(DECLARATION_ORDER_PROPERTY, order);
 
 		if (adviceElement.hasAttribute(RETURNING)) {
-			adviceDefinition.getPropertyValues().addPropertyValue(
+			adviceDefinition.getPropertyValues().add(
 					RETURNING_PROPERTY, adviceElement.getAttribute(RETURNING));
 		}
 		if (adviceElement.hasAttribute(THROWING)) {
-			adviceDefinition.getPropertyValues().addPropertyValue(
+			adviceDefinition.getPropertyValues().add(
 					THROWING_PROPERTY, adviceElement.getAttribute(THROWING));
 		}
 		if (adviceElement.hasAttribute(ARG_NAMES)) {
-			adviceDefinition.getPropertyValues().addPropertyValue(
+			adviceDefinition.getPropertyValues().add(
 					ARG_NAMES_PROPERTY, adviceElement.getAttribute(ARG_NAMES));
 		}
 
@@ -407,8 +404,8 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	/**
 	 * Gets the advice implementation class corresponding to the supplied {@link Element}.
 	 */
-	private Class getAdviceClass(Element adviceElement) {
-		String elementName = adviceElement.getLocalName();
+	private Class getAdviceClass(Element adviceElement, ParserContext parserContext) {
+		String elementName = parserContext.getDelegate().getLocalName(adviceElement);
 		if (BEFORE.equals(elementName)) {
 			return AspectJMethodBeforeAdvice.class;
 		}
@@ -507,7 +504,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 		RootBeanDefinition beanDefinition = new RootBeanDefinition(AspectJExpressionPointcut.class);
 		beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
 		beanDefinition.setSynthetic(true);
-		beanDefinition.getPropertyValues().addPropertyValue(EXPRESSION, expression);
+		beanDefinition.getPropertyValues().add(EXPRESSION, expression);
 		return beanDefinition;
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/config/MethodLocatingFactoryBean.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -30,7 +30,7 @@ import org.springframework.util.StringUtils;
  * @author Rob Harrop
  * @since 2.0
  */
-public class MethodLocatingFactoryBean implements FactoryBean, BeanFactoryAware {
+public class MethodLocatingFactoryBean implements FactoryBean<Method>, BeanFactoryAware {
 
 	private String targetBeanName;
 
@@ -41,8 +41,8 @@ public class MethodLocatingFactoryBean implements FactoryBean, BeanFactoryAware
 
 	/**
 	 * Set the name of the bean to locate the {@link Method} on.
-     * <p>This property is required.
-     * @param targetBeanName the name of the bean to locate the {@link Method} on
+	 * <p>This property is required.
+	 * @param targetBeanName the name of the bean to locate the {@link Method} on
 	 */
 	public void setTargetBeanName(String targetBeanName) {
 		this.targetBeanName = targetBeanName;
@@ -50,8 +50,8 @@ public class MethodLocatingFactoryBean implements FactoryBean, BeanFactoryAware
 
 	/**
 	 * Set the name of the {@link Method} to locate.
-     * <p>This property is required.
-     * @param methodName the name of the {@link Method} to locate
+	 * <p>This property is required.
+	 * @param methodName the name of the {@link Method} to locate
 	 */
 	public void setMethodName(String methodName) {
 		this.methodName = methodName;
@@ -78,11 +78,11 @@ public class MethodLocatingFactoryBean implements FactoryBean, BeanFactoryAware
 	}
 
 
-	public Object getObject() throws Exception {
+	public Method getObject() throws Exception {
 		return this.method;
 	}
 
-	public Class getObjectType() {
+	public Class<Method> getObjectType() {
 		return Method.class;
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/config/ScopedProxyBeanDefinitionDecorator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44,15 +44,18 @@ class ScopedProxyBeanDefinitionDecorator implements BeanDefinitionDecorator {
 		if (node instanceof Element) {
 			Element ele = (Element) node;
 			if (ele.hasAttribute(PROXY_TARGET_CLASS)) {
-				proxyTargetClass = Boolean.valueOf(ele.getAttribute(PROXY_TARGET_CLASS)).booleanValue();
+				proxyTargetClass = Boolean.valueOf(ele.getAttribute(PROXY_TARGET_CLASS));
 			}
 		}
 		
-		// Register the original bean definition as it will be referenced by the scoped proxy and is relevant for tooling (validation, navigation).
+		// Register the original bean definition as it will be referenced by the scoped proxy
+		// and is relevant for tooling (validation, navigation).
+		BeanDefinitionHolder holder =
+				ScopedProxyUtils.createScopedProxy(definition, parserContext.getRegistry(), proxyTargetClass);
 		String targetBeanName = ScopedProxyUtils.getTargetBeanName(definition.getBeanName());
-		parserContext.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(definition.getBeanDefinition(), targetBeanName));
-		
-		return ScopedProxyUtils.createScopedProxy(definition, parserContext.getRegistry(), proxyTargetClass);
+		parserContext.getReaderContext().fireComponentRegistered(
+				new BeanComponentDefinition(definition.getBeanDefinition(), targetBeanName));
+		return holder;
 	}
 
 }

org.springframework.aop/src/main/java/org/springframework/aop/config/package-info.java

@@ -0,0 +1,9 @@
+
+/**
+ *
+ * Support package for declarative AOP configuration,
+ * with XML schema being the primary configuration format.
+ *
+ */
+package org.springframework.aop.config;
+

org.springframework.aop/src/main/java/org/springframework/aop/config/package.html

@@ -1,8 +0,0 @@
-<html>
-<body>
-
-Support package for declarative AOP configuration,
-with XML schema being the primary configuration format.
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/framework/AbstractSingletonProxyFactoryBean.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -38,7 +38,7 @@ import org.springframework.util.ClassUtils;
  * @since 2.0
  */
 public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
-		implements FactoryBean, BeanClassLoaderAware, InitializingBean {
+		implements FactoryBean<Object>, BeanClassLoaderAware, InitializingBean {
 
 	private Object target;
 
@@ -196,7 +196,7 @@ public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
 		return this.proxy;
 	}
 
-	public Class getObjectType() {
+	public Class<?> getObjectType() {
 		if (this.proxy != null) {
 			return this.proxy.getClass();
 		}

org.springframework.aop/src/main/java/org/springframework/aop/framework/AdvisedSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,6 +20,8 @@ import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -38,7 +40,7 @@ import org.springframework.aop.target.EmptyTargetSource;
 import org.springframework.aop.target.SingletonTargetSource;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
-import org.springframework.util.ObjectUtils;
+import org.springframework.util.CollectionUtils;
 
 /**
  * Base class for AOP proxy configuration managers.
@@ -56,6 +58,7 @@ import org.springframework.util.ObjectUtils;
  * @author Juergen Hoeller
  * @see org.springframework.aop.framework.AopProxy
  */
+@SuppressWarnings("unchecked")
 public class AdvisedSupport extends ProxyConfig implements Advised {
 
 	/** use serialVersionUID from Spring 2.0 for interoperability */
@@ -159,7 +162,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		this.targetSource = EmptyTargetSource.forClass(targetClass);
 	}
 
-	public Class getTargetClass() {
+	public Class<?> getTargetClass() {
 		return this.targetSource.getTargetClass();
 	}
 
@@ -309,12 +312,30 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	/**
 	 * Add all of the given advisors to this proxy configuration.
 	 * @param advisors the advisors to register
+	 * @deprecated as of Spring 3.0, in favor of {@link #addAdvisors}
 	 */
+	@Deprecated
 	public void addAllAdvisors(Advisor[] advisors) {
+		addAdvisors(Arrays.asList(advisors));
+	}
+
+	/**
+	 * Add all of the given advisors to this proxy configuration.
+	 * @param advisors the advisors to register
+	 */
+	public void addAdvisors(Advisor... advisors) {
+		addAdvisors(Arrays.asList(advisors));
+	}
+
+	/**
+	 * Add all of the given advisors to this proxy configuration.
+	 * @param advisors the advisors to register
+	 */
+	public void addAdvisors(Collection<Advisor> advisors) {
 		if (isFrozen()) {
 			throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
 		}
-		if (!ObjectUtils.isEmpty(advisors)) {
+		if (!CollectionUtils.isEmpty(advisors)) {
 			for (Advisor advisor : advisors) {
 				if (advisor instanceof IntroductionAdvisor) {
 					validateIntroductionAdvisor((IntroductionAdvisor) advisor);
@@ -469,9 +490,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * Invoked when advice has changed.
 	 */
 	protected void adviceChanged() {
-		synchronized (this.methodCache) {
-			this.methodCache.clear();
-		}
+		this.methodCache.clear();
 	}
 
 	/**

org.springframework.aop/src/main/java/org/springframework/aop/framework/AopContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -46,7 +46,7 @@ public abstract class AopContext {
 	 * the controlling proxy configuration has been set to "true".
 	 * @see ProxyConfig#setExposeProxy
 	 */
-	private static final ThreadLocal currentProxy = new NamedThreadLocal("Current AOP proxy");
+	private static final ThreadLocal<Object> currentProxy = new NamedThreadLocal<Object>("Current AOP proxy");
 
 
 	/**
@@ -76,7 +76,12 @@ public abstract class AopContext {
 	 */
 	static Object setCurrentProxy(Object proxy) {
 		Object old = currentProxy.get();
-		currentProxy.set(proxy);
+		if (proxy != null) {
+			currentProxy.set(proxy);
+		}
+		else {
+			currentProxy.remove();
+		}
 		return old;
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/framework/AopProxyUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,10 @@ package org.springframework.aop.framework;
 import java.util.Arrays;
 
 import org.springframework.aop.SpringProxy;
+import org.springframework.aop.TargetClassAware;
+import org.springframework.aop.TargetSource;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.aop.target.SingletonTargetSource;
 import org.springframework.util.Assert;
 
 /**
@@ -34,6 +38,37 @@ import org.springframework.util.Assert;
  */
 public abstract class AopProxyUtils {
 
+	/**
+	 * Determine the ultimate target class of the given bean instance, traversing
+	 * not only a top-level proxy but any number of nested proxies as well -
+	 * as long as possible without side effects, that is, just for singleton targets.
+	 * @param candidate the instance to check (might be an AOP proxy)
+	 * @return the target class (or the plain class of the given object as fallback;
+	 * never <code>null</code>)
+	 * @see org.springframework.aop.TargetClassAware#getTargetClass()
+	 * @see org.springframework.aop.framework.Advised#getTargetSource()
+	 */
+	public static Class<?> ultimateTargetClass(Object candidate) {
+		Assert.notNull(candidate, "Candidate object must not be null");
+		Object current = candidate;
+		Class<?> result = null;
+		while (current instanceof TargetClassAware) {
+			result = ((TargetClassAware) current).getTargetClass();
+			Object nested = null;
+			if (current instanceof Advised) {
+				TargetSource targetSource = ((Advised) current).getTargetSource();
+				if (targetSource instanceof SingletonTargetSource) {
+					nested = ((SingletonTargetSource) targetSource).getTarget();
+				}
+			}
+			current = nested;
+		}
+		if (result == null) {
+			result = (AopUtils.isCglibProxy(candidate) ? candidate.getClass().getSuperclass() : candidate.getClass());
+		}
+		return result;
+	}
+
 	/**
 	 * Determine the complete set of interfaces to proxy for the given AOP configuration.
 	 * <p>This will always add the {@link Advised} interface unless the AdvisedSupport's

org.springframework.aop/src/main/java/org/springframework/aop/framework/Cglib2AopProxy.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -268,7 +268,7 @@ final class Cglib2AopProxy implements AopProxy, Serializable {
 
 		// Choose a "straight to target" interceptor. (used for calls that are
 		// unadvised but can return this). May be required to expose the proxy.
-		Callback targetInterceptor = null;
+		Callback targetInterceptor;
 		if (exposeProxy) {
 			targetInterceptor = isStatic ?
 					new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
@@ -316,12 +316,8 @@ final class Cglib2AopProxy implements AopProxy, Serializable {
 			// Now copy both the callbacks from mainCallbacks
 			// and fixedCallbacks into the callbacks array.
 			callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
-			for (int x = 0; x < mainCallbacks.length; x++) {
-				callbacks[x] = mainCallbacks[x];
-			}
-			for (int x = 0; x < fixedCallbacks.length; x++) {
-				callbacks[x + mainCallbacks.length] = fixedCallbacks[x];
-			}
+			System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
+			System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
 			this.fixedInterceptorOffset = mainCallbacks.length;
 		}
 		else {
@@ -610,7 +606,7 @@ final class Cglib2AopProxy implements AopProxy, Serializable {
 					targetClass = target.getClass();
 				}
 				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
-				Object retVal = null;
+				Object retVal;
 				// Check whether we only have one InvokerInterceptor: that is,
 				// no real advice, but just reflective invocation of the target.
 				if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {

org.springframework.aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -123,11 +123,9 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	 * @param proxiedInterfaces the interfaces to introspect
 	 */
 	private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
-		for (int i = 0; i < proxiedInterfaces.length; i++) {
-			Class proxiedInterface = proxiedInterfaces[i];
+		for (Class proxiedInterface : proxiedInterfaces) {
 			Method[] methods = proxiedInterface.getDeclaredMethods();
-			for (int j = 0; j < methods.length; j++) {
-				Method method = methods[j];
+			for (Method method : methods) {
 				if (AopUtils.isEqualsMethod(method)) {
 					this.equalsDefined = true;
 				}
@@ -148,7 +146,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	 * unless a hook method throws an exception.
 	 */
 	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-		MethodInvocation invocation = null;
+		MethodInvocation invocation;
 		Object oldProxy = null;
 		boolean setProxyContext = false;
 
@@ -171,7 +169,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 				return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
 			}
 
-			Object retVal = null;
+			Object retVal;
 
 			if (this.advised.exposeProxy) {
 				// Make invocation available if necessary.
@@ -179,7 +177,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 				setProxyContext = true;
 			}
 
-			// May be <code>null</code>. Get as late as possible to minimize the time we "own" the target,
+			// May be null. Get as late as possible to minimize the time we "own" the target,
 			// in case it comes from a pool.
 			target = targetSource.getTarget();
 			if (target != null) {
@@ -187,7 +185,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 			}
 
 			// Get the interception chain for this method.
-			List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
+			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
 
 			// Check whether we have any advice. If we don't, we can fallback on direct
 			// reflective invocation of the target, and avoid creating a MethodInvocation.
@@ -241,7 +239,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 			return false;
 		}
 
-		JdkDynamicAopProxy otherProxy = null;
+		JdkDynamicAopProxy otherProxy;
 		if (other instanceof JdkDynamicAopProxy) {
 			otherProxy = (JdkDynamicAopProxy) other;
 		}
@@ -257,7 +255,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 			return false;
 		}
 
-		// If we get here, aopr2 is the other AopProxy.
+		// If we get here, otherProxy is the other AopProxy.
 		return AopProxyUtils.equalsInProxy(this.advised, otherProxy.advised);
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/framework/ProxyConfig.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -113,12 +113,14 @@ public class ProxyConfig implements Serializable {
 	 * ThreadLocal for retrieval via the AopContext class. This is useful
 	 * if an advised object needs to call another advised method on itself.
 	 * (If it uses <code>this</code>, the invocation will not be advised).
-	 * <p>Default is "false", for optimal performance.
+	 * <p>Default is "false", in order to avoid unnecessary extra interception.
+	 * This means that no guarantees are provided that AopContext access will
+	 * work consistently within any method of the advised object.
 	 */
 	public void setExposeProxy(boolean exposeProxy) {
 		this.exposeProxy = exposeProxy;
 	}
-	
+
 	/**
 	 * Return whether the AOP proxy will expose the AOP proxy for
 	 * each invocation.

org.springframework.aop/src/main/java/org/springframework/aop/framework/ProxyFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -94,8 +94,8 @@ public class ProxyFactory extends ProxyCreatorSupport {
 	 * @return the proxy object
 	 */
 	@SuppressWarnings("unchecked")
-	public <T> T getProxy() {
-		return (T) createAopProxy().getProxy();
+	public Object getProxy() {
+		return createAopProxy().getProxy();
 	}
 
 	/**
@@ -108,8 +108,8 @@ public class ProxyFactory extends ProxyCreatorSupport {
 	 * @return the proxy object
 	 */
 	@SuppressWarnings("unchecked")
-	public <T> T  getProxy(ClassLoader classLoader) {
-		return (T) createAopProxy().getProxy(classLoader);
+	public Object getProxy(ClassLoader classLoader) {
+		return createAopProxy().getProxy(classLoader);
 	}
 
 
@@ -123,8 +123,9 @@ public class ProxyFactory extends ProxyCreatorSupport {
 	 * @return the proxy object
 	 * @see #ProxyFactory(Class, org.aopalliance.intercept.Interceptor)
 	 */
-	public static Object getProxy(Class proxyInterface, Interceptor interceptor) {
-		return new ProxyFactory(proxyInterface, interceptor).getProxy();
+	@SuppressWarnings("unchecked")
+	public static <T> T getProxy(Class<T> proxyInterface, Interceptor interceptor) {
+		return (T) new ProxyFactory(proxyInterface, interceptor).getProxy();
 	}
 
 	/**
@@ -135,8 +136,9 @@ public class ProxyFactory extends ProxyCreatorSupport {
 	 * @return the proxy object
 	 * @see #ProxyFactory(Class, org.springframework.aop.TargetSource)
 	 */
-	public static Object getProxy(Class proxyInterface, TargetSource targetSource) {
-		return new ProxyFactory(proxyInterface, targetSource).getProxy();
+	@SuppressWarnings("unchecked")
+	public static <T> T getProxy(Class<T> proxyInterface, TargetSource targetSource) {
+		return (T) new ProxyFactory(proxyInterface, targetSource).getProxy();
 	}
 
 	/**

org.springframework.aop/src/main/java/org/springframework/aop/framework/ProxyFactoryBean.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,9 +21,7 @@ import java.io.ObjectInputStream;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
@@ -91,7 +89,7 @@ import org.springframework.util.ObjectUtils;
  * @see Advised
  */
 public class ProxyFactoryBean extends ProxyCreatorSupport
-		implements FactoryBean, BeanClassLoaderAware, BeanFactoryAware {
+		implements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware {
 
 	/**
 	 * This suffix in a value in an interceptor list indicates to expand globals.
@@ -258,7 +256,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * a single one), the target bean type, or the TargetSource's target class.
 	 * @see org.springframework.aop.TargetSource#getTargetClass
 	 */
-	public Class getObjectType() {
+	public Class<?> getObjectType() {
 		synchronized (this) {
 			if (this.singletonInstance != null) {
 				return this.singletonInstance.getClass();
@@ -450,7 +448,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 				else {
 					// If we get here, we need to add a named interceptor.
 					// We must check if it's a singleton or prototype.
-					Object advice = null;
+					Object advice;
 					if (this.singleton || this.beanFactory.isSingleton(name)) {
 						// Add the real Advisor/Advice to the chain.
 						advice = this.beanFactory.getBean(name);
@@ -474,7 +472,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * We need to do this every time a new prototype instance is returned,
 	 * to return distinct instances of prototype Advisors and Advices.
 	 */
-	private List freshAdvisorChain() {		
+	private List<Advisor> freshAdvisorChain() {
 		Advisor[] advisors = getAdvisors();
 		List<Advisor> freshAdvisors = new ArrayList<Advisor>(advisors.length);
 		for (Advisor advisor : advisors) {
@@ -521,7 +519,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 			beans.add(bean);
 			names.put(bean, name);
 		}
-		Collections.sort(beans, new OrderComparator());
+		OrderComparator.sort(beans);
 		for (Object bean : beans) {
 			String name = names.get(bean);
 			if (name.startsWith(prefix)) {

org.springframework.aop/src/main/java/org/springframework/aop/framework/ReflectiveMethodInvocation.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ import org.aopalliance.intercept.MethodInvocation;
 
 import org.springframework.aop.ProxyMethodInvocation;
 import org.springframework.aop.support.AopUtils;
+import org.springframework.core.BridgeMethodResolver;
 
 /**
  * Spring's implementation of the AOP Alliance
@@ -101,13 +102,13 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea
 	 * but would complicate the code. And it would work only for static pointcuts.
 	 */
 	protected ReflectiveMethodInvocation(
-	    Object proxy, Object target, Method method, Object[] arguments,
-	    Class targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {
+			Object proxy, Object target, Method method, Object[] arguments,
+			Class targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {
 
 		this.proxy = proxy;
 		this.target = target;
 		this.targetClass = targetClass;
-		this.method = method;
+		this.method = BridgeMethodResolver.findBridgedMethod(method);
 		this.arguments = arguments;
 		this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
 	}

org.springframework.aop/src/main/java/org/springframework/aop/framework/adapter/package-info.java

@@ -0,0 +1,18 @@
+
+/**
+ *
+ * SPI package allowing Spring AOP framework to handle arbitrary advice types.
+ * <br>
+ * Users who want merely to <i>use</i> the Spring AOP framework, rather than extend
+ * its capabilities, don't need to concern themselves with this package.
+ * <br>
+ * 	You may wish to use these adapters to wrap Spring-specific advices, such as MethodBeforeAdvice,
+ * 	in MethodInterceptor, to allow their use in another AOP framework supporting the AOP Alliance interfaces. 
+ * </br>
+ * <br>
+ * 	These adapters do not depend on any other Spring framework classes to allow such usage.
+ * </br>
+ *
+ */
+package org.springframework.aop.framework.adapter;
+

org.springframework.aop/src/main/java/org/springframework/aop/framework/adapter/package.html

@@ -1,17 +0,0 @@
-<html>
-<body>
-
-SPI package allowing Spring AOP framework to handle arbitrary advice types.
-<br>
-Users who want merely to <i>use</i> the Spring AOP framework, rather than extend
-its capabilities, don't need to concern themselves with this package.
-<br>
-	You may wish to use these adapters to wrap Spring-specific advices, such as MethodBeforeAdvice,
-	in MethodInterceptor, to allow their use in another AOP framework supporting the AOP Alliance interfaces. 
-</br>
-<br>
-	These adapters do not depend on any other Spring framework classes to allow such usage.
-</br>
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/AbstractAdvisorAutoProxyCreator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@
 
 package org.springframework.aop.framework.autoproxy;
 
-import java.util.Collections;
 import java.util.List;
 
 import org.springframework.aop.Advisor;
@@ -86,10 +85,10 @@ public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyC
 	protected List<Advisor> findEligibleAdvisors(Class beanClass, String beanName) {
 		List<Advisor> candidateAdvisors = findCandidateAdvisors();
 		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
+		extendAdvisors(eligibleAdvisors);
 		if (!eligibleAdvisors.isEmpty()) {
 			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
 		}
-		extendAdvisors(eligibleAdvisors);
 		return eligibleAdvisors;
 	}
 
@@ -141,7 +140,7 @@ public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyC
 	 * @see org.springframework.core.OrderComparator
 	 */
 	protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
-		Collections.sort(advisors, new OrderComparator());
+		OrderComparator.sort(advisors);
 		return advisors;
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/AbstractAutoProxyCreator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -112,7 +112,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	protected final Log logger = LogFactory.getLog(getClass());
 
 	/** Default value is same as non-ordered */
-	private int order = Integer.MAX_VALUE;
+	private int order = Ordered.LOWEST_PRECEDENCE;
 
 	/** Default is global AdvisorAdapterRegistry */
 	private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();
@@ -144,7 +144,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 
 	private final Set<Object> nonAdvisedBeans = Collections.synchronizedSet(new HashSet<Object>());
 
-	private final Map<Object, Class> proxyTypes = new ConcurrentHashMap<Object, Class>();
+	private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<Object, Class<?>>();
 
 
 	/**
@@ -253,12 +253,12 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	}
 
 
-	public Class predictBeanType(Class beanClass, String beanName) {
+	public Class<?> predictBeanType(Class<?> beanClass, String beanName) {
 		Object cacheKey = getCacheKey(beanClass, beanName);
 		return this.proxyTypes.get(cacheKey);
 	}
 
-	public Constructor[] determineCandidateConstructors(Class beanClass, String beanName) throws BeansException {
+	public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
 		return null;
 	}
 
@@ -268,7 +268,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 		return wrapIfNecessary(bean, beanName, cacheKey);
 	}
 
-	public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
+	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
 		Object cacheKey = getCacheKey(beanClass, beanName);
 
 		if (!this.targetSourcedBeans.contains(cacheKey)) {
@@ -332,7 +332,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	 * @param beanName the bean name
 	 * @return the cache key for the given class and name
 	 */
-	protected Object getCacheKey(Class beanClass, String beanName) {
+	protected Object getCacheKey(Class<?> beanClass, String beanName) {
 		return beanClass.getName() + "_" + beanName;
 	}
 
@@ -379,7 +379,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	 * @see org.aopalliance.intercept.MethodInterceptor
 	 * @see #shouldSkip
 	 */
-	protected boolean isInfrastructureClass(Class beanClass) {
+	protected boolean isInfrastructureClass(Class<?> beanClass) {
 		boolean retVal = Advisor.class.isAssignableFrom(beanClass) ||
 				Advice.class.isAssignableFrom(beanClass) ||
 				AopInfrastructureBean.class.isAssignableFrom(beanClass);
@@ -398,7 +398,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	 * @param beanName the name of the bean
 	 * @return whether to skip the given bean
 	 */
-	protected boolean shouldSkip(Class beanClass, String beanName) {
+	protected boolean shouldSkip(Class<?> beanClass, String beanName) {
 		return false;
 	}
 
@@ -412,7 +412,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	 * @return a TargetSource for this bean
 	 * @see #setCustomTargetSourceCreators
 	 */
-	protected TargetSource getCustomTargetSource(Class beanClass, String beanName) {
+	protected TargetSource getCustomTargetSource(Class<?> beanClass, String beanName) {
 		// We can't create fancy target sources for directly registered singletons.
 		if (this.customTargetSourceCreators != null &&
 				this.beanFactory != null && this.beanFactory.containsBean(beanName)) {
@@ -445,7 +445,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	 * @see #buildAdvisors
 	 */
 	protected Object createProxy(
-			Class beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
+			Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
 
 		ProxyFactory proxyFactory = new ProxyFactory();
 		// Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
@@ -454,8 +454,8 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 		if (!shouldProxyTargetClass(beanClass, beanName)) {
 			// Must allow for introductions; can't just set interfaces to
 			// the target's interfaces only.
-			Class[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
-			for (Class targetInterface : targetInterfaces) {
+			Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
+			for (Class<?> targetInterface : targetInterfaces) {
 				proxyFactory.addInterface(targetInterface);
 			}
 		}
@@ -487,7 +487,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	 * @return whether the given bean should be proxied with its target class
 	 * @see AutoProxyUtils#shouldProxyTargetClass
 	 */
-	protected boolean shouldProxyTargetClass(Class beanClass, String beanName) {
+	protected boolean shouldProxyTargetClass(Class<?> beanClass, String beanName) {
 		return (isProxyTargetClass() ||
 				(this.beanFactory instanceof ConfigurableListableBeanFactory &&
 						AutoProxyUtils.shouldProxyTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName)));
@@ -591,6 +591,6 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	 * @see #PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS
 	 */
 	protected abstract Object[] getAdvicesAndAdvisorsForBean(
-			Class beanClass, String beanName, TargetSource customTargetSource) throws BeansException;
+			Class<?> beanClass, String beanName, TargetSource customTargetSource) throws BeansException;
 
 }

org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/AutoProxyUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -52,7 +52,7 @@ public abstract class AutoProxyUtils {
 	 * @return whether the given bean should be proxied with its target class
 	 */
 	public static boolean shouldProxyTargetClass(ConfigurableListableBeanFactory beanFactory, String beanName) {
-		if (beanFactory.containsBeanDefinition(beanName)) {
+		if (beanName != null && beanFactory.containsBeanDefinition(beanName)) {
 			BeanDefinition bd = beanFactory.getBeanDefinition(beanName);
 			return Boolean.TRUE.equals(bd.getAttribute(PRESERVE_TARGET_CLASS_ATTRIBUTE));
 		}

org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/BeanNameAutoProxyCreator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -84,6 +84,15 @@ public class BeanNameAutoProxyCreator extends AbstractAutoProxyCreator {
 				if (isMatch(beanName, mappedName)) {
 					return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
 				}
+				BeanFactory beanFactory = getBeanFactory();
+				if (beanFactory != null) {
+					String[] aliases = beanFactory.getAliases(beanName);
+					for (String alias : aliases) {
+						if (isMatch(alias, mappedName)) {
+							return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
+						}
+					}
+				}
 			}
 		}
 		return DO_NOT_PROXY;

org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/ProxyCreationContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2011 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,8 +29,8 @@ import org.springframework.core.NamedThreadLocal;
 public class ProxyCreationContext {
 
 	/** ThreadLocal holding the current proxied bean name during Advisor matching */
-	private static final ThreadLocal currentProxiedBeanName =
-			new NamedThreadLocal("Name of currently proxied bean");
+	private static final ThreadLocal<String> currentProxiedBeanName =
+			new NamedThreadLocal<String>("Name of currently proxied bean");
 
 
 	/**
@@ -38,7 +38,7 @@ public class ProxyCreationContext {
 	 * @return the name of the bean, or <code>null</code> if none available
 	 */
 	public static String getCurrentProxiedBeanName() {
-		return (String) currentProxiedBeanName.get();
+		return currentProxiedBeanName.get();
 	}
 
 	/**
@@ -46,7 +46,12 @@ public class ProxyCreationContext {
 	 * @param beanName the name of the bean, or <code>null</code> to reset it
 	 */
 	static void setCurrentProxiedBeanName(String beanName) {
-		currentProxiedBeanName.set(beanName);
+		if (beanName != null) {
+			currentProxiedBeanName.set(beanName);
+		}
+		else {
+			currentProxiedBeanName.remove();
+		}
 	}
 
 }

org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/TargetSourceCreator.java

@@ -38,6 +38,6 @@ public interface TargetSourceCreator {
 	 * @return a special TargetSource or <code>null</code> if this TargetSourceCreator isn't
 	 * interested in the particular bean
 	 */
-	TargetSource getTargetSource(Class beanClass, String beanName);
+	TargetSource getTargetSource(Class<?> beanClass, String beanName);
 
 }

org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/package-info.java

@@ -0,0 +1,16 @@
+
+/**
+ *
+ * Bean post-processors for use in ApplicationContexts to simplify AOP usage
+ * by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
+ * 
+ * <p>The various post-processors in this package need only be added to an ApplicationContext
+ * (typically in an XML bean definition document) to automatically proxy selected beans.
+ * 
+ * <p><b>NB</b>: Automatic auto-proxying is not supported for BeanFactory implementations,
+ * as post-processors beans are only automatically detected in application contexts.
+ * Post-processors can be explicitly registered on a ConfigurableBeanFactory instead.
+ *
+ */
+package org.springframework.aop.framework.autoproxy;
+

org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/package.html

@@ -1,15 +0,0 @@
-<html>
-<body>
-
-Bean post-processors for use in ApplicationContexts to simplify AOP usage
-by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
-
-<p>The various post-processors in this package need only be added to an ApplicationContext
-(typically in an XML bean definition document) to automatically proxy selected beans.
-
-<p><b>NB</b>: Automatic auto-proxying is not supported for BeanFactory implementations,
-as post-processors beans are only automatically detected in application contexts.
-Post-processors can be explicitly registered on a ConfigurableBeanFactory instead.
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/framework/autoproxy/target/AbstractBeanFactoryBasedTargetSourceCreator.java

@@ -86,7 +86,7 @@ public abstract class AbstractBeanFactoryBasedTargetSourceCreator
 	// Implementation of the TargetSourceCreator interface
 	//---------------------------------------------------------------------
 
-	public final TargetSource getTargetSource(Class beanClass, String beanName) {
+	public final TargetSource getTargetSource(Class<?> beanClass, String beanName) {
 		AbstractBeanFactoryBasedTargetSource targetSource =
 				createBeanFactoryBasedTargetSource(beanClass, beanName);
 		if (targetSource == null) {
@@ -194,6 +194,6 @@ public abstract class AbstractBeanFactoryBasedTargetSourceCreator
 	 * @return the AbstractPrototypeBasedTargetSource, or <code>null</code> if we don't match this
 	 */
 	protected abstract AbstractBeanFactoryBasedTargetSource createBeanFactoryBasedTargetSource(
-			Class beanClass, String beanName);
+			Class<?> beanClass, String beanName);
 
 }

org.springframework.aop/src/main/java/org/springframework/aop/framework/package-info.java

@@ -0,0 +1,19 @@
+
+/**
+ *
+ * Package containing Spring's basic AOP infrastructure, compliant with the
+ * <a href="http://aopalliance.sourceforge.net">AOP Alliance</a> interfaces.
+ * 
+ * <p>Spring AOP supports proxying interfaces or classes, introductions, and offers
+ * static and dynamic pointcuts.
+ * 
+ * <p>Any Spring AOP proxy can be cast to the ProxyConfig AOP configuration interface
+ * in this package to add or remove interceptors.
+ * 
+ * <p>The ProxyFactoryBean is a convenient way to create AOP proxies in a BeanFactory
+ * or ApplicationContext. However, proxies can be created programmatically using the
+ * ProxyFactory class.
+ *
+ */
+package org.springframework.aop.framework;
+

org.springframework.aop/src/main/java/org/springframework/aop/framework/package.html

@@ -1,18 +0,0 @@
-<html>
-<body>
-
-Package containing Spring's basic AOP infrastructure, compliant with the
-<a href="http://aopalliance.sourceforge.net">AOP Alliance</a> interfaces.
-
-<p>Spring AOP supports proxying interfaces or classes, introductions, and offers
-static and dynamic pointcuts.
-
-<p>Any Spring AOP proxy can be cast to the ProxyConfig AOP configuration interface
-in this package to add or remove interceptors.
-
-<p>The ProxyFactoryBean is a convenient way to create AOP proxies in a BeanFactory
-or ApplicationContext. However, proxies can be created programmatically using the
-ProxyFactory class.
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2002-2009 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.interceptor;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Future;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+
+import org.springframework.core.Ordered;
+import org.springframework.core.task.AsyncTaskExecutor;
+import org.springframework.core.task.support.TaskExecutorAdapter;
+import org.springframework.util.Assert;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * AOP Alliance <code>MethodInterceptor</code> that processes method invocations
+ * asynchronously, using a given {@link org.springframework.core.task.AsyncTaskExecutor}.
+ * Typically used with the {@link org.springframework.context.task.Async} annotation.
+ *
+ * <p>In terms of target method signatures, any parameter types are supported.
+ * However, the return type is constrained to either <code>void</code> or
+ * <code>java.util.concurrent.Future</code>. In the latter case, the Future handle
+ * returned from the proxy will be an actual asynchronous Future that can be used
+ * to track the result of the asynchronous method execution. However, since the
+ * target method needs to implement the same signature, it will have to return
+ * a temporary Future handle that just passes the return value through
+ * (like Spring's {@link org.springframework.scheduling.annotation.AsyncResult}
+ * or EJB 3.1's <code>javax.ejb.AsyncResult</code>).
+ *
+ * @author Juergen Hoeller
+ * @since 3.0
+ * @see org.springframework.scheduling.annotation.Async
+ * @see org.springframework.scheduling.annotation.AsyncAnnotationAdvisor
+ */
+public class AsyncExecutionInterceptor implements MethodInterceptor, Ordered {
+
+	private final AsyncTaskExecutor asyncExecutor;
+
+
+	/**
+	 * Create a new AsyncExecutionInterceptor.
+	 * @param asyncExecutor the Spring AsyncTaskExecutor to delegate to
+	 */
+	public AsyncExecutionInterceptor(AsyncTaskExecutor asyncExecutor) {
+		Assert.notNull(asyncExecutor, "TaskExecutor must not be null");
+		this.asyncExecutor = asyncExecutor;
+	}
+
+	/**
+	 * Create a new AsyncExecutionInterceptor.
+	 * @param asyncExecutor the <code>java.util.concurrent</code> Executor
+	 * to delegate to (typically a {@link java.util.concurrent.ExecutorService}
+	 */
+	public AsyncExecutionInterceptor(Executor asyncExecutor) {
+		this.asyncExecutor = new TaskExecutorAdapter(asyncExecutor);
+	}
+
+
+	public Object invoke(final MethodInvocation invocation) throws Throwable {
+		Future result = this.asyncExecutor.submit(new Callable<Object>() {
+			public Object call() throws Exception {
+				try {
+					Object result = invocation.proceed();
+					if (result instanceof Future) {
+						return ((Future) result).get();
+					}
+				}
+				catch (Throwable ex) {
+					ReflectionUtils.rethrowException(ex);
+				}
+				return null;
+			}
+		});
+		if (Future.class.isAssignableFrom(invocation.getMethod().getReturnType())) {
+			return result;
+		}
+		else {
+			return null;
+		}
+	}
+
+	public int getOrder() {
+		return Ordered.HIGHEST_PRECEDENCE;
+	}
+
+}

org.springframework.aop/src/main/java/org/springframework/aop/interceptor/ExposeBeanNameAdvisors.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45,7 +45,7 @@ public abstract class ExposeBeanNameAdvisors {
 	 * Binding for the bean name of the bean which is currently being invoked
 	 * in the ReflectiveMethodInvocation userAttributes Map.
 	 */
-	private static final String BEAN_NAME_ATTRIBUTE = ExposeBeanNameAdvisors.class.getName() + ".beanName";
+	private static final String BEAN_NAME_ATTRIBUTE = ExposeBeanNameAdvisors.class.getName() + ".BEAN_NAME";
 
 
 	/**
@@ -114,7 +114,7 @@ public abstract class ExposeBeanNameAdvisors {
 				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
 			}
 			ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
-			pmi.setUserAttribute(BEAN_NAME_ATTRIBUTE, beanName);
+			pmi.setUserAttribute(BEAN_NAME_ATTRIBUTE, this.beanName);
 			return mi.proceed();
 		}
 	}
@@ -137,7 +137,7 @@ public abstract class ExposeBeanNameAdvisors {
 				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
 			}
 			ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
-			pmi.setUserAttribute(BEAN_NAME_ATTRIBUTE, beanName);
+			pmi.setUserAttribute(BEAN_NAME_ATTRIBUTE, this.beanName);
 			return super.invoke(mi);
 		}
 

org.springframework.aop/src/main/java/org/springframework/aop/interceptor/ExposeInvocationInterceptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2011 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,6 +24,7 @@ import org.aopalliance.intercept.MethodInvocation;
 import org.springframework.aop.Advisor;
 import org.springframework.aop.support.DefaultPointcutAdvisor;
 import org.springframework.core.NamedThreadLocal;
+import org.springframework.core.Ordered;
 
 /**
  * Interceptor that exposes the current {@link org.aopalliance.intercept.MethodInvocation}
@@ -39,7 +40,7 @@ import org.springframework.core.NamedThreadLocal;
  * @author Rod Johnson
  * @author Juergen Hoeller
  */
-public class ExposeInvocationInterceptor implements MethodInterceptor, Serializable {
+public class ExposeInvocationInterceptor implements MethodInterceptor, Ordered, Serializable {
 
 	/** Singleton instance of this class */
 	public static final ExposeInvocationInterceptor INSTANCE = new ExposeInvocationInterceptor();
@@ -49,17 +50,14 @@ public class ExposeInvocationInterceptor implements MethodInterceptor, Serializa
 	 * Spring AOP, as it prevents the need to create a new Advisor to wrap the instance.
 	 */
 	public static final Advisor ADVISOR = new DefaultPointcutAdvisor(INSTANCE) {
-		@Override
-		public int getOrder() {
-			return Integer.MIN_VALUE;
-		}
 		@Override
 		public String toString() {
 			return ExposeInvocationInterceptor.class.getName() +".ADVISOR";
 		}
 	};
 
-	private static final ThreadLocal invocation = new NamedThreadLocal("Current AOP method invocation");
+	private static final ThreadLocal<MethodInvocation> invocation =
+			new NamedThreadLocal<MethodInvocation>("Current AOP method invocation");
 
 
 	/**
@@ -69,11 +67,12 @@ public class ExposeInvocationInterceptor implements MethodInterceptor, Serializa
 	 * or if the ExposeInvocationInterceptor was not added to this interceptor chain
 	 */
 	public static MethodInvocation currentInvocation() throws IllegalStateException {
-		MethodInvocation mi = (MethodInvocation) invocation.get();
+		MethodInvocation mi = invocation.get();
 		if (mi == null)
 			throw new IllegalStateException(
-					"No MethodInvocation found: Check that an AOP invocation is in progress, " +
-					"and that the ExposeInvocationInterceptor is in the interceptor chain.");
+					"No MethodInvocation found: Check that an AOP invocation is in progress, and that the " +
+					"ExposeInvocationInterceptor is upfront in the interceptor chain. Specifically, note that " +
+					"advices with order HIGHEST_PRECEDENCE will execute before ExposeInvocationInterceptor!");
 		return mi;
 	}
 
@@ -85,16 +84,20 @@ public class ExposeInvocationInterceptor implements MethodInterceptor, Serializa
 	}
 
 	public Object invoke(MethodInvocation mi) throws Throwable {
-		Object old = invocation.get();
+		MethodInvocation oldInvocation = invocation.get();
 		invocation.set(mi);
 		try {
 			return mi.proceed();
 		}
 		finally {
-			invocation.set(old);
+			invocation.set(oldInvocation);
 		}
 	}
-	
+
+	public int getOrder() {
+		return Ordered.HIGHEST_PRECEDENCE + 1;
+	}
+
 	/**
 	 * Required to support serialization. Replaces with canonical instance
 	 * on deserialization, protecting Singleton pattern.

org.springframework.aop/src/main/java/org/springframework/aop/interceptor/package-info.java

@@ -0,0 +1,10 @@
+
+/**
+ *
+ * Provides miscellaneous interceptor implementations.
+ * More specific interceptors can be found in corresponding
+ * functionality packages, like "transaction" and "orm".
+ *
+ */
+package org.springframework.aop.interceptor;
+

org.springframework.aop/src/main/java/org/springframework/aop/interceptor/package.html

@@ -1,9 +0,0 @@
-<html>
-<body>
-
-Provides miscellaneous interceptor implementations.
-More specific interceptors can be found in corresponding
-functionality packages, like "transaction" and "orm".
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/package-info.java

@@ -0,0 +1,25 @@
+
+/**
+ *
+ * Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
+ * 
+ * <br>Any AOP Alliance MethodInterceptor is usable in Spring.
+ * 
+ * <br>Spring AOP also offers:
+ * <ul>
+ * 	<li>Introduction support
+ * 	<li>A Pointcut abstraction, supporting "static" pointcuts
+ * 		(class and method-based) and "dynamic" pointcuts (also considering method arguments).
+ * 		There are currently no AOP Alliance interfaces for pointcuts.
+ * 	<li>A full range of advice types, including around, before, after returning and throws advice.
+ * 	<li>Extensibility allowing arbitrary custom advice types to
+ * 		be plugged in without modifying the core framework.
+ * </ul>
+ * 
+ * <br>
+ * Spring AOP can be used programmatically or (preferably)
+ * integrated with the Spring IoC container.
+ *
+ */
+package org.springframework.aop;
+

org.springframework.aop/src/main/java/org/springframework/aop/package.html

@@ -1,24 +0,0 @@
-<html>
-<body>
-
-Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
-
-<br>Any AOP Alliance MethodInterceptor is usable in Spring.
-
-<br>Spring AOP also offers:
-<ul>
-	<li>Introduction support
-	<li>A Pointcut abstraction, supporting "static" pointcuts
-		(class and method-based) and "dynamic" pointcuts (also considering method arguments).
-		There are currently no AOP Alliance interfaces for pointcuts.
-	<li>A full range of advice types, including around, before, after returning and throws advice.
-	<li>Extensibility allowing arbitrary custom advice types to
-		be plugged in without modifying the core framework.
-</ul>
-
-<br>
-Spring AOP can be used programmatically or (preferably)
-integrated with the Spring IoC container.
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/scope/DefaultScopedObject.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,8 @@
 
 package org.springframework.aop.scope;
 
+import java.io.Serializable;
+
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.util.Assert;
 
@@ -32,7 +34,7 @@ import org.springframework.util.Assert;
  * @see org.springframework.beans.factory.BeanFactory#getBean
  * @see org.springframework.beans.factory.config.ConfigurableBeanFactory#destroyScopedBean
  */
-public class DefaultScopedObject implements ScopedObject {
+public class DefaultScopedObject implements ScopedObject, Serializable {
 
 	private final ConfigurableBeanFactory beanFactory;
 
@@ -43,8 +45,6 @@ public class DefaultScopedObject implements ScopedObject {
 	 * Creates a new instance of the {@link DefaultScopedObject} class.
 	 * @param beanFactory the {@link ConfigurableBeanFactory} that holds the scoped target object
 	 * @param targetBeanName the name of the target bean
-	 * @throws IllegalArgumentException if either of the parameters is <code>null</code>; or
-	 * if the <code>targetBeanName</code> consists wholly of whitespace
 	 */
 	public DefaultScopedObject(ConfigurableBeanFactory beanFactory, String targetBeanName) {
 		Assert.notNull(beanFactory, "BeanFactory must not be null");

org.springframework.aop/src/main/java/org/springframework/aop/scope/ScopedProxyFactoryBean.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49,7 +49,7 @@ import org.springframework.util.ClassUtils;
  * @since 2.0
  * @see #setProxyTargetClass
  */
-public class ScopedProxyFactoryBean extends ProxyConfig implements FactoryBean, BeanFactoryAware {
+public class ScopedProxyFactoryBean extends ProxyConfig implements FactoryBean<Object>, BeanFactoryAware {
 
 	/** The TargetSource that manages scoping */
 	private final SimpleBeanTargetSource scopedTargetSource = new SimpleBeanTargetSource();
@@ -117,7 +117,7 @@ public class ScopedProxyFactoryBean extends ProxyConfig implements FactoryBean,
 		return this.proxy;
 	}
 
-	public Class getObjectType() {
+	public Class<?> getObjectType() {
 		if (this.proxy != null) {
 			return this.proxy.getClass();
 		}

org.springframework.aop/src/main/java/org/springframework/aop/scope/ScopedProxyUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@ package org.springframework.aop.scope;
 import org.springframework.aop.framework.autoproxy.AutoProxyUtils;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinitionHolder;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 
@@ -52,32 +53,39 @@ public abstract class ScopedProxyUtils {
 
 		// Create a scoped proxy definition for the original bean name,
 		// "hiding" the target bean in an internal target definition.
-		RootBeanDefinition scopedProxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
-		scopedProxyDefinition.setOriginatingBeanDefinition(definition.getBeanDefinition());
-		scopedProxyDefinition.setSource(definition.getSource());
-		scopedProxyDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
-		
+		RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
+		proxyDefinition.setOriginatingBeanDefinition(definition.getBeanDefinition());
+		proxyDefinition.setSource(definition.getSource());
+		proxyDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
+
 		String targetBeanName = getTargetBeanName(originalBeanName);
-		scopedProxyDefinition.getPropertyValues().addPropertyValue("targetBeanName", targetBeanName);
+		proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);
 
 		if (proxyTargetClass) {
 			targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
 			// ScopedFactoryBean's "proxyTargetClass" default is TRUE, so we don't need to set it explicitly here.
 		}
 		else {
-			scopedProxyDefinition.getPropertyValues().addPropertyValue("proxyTargetClass", Boolean.FALSE);
+			proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
+		}
+
+		// Copy autowire settings from original bean definition.
+		proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
+		proxyDefinition.setPrimary(targetDefinition.isPrimary());
+		if (targetDefinition instanceof AbstractBeanDefinition) {
+			proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
 		}
 
-		scopedProxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
 		// The target bean should be ignored in favor of the scoped proxy.
 		targetDefinition.setAutowireCandidate(false);
+		targetDefinition.setPrimary(false);
 
 		// Register the target bean as separate bean in the factory.
 		registry.registerBeanDefinition(targetBeanName, targetDefinition);
 
 		// Return the scoped proxy definition as primary bean definition
 		// (potentially an inner bean).
-		return new BeanDefinitionHolder(scopedProxyDefinition, originalBeanName, definition.getAliases());
+		return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());
 	}
 	
 	/**

org.springframework.aop/src/main/java/org/springframework/aop/scope/package-info.java

@@ -0,0 +1,8 @@
+
+/**
+ *
+ * Support for AOP-based scoping of target objects, with configurable backend.
+ *
+ */
+package org.springframework.aop.scope;
+

org.springframework.aop/src/main/java/org/springframework/aop/scope/package.html

@@ -1,7 +0,0 @@
-<html>
-<body>
-
-Support for AOP-based scoping of target objects, with configurable backend.
-
-</body>
-</html>

org.springframework.aop/src/main/java/org/springframework/aop/support/AbstractBeanFactoryPointcutAdvisor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,9 @@
 
 package org.springframework.aop.support;
 
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
 import org.aopalliance.aop.Advice;
 
 import org.springframework.beans.factory.BeanFactory;
@@ -41,9 +44,9 @@ public abstract class AbstractBeanFactoryPointcutAdvisor extends AbstractPointcu
 
 	private BeanFactory beanFactory;
 
-	private Advice advice;
+	private transient Advice advice;
 
-	private final Object adviceMonitor = new Object();
+	private transient volatile Object adviceMonitor = new Object();
 
 
 	/**
@@ -74,7 +77,7 @@ public abstract class AbstractBeanFactoryPointcutAdvisor extends AbstractPointcu
 		synchronized (this.adviceMonitor) {
 			if (this.advice == null && this.adviceBeanName != null) {
 				Assert.state(this.beanFactory != null, "BeanFactory must be set to resolve 'adviceBeanName'");
-				this.advice = (Advice) this.beanFactory.getBean(this.adviceBeanName, Advice.class);
+				this.advice = this.beanFactory.getBean(this.adviceBeanName, Advice.class);
 			}
 			return this.advice;
 		}
@@ -85,4 +88,17 @@ public abstract class AbstractBeanFactoryPointcutAdvisor extends AbstractPointcu
 		return getClass().getName() + ": advice bean '" + getAdviceBeanName() + "'";
 	}
 
+
+	//---------------------------------------------------------------------
+	// Serialization support
+	//---------------------------------------------------------------------
+
+	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+		// Rely on default serialization, just initialize state after deserialization.
+		ois.defaultReadObject();
+
+		// Initialize transient fields.
+		this.adviceMonitor = new Object();
+	}
+
 }

org.springframework.aop/src/main/java/org/springframework/aop/support/AbstractPointcutAdvisor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,8 @@ package org.springframework.aop.support;
 
 import java.io.Serializable;
 
+import org.aopalliance.aop.Advice;
+
 import org.springframework.aop.PointcutAdvisor;
 import org.springframework.core.Ordered;
 import org.springframework.util.ObjectUtils;
@@ -34,7 +36,7 @@ import org.springframework.util.ObjectUtils;
  */
 public abstract class AbstractPointcutAdvisor implements PointcutAdvisor, Ordered, Serializable {
 
-	private int order = Ordered.LOWEST_PRECEDENCE;
+	private Integer order;
 
 
 	public void setOrder(int order) {
@@ -42,7 +44,14 @@ public abstract class AbstractPointcutAdvisor implements PointcutAdvisor, Ordere
 	}
 
 	public int getOrder() {
-		return this.order;
+		if (this.order != null) {
+			return this.order;
+		}
+		Advice advice = getAdvice();
+		if (advice instanceof Ordered) {
+			return ((Ordered) advice).getOrder();
+		}
+		return Ordered.LOWEST_PRECEDENCE;
 	}
 
 	public boolean isPerInstance() {

org.springframework.aop/src/main/java/org/springframework/aop/support/AbstractRegexpMethodPointcut.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -55,7 +55,7 @@ public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPo
 	/** Regular expressions to match */
 	private String[] patterns = new String[0];
 
-	/** Regaular expressions <strong>not</strong> to match */
+	/** Regular expressions <strong>not</strong> to match */
 	private String[] excludedPatterns = new String[0];
 
 
@@ -155,14 +155,22 @@ public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPo
 	/**
 	 * Subclasses must implement this to initialize regexp pointcuts.
 	 * Can be invoked multiple times.
-	 * <p>This method will be invoked from the setPatterns method,
+	 * <p>This method will be invoked from the {@link #setPatterns} method,
 	 * and also on deserialization.
 	 * @param patterns the patterns to initialize
 	 * @throws IllegalArgumentException in case of an invalid pattern
 	 */
 	protected abstract void initPatternRepresentation(String[] patterns) throws IllegalArgumentException;
 
-	protected abstract void initExcludedPatternRepresentation(String[] excludedPatterns) throws IllegalArgumentException;
+	/**
+	 * Subclasses must implement this to initialize regexp pointcuts.
+	 * Can be invoked multiple times.
+	 * <p>This method will be invoked from the {@link #setExcludedPatterns} method,
+	 * and also on deserialization.
+	 * @param patterns the patterns to initialize
+	 * @throws IllegalArgumentException in case of an invalid pattern
+	 */
+	protected abstract void initExcludedPatternRepresentation(String[] patterns) throws IllegalArgumentException;
 
 	/**
 	 * Does the pattern at the given index match this string?
@@ -197,12 +205,10 @@ public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPo
 	@Override
 	public int hashCode() {
 		int result = 27;
-		for (int i = 0; i < this.patterns.length; i++) {
-			String pattern = this.patterns[i];
+		for (String pattern : this.patterns) {
 			result = 13 * result + pattern.hashCode();
 		}
-		for (int i = 0; i < this.excludedPatterns.length; i++) {
-			String excludedPattern = this.excludedPatterns[i];
+		for (String excludedPattern : this.excludedPatterns) {
 			result = 13 * result + excludedPattern.hashCode();
 		}
 		return result;
@@ -214,18 +220,4 @@ public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPo
 				", excluded patterns " + ObjectUtils.nullSafeToString(this.excludedPatterns);
 	}
 
-
-	//---------------------------------------------------------------------
-	// Serialization support
-	//---------------------------------------------------------------------
-
-	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
-		// Rely on default serialization; just initialize state after deserialization.
-		ois.defaultReadObject();
-
-		// Ask subclass to reinitialize.
-		initPatternRepresentation(this.patterns);
-		initExcludedPatternRepresentation(this.excludedPatterns);
-	}
-
 }

org.springframework.aop/src/main/java/org/springframework/aop/support/AopUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -85,27 +85,37 @@ public abstract class AopUtils {
 	 * Check whether the specified class is a CGLIB-generated class.
 	 * @param clazz the class to check
 	 */
-	public static boolean isCglibProxyClass(Class clazz) {
-		return (clazz != null && clazz.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR));
+	public static boolean isCglibProxyClass(Class<?> clazz) {
+		return (clazz != null && isCglibProxyClassName(clazz.getName()));
 	}
 
 	/**
-	 * Determine the target class of the given bean instance,
-	 * which might be an AOP proxy.
+	 * Check whether the specified class name is a CGLIB-generated class.
+	 * @param className the class name to check
+	 */
+	public static boolean isCglibProxyClassName(String className) {
+		return (className != null && className.contains(ClassUtils.CGLIB_CLASS_SEPARATOR));
+	}
+
+	/**
+	 * Determine the target class of the given bean instance which might be an AOP proxy.
 	 * <p>Returns the target class for an AOP proxy and the plain class else.
 	 * @param candidate the instance to check (might be an AOP proxy)
-	 * @return the target class (or the plain class of the given object as fallback)
+	 * @return the target class (or the plain class of the given object as fallback;
+	 * never <code>null</code>)
 	 * @see org.springframework.aop.TargetClassAware#getTargetClass()
+	 * @see org.springframework.aop.framework.AopProxyUtils#ultimateTargetClass(Object)
 	 */
-	public static Class getTargetClass(Object candidate) {
+	public static Class<?> getTargetClass(Object candidate) {
 		Assert.notNull(candidate, "Candidate object must not be null");
+		Class<?> result = null;
 		if (candidate instanceof TargetClassAware) {
-			return ((TargetClassAware) candidate).getTargetClass();
+			result = ((TargetClassAware) candidate).getTargetClass();
 		}
-		if (isCglibProxyClass(candidate.getClass())) {
-			return candidate.getClass().getSuperclass();
+		if (result == null) {
+			result = (isCglibProxy(candidate) ? candidate.getClass().getSuperclass() : candidate.getClass());
 		}
-		return candidate.getClass();
+		return result;
 	}
 
 	/**
@@ -157,7 +167,7 @@ public abstract class AopUtils {
 	 * <code>targetClass</code> doesn't implement it or is <code>null</code>
 	 * @see org.springframework.util.ClassUtils#getMostSpecificMethod
 	 */
-	public static Method getMostSpecificMethod(Method method, Class targetClass) {
+	public static Method getMostSpecificMethod(Method method, Class<?> targetClass) {
 		Method resolvedMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
 		// If we are dealing with method with generic parameters, find the original method.
 		return BridgeMethodResolver.findBridgedMethod(resolvedMethod);
@@ -172,7 +182,7 @@ public abstract class AopUtils {
 	 * @param targetClass the class to test
 	 * @return whether the pointcut can apply on any method
 	 */
-	public static boolean canApply(Pointcut pc, Class targetClass) {
+	public static boolean canApply(Pointcut pc, Class<?> targetClass) {
 		return canApply(pc, targetClass, false);
 	}
 
@@ -186,7 +196,7 @@ public abstract class AopUtils {
 	 * for this bean includes any introductions
 	 * @return whether the pointcut can apply on any method
 	 */
-	public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) {
+	public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
 		if (!pc.getClassFilter().matches(targetClass)) {
 			return false;
 		}
@@ -199,7 +209,7 @@ public abstract class AopUtils {
 
 		Set<Class> classes = new HashSet<Class>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
 		classes.add(targetClass);
-		for (Class clazz : classes) {
+		for (Class<?> clazz : classes) {
 			Method[] methods = clazz.getMethods();
 			for (Method method : methods) {
 				if ((introductionAwareMethodMatcher != null &&
@@ -221,7 +231,7 @@ public abstract class AopUtils {
 	 * @param targetClass class we're testing
 	 * @return whether the pointcut can apply on any method
 	 */
-	public static boolean canApply(Advisor advisor, Class targetClass) {
+	public static boolean canApply(Advisor advisor, Class<?> targetClass) {
 		return canApply(advisor, targetClass, false);
 	}
 
@@ -235,7 +245,7 @@ public abstract class AopUtils {
 	 * any introductions
 	 * @return whether the pointcut can apply on any method
 	 */
-	public static boolean canApply(Advisor advisor, Class targetClass, boolean hasIntroductions) {
+	public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
 		if (advisor instanceof IntroductionAdvisor) {
 			return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
 		}
@@ -257,7 +267,7 @@ public abstract class AopUtils {
 	 * @return sublist of Advisors that can apply to an object of the given class
 	 * (may be the incoming List as-is)
 	 */
-	public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class clazz) {
+	public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
 		if (candidateAdvisors.isEmpty()) {
 			return candidateAdvisors;
 		}
@@ -291,7 +301,7 @@ public abstract class AopUtils {
 	 * @throws org.springframework.aop.AopInvocationException in case of a reflection error
 	 */
 	public static Object invokeJoinpointUsingReflection(Object target, Method method, Object[] args)
-	    throws Throwable {
+			throws Throwable {
 
 		// Use reflection to invoke the method.
 		try {

org.springframework.aop/src/main/java/org/springframework/aop/support/DefaultIntroductionAdvisor.java

@@ -38,6 +38,7 @@ import org.springframework.util.ClassUtils;
  * @author Juergen Hoeller
  * @since 11.11.2003
  */
+@SuppressWarnings({ "unchecked", "serial" })
 public class DefaultIntroductionAdvisor implements IntroductionAdvisor, ClassFilter, Ordered, Serializable {
 
 	private final Advice advice;

org.springframework.aop/src/main/java/org/springframework/aop/support/DynamicMethodMatcher.java

@@ -34,7 +34,7 @@ public abstract class DynamicMethodMatcher implements MethodMatcher {
 	 * Can override to add preconditions for dynamic matching. This implementation
 	 * always returns true.
 	 */
-	public boolean matches(Method method, Class targetClass) {
+	public boolean matches(Method method, Class<?> targetClass) {
 		return true;
 	}
 

org.springframework.aop/src/main/java/org/springframework/aop/support/IntroductionInfoSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,13 +21,11 @@ import java.io.ObjectInputStream;
 import java.io.Serializable;
 import java.lang.reflect.Method;
 import java.util.HashSet;
-import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.aopalliance.intercept.MethodInvocation;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 
 import org.springframework.aop.IntroductionInfo;
 import org.springframework.util.ClassUtils;
@@ -44,11 +42,9 @@ import org.springframework.util.ClassUtils;
  */
 public class IntroductionInfoSupport implements IntroductionInfo, Serializable {
 
-	protected transient Log logger = LogFactory.getLog(getClass());
+	protected final Set<Class> publishedInterfaces = new HashSet<Class>();
 
-	protected Set<Class> publishedInterfaces = new HashSet<Class>();
-
-	private transient Map<Method, Boolean> rememberedMethods = new IdentityHashMap<Method, Boolean>(32);
+	private transient Map<Method, Boolean> rememberedMethods = new ConcurrentHashMap<Method, Boolean>(32);
 
 
 	/**
@@ -119,10 +115,8 @@ public class IntroductionInfoSupport implements IntroductionInfo, Serializable {
 	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
 		// Rely on default serialization; just initialize state after deserialization.
 		ois.defaultReadObject();
-
 		// Initialize transient fields.
-		this.logger = LogFactory.getLog(getClass());
-		this.rememberedMethods = new IdentityHashMap<Method, Boolean>(32);
+		this.rememberedMethods = new ConcurrentHashMap<Method, Boolean>(32);
 	}
 
 }

org.springframework.aop/src/main/java/org/springframework/aop/support/JdkRegexpMethodPointcut.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -42,12 +42,12 @@ public class JdkRegexpMethodPointcut extends AbstractRegexpMethodPointcut {
 	/** 
 	 * Compiled form of the patterns.
 	 */
-	private transient Pattern[] compiledPatterns = new Pattern[0];
+	private Pattern[] compiledPatterns = new Pattern[0];
 
 	/** 
 	 * Compiled form of the exclusion patterns.
 	 */
-	private transient Pattern[] compiledExclusionPatterns = new Pattern[0];
+	private Pattern[] compiledExclusionPatterns = new Pattern[0];
 
 
 	/**
@@ -58,6 +58,14 @@ public class JdkRegexpMethodPointcut extends AbstractRegexpMethodPointcut {
 		this.compiledPatterns = compilePatterns(patterns);
 	}
 
+	/**
+	 * Initialize exclusion {@link Pattern Patterns} from the supplied <code>String[]</code>.
+	 */
+	@Override
+	protected void initExcludedPatternRepresentation(String[] excludedPatterns) throws PatternSyntaxException {
+		this.compiledExclusionPatterns = compilePatterns(excludedPatterns);
+	}
+
 	/**
 	 * Returns <code>true</code> if the {@link Pattern} at index <code>patternIndex</code>
 	 * matches the supplied candidate <code>String</code>.
@@ -68,14 +76,6 @@ public class JdkRegexpMethodPointcut extends AbstractRegexpMethodPointcut {
 		return matcher.matches();
 	}
 
-	/**
-	 * Initialize exclusion {@link Pattern Patterns} from the supplied <code>String[]</code>.
-	 */
-	@Override
-	protected void initExcludedPatternRepresentation(String[] excludedPatterns) throws IllegalArgumentException {
-		this.compiledExclusionPatterns = compilePatterns(excludedPatterns);
-	}
-
 	/**
 	 * Returns <code>true</code> if the exclusion {@link Pattern} at index <code>patternIndex</code>
 	 * matches the supplied candidate <code>String</code>.
@@ -86,11 +86,12 @@ public class JdkRegexpMethodPointcut extends AbstractRegexpMethodPointcut {
 		return matcher.matches();
 	}
 
+
 	/**
 	 * Compiles the supplied <code>String[]</code> into an array of
 	 * {@link Pattern} objects and returns that array.
 	 */
-	private Pattern[] compilePatterns(String[] source) {
+	private Pattern[] compilePatterns(String[] source) throws PatternSyntaxException {
 		Pattern[] destination = new Pattern[source.length];
 		for (int i = 0; i < source.length; i++) {
 			destination[i] = Pattern.compile(source[i]);

org.springframework.aop/src/main/java/org/springframework/aop/support/StaticMethodMatcher.java

@@ -30,7 +30,7 @@ public abstract class StaticMethodMatcher implements MethodMatcher {
 		return false;
 	}
 
-	public final boolean matches(Method method, Class targetClass, Object[] args) {
+	public final boolean matches(Method method, Class<?> targetClass, Object[] args) {
 		// should never be invoked because isRuntime() returns false
 		throw new UnsupportedOperationException("Illegal MethodMatcher usage");
 	}