spring-projects/spring-framework

This system is the Spring Framework, a comprehensive Java application framework providing core dependency injection, bean management, and aspect-oriented programming capabilities. It offers extensive support for caching, asynchronous execution, transaction management, and web development, with specific integrations for Java EE/Jakarta EE standards. The codebase has been significantly modernized to support Ahead-of-Time (AOT) compilation, native image compatibility, and Kotlin development, while enforcing strict null-safety and architectural constraints throughout.

76 changes.

This period focused on a comprehensive overhaul of Spring AOP, introducing a modular proxy infrastructure, enhanced null-safety, and new classes for @AspectJ support and dynamic target sources. Concurrently, the framework expanded its AspectJ capabilities to include automatic dependency injection, caching, transaction management, and asynchronous execution, while also adding JCache support and transaction-aware caching.

41 changes.

This period focused on expanding the framework's capabilities with new features for reactive database access via R2DBC and enhanced caching support for JCache and Caffeine. Concurrently, the team improved the WebFlux API, introduced Kotlin extensions for bean management, and significantly expanded test coverage across AOP, beans, and context indexing.

25 changes.

This period focused on implementing Ahead-of-Time (AOT) processing capabilities, including new exception hierarchies, runtime hint recording, and build-time code generation for native image compatibility. Concurrently, the project expanded test coverage and feature support for Kotlin, particularly regarding bean instantiation, AOP with coroutines, and AOT code generation.

The Spring Framework now provides a Java-based configuration option for AspectJ-driven dependency injection. A new \@EnableSpringConfigured\ annotation and its associated \SpringConfiguredConfiguration\ class have been added to the \org.springframework.context.annotation.aspectj\ package. This allows developers to enable dependency injection for non-managed classes (typically those annotated with \@Configurable\) using Java configuration, mirroring the functionality previously available only via the XML \\<context:spring-configured\>\ element.

spring-aspects/src/main/java/org/springframework/context · high confidence

A new AOT (Ahead-of-Time) configuration file has been added to register processors for scoped proxy bean registration, AspectJ advisor registration, and AspectJ bean factory initialization. This enables Spring AOP features to work correctly in native-image environments by providing the necessary reflection hints and bean registration logic at build time.

spring-aop/src/main/resources/META-INF/spring · high confidence

Spring now provides built-in support for annotation-driven caching using AspectJ, allowing developers to use \@Cacheable\, \@CacheEvict\, \@CachePut\, and \@Caching\ annotations on classes and methods for Spring's native caching, as well as \@CacheResult\, \@CachePut\, \@CacheRemove\, and \@CacheRemoveAll\ for JSR-107 (JCache). This enables transparent caching via AspectJ weaving, which can be enabled by registering the \AnnotationCacheAspect\ and \JCacheCacheAspect\ beans or using the provided \@Configuration\ classes (\AspectJCachingConfiguration\ and \AspectJJCacheConfiguration\).

spring-aspects/src/main/java/org/springframework/cache · high confidence

New AspectJ aspects and configuration classes have been introduced to enable annotation-driven transaction management in AspectJ mode. This includes \AnnotationTransactionAspect\ for Spring's \@Transactional\ and \JtaAnnotationTransactionAspect\ for the JTA \@Transactional\ annotation, along with corresponding \@Configuration\ classes (\AspectJTransactionManagementConfiguration\ and \AspectJJtaTransactionManagementConfiguration\) that register these aspects as infrastructure beans.

spring-aspects/src/main/java/org/springframework/transaction · high confidence

Introduces a new Caffeine cache manager implementation, enabling users to configure and manage caches backed by the Caffeine library within the Spring cache abstraction. This includes support for static and dynamic cache modes, custom cache specifications, and asynchronous cache loading.

spring-context-support/src/main/java/org/springframework/cache/caffeine · high confidence

The spring-instrument module now includes InstrumentationSavingAgent, a Java agent that captures the JVM's Instrumentation interface via both premain and agentmain entry points. This enables Spring's instrumentation capabilities to be used at runtime through the Attach API, allowing dynamic loading and weaving without requiring the agent class on the classpath at startup. The package also includes a package-info.java file with null-safety annotations.

spring-instrument · high confidence

Introduces new Spring cache abstractions for JCache (JSR-107), including the JCacheCacheManager, JCacheCache, and JCacheManagerFactoryBean. This enables Spring applications to integrate with any JSR-107 compliant cache provider, with the factory bean simplifying the creation and lifecycle management of the underlying JCache CacheManager.

spring-context-support/src/main/java/org/springframework/cache/jcache · high confidence

Added new JMH (Java Microbenchmark Harness) benchmarks for the Spring Beans module. The changes introduce two new benchmark classes, AbstractPropertyAccessorBenchmark and BeanUtilsBenchmark, which measure the performance of property access and bean instantiation. These benchmarks allow developers to track performance changes in core bean manipulation operations.

spring-beans/src/jmh/java/org/springframework/beans · high confidence

The Spring Framework now supports JSR-107 (JCache) cache annotations, including @CacheResult, @CachePut, @CacheRemove, and @CacheRemoveAll. This change introduces a new set of interceptor and operation classes in the spring-context-support module that enable caching behavior for methods annotated with these standard JCache annotations, allowing users to leverage JCache semantics within the Spring caching abstraction.

spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor · high confidence

Introduced four new FactoryBeans in the \org.springframework.beans.factory.serviceloader\ package to integrate with the JDK's \ServiceLoader\ facility. \ServiceFactoryBean\ exposes the primary service instance, \ServiceListFactoryBean\ exposes a list of all available services, and \ServiceLoaderFactoryBean\ exposes the raw \ServiceLoader\ instance. These components allow Spring applications to easily discover and inject Java SPI implementations.

spring-beans/src/main/java/org/springframework/beans/factory/serviceloader · high confidence

The spring-expression module now includes a JMH benchmark suite (SpelBenchmark.java) for measuring parsing and execution performance. Additionally, the diff introduces several core API classes and interfaces that define the SpEL evaluation model, including the Expression, EvaluationContext, and various exception types (AccessException, EvaluationException, ExpressionException, ExpressionInvocationTargetException) as well as resolvers (BeanResolver, ConstructorResolver, MethodResolver) and executors (ConstructorExecutor, MethodExecutor).

spring-expression · high confidence

The build now includes an automated architecture verification step that enforces structural rules on the codebase. This new Gradle plugin registers tasks that use the ArchUnit library to validate that packages are free of cycles, that specific forbidden types (such as Reactor's Assert class, SLF4J's LoggerFactory, and Spring's NonNull/Nullable annotations) are not imported, and that Java classes do not use String.toLowerCase/toUpperCase without specifying a locale. These checks run as part of the standard verification lifecycle, ensuring architectural constraints are maintained.

buildSrc/src/main/java/org/springframework/build/architecture · high confidence

The spring-orm module introduces new exception classes, ObjectOptimisticLockingFailureException and ObjectRetrievalFailureException, which provide detailed information about the persistent class and identifier involved in optimistic locking violations and object retrieval failures, respectively.

spring-orm · high confidence

The build system now includes a new Gradle task, \validateMultiReleaseJar\, which validates the structure of multi-release JARs. This task is automatically registered and included in the \check\ lifecycle, but it is only active on Java 25 or higher, ensuring that multi-release JARs meet the required specifications during the build's verification phase.

buildSrc/src/main/java/org/springframework/build/multirelease · high confidence

Introduces a new Java agent, RuntimeHintsAgent, which intercepts and records method invocations related to Spring's runtime hints (reflection, resources, etc.) at runtime. This is supported by a suite of testing utilities in spring-core-test, including the @EnabledIfRuntimeHintsAgent annotation to conditionally run tests, RuntimeHintsInvocationsAssert for verifying recorded invocations against configured hints, and a TestGenerationContext to facilitate testing of generated code. The agent is marked as deprecated in favor of GraalVM's native image flags.

spring-core-test · high confidence

Added new test fixture classes in the spring-aop module to support AOP testing scenarios. This includes NopInterceptor, a trivial interceptor for displaying chains; SerializableNopInterceptor, a serializable variant for proxy serialization tests; and TimestampIntroductionInterceptor, an introduction interceptor for timestamp-based tests.

spring-aop/src/testFixtures/java/org/springframework/aop/testfixture/interceptor · high confidence

Introduced new AspectJ aspects (AbstractAsyncExecutionAspect, AnnotationAsyncExecutionAspect) and a corresponding configuration class (AspectJAsyncConfiguration) to enable @Async processing via the AspectJ compiler. This allows Spring's asynchronous execution model to be applied to classes compiled with AspectJ, providing a non-proxy-based alternative to the standard JDK/CGLIB proxy approach.

spring-aspects/src/main/java/org/springframework/scheduling · high confidence

A new mime.types file is introduced in the Spring context-support module, providing default mappings for the Java Activation Framework. This includes standard types for text, images (including PNG, SVG, JPEG, GIF), audio, video, and various document formats (PostScript, RTF, PDF, etc.), enabling Spring's JavaMail integration to correctly identify content types for a broader range of file extensions.

spring-context-support/src/main/resources/org · high confidence

The Spring Beans and Spring Utility namespaces now include formal XML Schema (XSD) definitions alongside the legacy DTD. This provides structured validation for configuration files, supporting features such as profile-based parsing in the beans schema and factory beans for collections and properties in the util schema. The tool namespace schema is also added to support annotation metadata.

spring-beans/src/main/resources/org · high confidence

A new Gradle plugin, LocalDevelopmentPlugin, has been introduced to the build system. When the -PskipDocs property is active, this plugin disables all tasks in the 'documentation' and 'distribution' groups. This allows developers to speed up local builds by skipping the generation of documentation and distribution artifacts.

buildSrc/src/main/java/org/springframework/build/dev · high confidence

The Spring AOP test fixtures for AspectJ have been consolidated into a shared test fixture module. New classes including CommonExpressions, CommonPointcuts, PerTargetAspect, PerThisAspect, and TwoAdviceAspect have been added to the spring-aop/src/testFixtures/java/org/springframework/aop/testfixture/aspectj directory. These provide reusable AspectJ aspects and pointcut definitions for use in Spring AOP tests.

spring-aop/src/testFixtures/java/org/springframework/aop/testfixture/aspectj · high confidence

The Spring AOP test fixtures for mixin support have been consolidated into a new \spring-aop/src/testFixtures/java/org/springframework/aop/testfixture/mixin\ package. This adds a set of new classes (\Lockable\, \DefaultLockable\, \LockMixin\, \LockMixinAdvisor\, and \LockedException\) that provide a stateful locking functionality for demonstrating and testing AOP mixin capabilities.

spring-aop/src/testFixtures/java/org/springframework/aop/testfixture/mixin · high confidence

The \spring-tx\ module introduces a new exception hierarchy in the \org.springframework.dao\ package. A new abstract base class \DataAccessException\ is added, along with a \NonTransientDataAccessException\ for permanent errors. Specific exceptions like \CannotAcquireLockException\ and \PessimisticLockingFailureException\ are introduced to replace older, more specific exceptions such as \CannotSerializeTransactionException\ and \DeadlockLoserDataAccessException\, which are now marked as deprecated. This change provides a more consistent and unified approach to handling data access errors, allowing users to catch broader categories of exceptions rather than relying on specific, potentially numerous, exception types.

spring-tx · high confidence

A new Java SPI configuration file has been added to register the CandidateComponentsIndexer as a processing tool, enabling the Spring context indexer to automatically scan and index candidate components during compilation.

spring-context-indexer/src/main/resources · high confidence

The Spring Framework's bean factory support classes have been updated to support new bean definition attributes and improved type resolution. Specifically, \AbstractBeanDefinition\ now supports the \@Order\ and \@Priority\ annotations via new \ORDER\_ATTRIBUTE\ and \PREFERRED\_CONSTRUCTors\_ATTRIBUTE\ constants, allowing developers to control bean ordering and preferred constructors. Additionally, \AbstractAutowireCapableBeanFactory\ exposes new accessors for \allowCircularReferences\ and \allowRawInjectionDespiteWrapping\, giving finer control over circular reference handling and injection behavior. These changes enhance the flexibility of bean configuration and dependency resolution.

spring-beans/src/main/java/org/springframework/beans/factory/support · high confidence

The @Scheduled and @Async annotations now support java.time.Duration for delay and rate attributes, enabling more precise task scheduling. Additionally, the framework provides first-class support for Java virtual threads in common executors, allowing developers to leverage virtual threads for asynchronous method execution and scheduled tasks.

spring-context · high confidence

Spring Framework adds initial support for reactive database access using the R2DBC (Reactive Relational Database Connectivity) API. This includes new exception classes for SQL grammar and unclassified errors, a utility for managing R2DBC connections and transaction synchronization, and a proxy for connection factories that ensures seamless participation in Spring-managed transactions. Additionally, the framework introduces a set of classes for initializing and cleaning up databases via SQL scripts, including a composite populator, resource-based populator, and associated script parsing and execution utilities.

spring-r2dbc · high confidence

The Spring Framework now provides an AspectJ-based mechanism to automatically inject dependencies into domain objects at runtime. This is achieved through new aspects (such as AnnotationBeanConfigurerAspect) that intercept object construction and deserialization to perform configuration. Users can mark classes with the @Configurable annotation or implement the ConfigurableObject interface to enable this automatic wiring, allowing for cleaner domain models without explicit factory lookups.

spring-aspects/src/main/java/org/springframework/beans · high confidence

A new Gradle plugin, RuntimeHintsAgentPlugin, is introduced to automatically configure the runtime hints Java agent for test tasks. The plugin registers a 'runtimeHintsTest' task that applies the agent to the JVM, with configurable included and excluded packages via a 'runtimeHintsAgent' DSL extension. This allows tests to be run with the runtime hints agent active, supporting the native image code path for testing runtime hints.

buildSrc/src/main/java/org/springframework/build/hint · high confidence

The spring-core module now supports declarative use of reflection and runtime hint registration, enabling better AOT and native image compatibility. This includes the introduction of the @RegisterReflectionForBinding annotation and related infrastructure to specify which classes and methods require reflection at runtime, reducing the need for dynamic class loading and improving startup performance.

spring-core · high confidence

A new set of classes has been added to the \spring-aop\ module to handle AspectJ annotation-style aspects. This includes \AnnotationAwareAspectJAutoProxyCreator\ for auto-proxying, \AspectJAdvisorFactory\ and \ReflectiveAspectJAdvisorFactory\ for creating advisors from annotated classes, and supporting classes like \AspectMetadata\, \BeanFactoryAspectJAdvisorsBuilder\, and various \AspectInstanceFactory\ implementations to manage aspect instantiation and metadata.

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation · high confidence

The spring-websocket module now includes new classes to represent WebSocket protocol elements: \AbstractWebSocketMessage\, \BinaryMessage\, \PingMessage\, \PongMessage\, \SubProtocolCapable\, \WebSocketExtension\, \WebSocketHandler\, \WebSocketHttpHeaders\, \WebSocketMessage\, \WebSocketSession\, and \AbstractWebSocketSession\. These classes provide a structured way to handle WebSocket messages, headers, and session state, supporting features like partial messages, sub-protocols, and extensions as defined in RFC 6455.

spring-websocket · high confidence

A new Gradle plugin, OptionalDependenciesPlugin, has been added to the buildSrc module. This plugin introduces an 'optional' configuration that is included in the compile and runtime classpaths but does not propagate to dependent projects, effectively enabling Maven-style optional dependencies within the Gradle build system.

buildSrc/src/main/java/org/springframework/build/optional · high confidence

The spring-messaging module now includes foundational interfaces and classes for the messaging abstraction, including Message, MessageChannel, MessageHandler, and related exceptions (MessagingException, MessageDeliveryException, MessageHandlingException). It also adds a JMH benchmark for DefaultSubscriptionRegistry to measure performance of subscription operations.

spring-messaging · high confidence

The Spring Framework introduces a dedicated exception hierarchy for Ahead-of-Time (AOT) processing errors, including the new \AotException\, \AotProcessingException\, and \AotBeanProcessingException\ classes to provide more specific error reporting during AOT build-time processing. Additionally, new interfaces \BeanFactoryInitializationAotProcessor\ and \BeanRegistrationAotProcessor\ are added to the \spring-beans\ module, enabling custom AOT processors to contribute to bean factory initialization and bean registration code generation respectively.

spring-beans/src/main/java/org/springframework/beans/factory/aot · high confidence

Spring 6.2 introduces new classes in the \org.springframework.ui.freemarker\ package to support FreeMarker template rendering. \FreeMarkerConfigurationFactory\ provides a configurable factory for FreeMarker's \Configuration\, now supporting \Charset\-based encoding via \setDefaultCharset\ and allowing custom \TemplateLoader\ instances to be registered for template loading. \FreeMarkerConfigurationFactoryBean\ exposes the \Configuration\ as a Spring bean, while \FreeMarkerTemplateUtils\ offers a utility method to process templates into strings. These classes require FreeMarker 2.3.33 or higher.

spring-context-support/src/main/java/org/springframework/ui · high confidence

The Spring Framework now provides a dedicated set of configuration classes to support JSR-107 (JCache) annotation-driven caching. This includes the \JCacheConfigurer\ interface and its \JCacheConfigurerSupport\ implementation, which allow users to explicitly define how exception caches are resolved. The \AbstractJCacheConfiguration\ and \ProxyJCacheConfiguration\ classes handle the registration of necessary infrastructure beans, such as the \JCacheOperationSource\ and \JCacheInterceptor\, enabling seamless integration of JCache with Spring's caching abstraction.

spring-context-support/src/main/java/org/springframework/cache/jcache/config · high confidence

Added Kotlin extension functions for \BeanFactory\ and \ListableBeanFactory\ that provide type-safe, reified variants of common methods like \getBean\, \getBeanProvider\, \getBeanNamesForType\, \getBeansOfType\, \getBeansWithAnnotation\, and \findAnnotationOnBean\ to avoid type erasure. Additionally, introduced \BeanRegistrarDsl\ to allow concise, programmatic bean registration with support for profiles, aliases, and various bean specification options.

spring-beans/src/main/kotlin · high confidence

The spring-oxm module introduces new interfaces for generic type support and MIME attachments, alongside a structured exception hierarchy. GenericMarshaller and GenericUnmarshaller provide a supports(Type) method to check type compatibility for generic types. The MimeMarshaller and MimeUnmarshaller interfaces enable marshalling and unmarshalling with MIME attachments for binary data optimization. Additionally, a new exception hierarchy is established: XmlMappingException serves as the root, with specific exceptions including MarshallingException, UnmarshallingFailureException, ValidationFailureException, and UncategorizedMappingException to provide detailed error reporting for mapping failures.

spring-oxm · high confidence

A new set of classes has been introduced in the \spring-context-support\ module to facilitate deeper integration with the Quartz scheduler. This includes \AdaptableJobFactory\ to support \Runnable\ objects as jobs, \LocalDataSourceJobStore\ to delegate JDBC connections to a Spring-managed \DataSource\, and \LocalTaskExecutorThreadPool\ to delegate thread execution to a Spring \Executor\. Additionally, factory beans (\CronTriggerFactoryBean\, \JobDetailFactoryBean\, \MethodInvokingJobDetailFactoryBean\) and helper classes (\ResourceLoaderClassLoadHelper\, \SchedulerAccessor\, \SchedulerAccessorBean\) are provided to configure Quartz triggers, job details, and scheduler access within the Spring IoC container.

spring-context-support/src/main/java/org/springframework/scheduling · high confidence

A new XML schema (spring-aop.xsd) has been added to define the configuration elements for Spring's AOP support. This schema introduces the 'config' element for compartmentalizing AOP-specific settings, including named pointcuts, advisors, and aspects. It also defines the 'aspectj-autoproxy' element to enable @AspectJ style AOP and the 'scoped-proxy' element to mark beans as scoped proxies. Users can now leverage these XML definitions to configure aspect-oriented programming features within their Spring applications.

spring-aop/src/main/resources/org · high confidence

The Spring AOP module introduces new classes in the \org.springframework.aop.framework.autoproxy.target\ package to support advanced target source creation. \LazyInitTargetSourceCreator\ creates proxies for beans marked as lazy-init, while \QuickTargetSourceCreator\ uses bean name prefixes (\:\, \%\, \!\) to automatically configure \CommonsPool2TargetSource\, \ThreadLocalTargetSource\, or \PrototypeTargetSource\ respectively. These creators rely on the new \AbstractBeanFactoryBasedTargetSourceCreator\ base class, which manages internal \BeanFactory\ instances to handle prototype and lazy initialization scenarios without interfering with the main container. The \package-info.java\ file adds null-safety annotations to the package.

spring-aop/src/main/java/org/springframework/aop/framework/autoproxy/target · high confidence

The spring-beans module introduces several new classes to support annotation-driven bean configuration. AnnotatedBeanDefinition and AnnotatedGenericBeanDefinition expose annotation metadata for bean definitions, allowing Spring to inspect class annotations without loading the class. BeanFactoryAnnotationUtils provides utility methods for resolving beans by qualifier and extracting qualifier values. CustomAutowireConfigurer enables registration of custom qualifier annotation types. Additionally, the module adds support for Jakarta EE 11 APIs via JakartaAnnotationsRuntimeHints, which registers reflection hints for Jakarta injection annotations.

spring-beans/src/main/java/org/springframework/beans/factory/annotation · high confidence

The Spring Framework introduces a new bean wiring mechanism in the \org.springframework.beans.factory.wiring\ package, providing a foundation for aspect-driven bean configuration. This includes the \BeanConfigurerSupport\ base class and \BeanWiringInfo\ metadata holder, which allow objects (such as AspectJ aspects) to perform dependency injection on arbitrary instances. The default \ClassNameBeanWiringInfoResolver\ enables automatic wiring by matching bean names to fully-qualified class names, supporting both by-name and by-type autowiring modes.

spring-beans/src/main/java/org/springframework/beans/factory/wiring · high confidence

Added the \Refreshable\ interface and two new classes in \org.springframework.aop.target.dynamic\: \AbstractRefreshableTargetSource\ and \BeanFactoryRefreshableTargetSource\. These provide a mechanism for Spring AOP to periodically check and refresh target objects, allowing for dynamic reloading of beans from a \BeanFactory\. This introduces new capabilities for managing the lifecycle and freshness of AOP-proxied objects.

spring-aop/src/main/java/org/springframework/aop/target/dynamic · high confidence

The spring-jdbc module introduces several new exception classes to improve error handling: BadSqlGrammarException, IncorrectResultSetColumnCountException, InvalidResultSetAccessException, LobRetrievalFailureException, SQLWarningException, and UncategorizedSQLException. Additionally, XML namespace support is added for database initialization, introducing the JdbcNamespaceHandler and related configuration utilities (DatabasePopulatorConfigUtils, EmbeddedDatabaseBeanDefinitionParser, InitializeDatabaseBeanDefinitionParser) to parse \<embedded-database\> and \<initialize-database\> elements in Spring XML configuration.

spring-jdbc · high confidence

The Spring Framework introduces a new set of classes in the \org.springframework.beans.factory.parsing\ package to support bean definition parsing. This includes the \ComponentDefinition\ interface and its implementations (\BeanComponentDefinition\, \AliasDefinition\, etc.) which provide a logical view of configuration entities, along with supporting classes like \Problem\, \Location\, and \SourceExtractor\ to handle parsing errors and source metadata. This infrastructure enables tools and external processes to subscribe to parsing events via \ReaderEventListener\ and \EmptyReaderEventListener\, allowing for better visualization and validation of bean configurations.

spring-beans/src/main/java/org/springframework/beans/factory/parsing · high confidence

The Spring Framework introduces a new, first-class API for programmatic bean registration. Developers can now register beans directly using the \BeanRegistrar\ and \BeanRegistry\ interfaces, allowing for more flexible and concise configuration without relying solely on XML or \@Configuration\ classes. This change adds new interfaces and utility classes in the \org.springframework.beans.factory\ package, including \BeanRegistrar\, \BeanRegistry\, and various exception and callback interfaces, enabling more dynamic bean management at runtime.

spring-beans/src/main/java/org/springframework/beans/factory · high confidence

Introduced the new scoped proxy infrastructure in the spring-aop module, including the ScopedObject interface for accessing raw target objects and removing them from scope, the ScopedProxyFactoryBean for creating thread-safe singletons with transparent scoping, and the ScopedProxyUtils utility class for managing target bean naming and scoped proxy registration. This provides the core API and implementation for Spring's AOP-based scoping support.

spring-aop/src/main/java/org/springframework/aop/scope · high confidence

Added new test fixture classes in the spring-aop module to support internal testing of Spring AOP features. This includes CountingAfterReturningAdvice, CountingBeforeAdvice, MethodCounter, MyThrowsHandler, and TimestampIntroductionAdvisor, which provide reusable implementations for common advice patterns and method counting during tests.

spring-aop/src/testFixtures/java/org/springframework/aop/testfixture/advice · high confidence

The Spring Framework introduces new classes in the \org.springframework.cache.transaction\ package to support synchronization of cache operations with Spring-managed transactions. \AbstractTransactionSupportingCacheManager\ provides a base class for cache managers that can be configured to delay cache writes until after a successful transaction commit. \TransactionAwareCacheManagerProxy\ acts as a proxy for an existing \CacheManager\, wrapping its caches with \TransactionAwareCacheDecorator\ to ensure that \put\ operations are only executed after a transaction commits. These components allow applications to maintain cache consistency with database transactions.

spring-context-support/src/main/java/org/springframework/cache/transaction · high confidence

The Spring Framework now includes a comprehensive set of property editors in the \spring-beans\ module, enabling direct conversion between strings and various Java types. New editors include \ByteArrayPropertyEditor\, \CharArrayPropertyEditor\, \CharacterEditor\, \CharsetEditor\, \ClassArrayEditor\, \ClassEditor\, \CurrencyEditor\, \CustomBooleanEditor\, \CustomCollectionEditor\, \CustomDateEditor\, \CustomMapEditor\, \CustomNumberEditor\, \FileEditor\, \InputSourceEditor\, \InputStreamEditor\, and \LocaleEditor\. These editors allow developers to bind string values from forms or configuration to strongly-typed bean properties, with support for custom formats, locale-specific parsing, and null/empty string handling.

spring-beans/src/main/java/org/springframework/beans/propertyeditors · high confidence

The Spring AOP module has been refactored to introduce a new set of core classes that manage AOP proxy configuration and creation. This includes the new \AbstractAdvisingBeanPostProcessor\ and \AbstractSingletonProxyFactoryBean\ classes, which provide base implementations for bean post-processors and factory beans that produce singleton-scoped proxy objects. The \Advised\ interface and \AdvisedSupport\ class have been updated to manage AOP configuration, while \AopProxy\ and \AopProxyFactory\ interfaces define the contract for creating actual proxy objects. Additionally, \AopContext\ provides a way to retrieve the current AOP proxy, and \AopConfigException\ handles configuration errors. These changes restructure how Spring AOP handles proxy creation and advice application, providing a more modular and extensible foundation for AOP features.

spring-aop/src/main/java/org/springframework/aop/framework · high confidence

The XML bean definition parsing infrastructure has been refactored to introduce new abstract base classes for parsing: \AbstractBeanDefinitionParser\, \AbstractSingleBeanDefinitionParser\, and \AbstractSimpleBeanDefinitionParser\. These classes provide a template method pattern for parsing XML elements into \BeanDefinition\ objects, simplifying the implementation of custom XML namespaces. Additionally, the \BeanDefinitionParser\ and \BeanDefinitionDecorator\ interfaces are now explicitly defined to handle top-level and nested custom tags respectively, while \DefaultBeanDefinitionDocumentReader\ has been updated to use these new abstractions, improving the consistency and extensibility of the XML parsing process.

spring-beans/src/main/java/org/springframework/beans/factory/xml · high confidence

The Spring Framework refactored the bean introspection and property access layers to improve performance, null-safety, and extensibility. A new \BeanInfoFactory\ strategy interface and \SimpleBeanInfoFactory\ implementation replace the previous hardcoded introspection logic, allowing for more efficient and customizable property descriptor resolution. The \AbstractNestablePropertyAccessor\ and \AbstractPropertyAccessor\ classes were introduced to consolidate common property accessor behavior, while \BeanWrapperImpl\ and \BeanWrapper\ interfaces were updated to support nested path traversal and \Optional\ unwrapping. Additionally, \BeanUtils\ was enhanced to support Kotlin classes with optional parameters and default values, and \BeanInstantiationException\ was updated to preserve constructor/method context for better error reporting.

spring-beans/src/main/java/org/springframework/beans · high confidence

The Spring AOP module now includes the necessary META-INF resource files to enable XML-based AOP configuration and IDE assistance. Specifically, spring.schemas maps HTTP and HTTPS URLs for Spring AOP XSDs (versions 2.0 through 4.3, plus the unversioned schema) to the local schema files, allowing XML parsers to resolve the namespace. spring.handlers registers the AopNamespaceHandler for the 'aop' namespace. Additionally, spring.tooling provides metadata for IDEs to recognize the 'aop' namespace and prefix, while spring.factories registers the ScopedProxyBeanRegistrationContributionProvider to support scoped proxy bean generation.

spring-aop/src/main/resources/META-INF · high confidence

The repository now includes standardized configuration files (.editorconfig, .gitattributes, .gitignore) to enforce consistent line endings, binary file handling, and build/IDE artifacts. A comprehensive CONTRIBUTING.md guide has been added, detailing the code of conduct, issue lifecycle, and pull request process, while the README.md and SECURITY.md provide updated project overview and vulnerability reporting instructions. Additionally, Gradle wrapper scripts (gradlew, gradlew.bat) and IDE import guides for Eclipse and IntelliJ IDEA are introduced to streamline the build and development experience.

(repo-wide) · high confidence

WebFlux now supports the SameSite attribute for session cookies, allowing developers to configure cookie security policies directly within the framework. This enhancement improves compliance with modern browser security standards by enabling explicit control over cross-site request behavior for cookies managed by the WebFlux session mechanism.

spring-web · high confidence

The Spring AOP namespace parsing logic has been restructured to improve clarity and maintainability. New classes such as AspectComponentDefinition, PointcutComponentDefinition, and AdvisorComponentDefinition now encapsulate component definitions for aspects, pointcuts, and advisors, while corresponding Entry classes (AspectEntry, PointcutEntry, AdvisorEntry, AdviceEntry) manage parse state. This change separates concerns within the spring-aop module, making the XML configuration parsing more modular and easier to extend.

spring-aop/src/main/java/org/springframework/aop/config · high confidence

The Spring AOP support classes in the org.springframework.aop.support package have been refactored to improve null-safety and internal consistency. The codebase now uses JSpecify annotations to mark parameters and fields as @Nullable, and the AbstractPointcutAdvisor and related classes have been restructured to support more robust proxy and pointcut handling. Additionally, the AopUtils class has been updated to include checks for Kotlin Coroutines and Reactive types, and the handling of bridged suspending functions has been refined.

spring-aop/src/main/java/org/springframework/aop/support · medium confidence

A new AOT configuration file (aot.factories) is introduced in the Spring context support module to register runtime hints for JavaMail mime types and the Quartz SchedulerFactoryBean, enabling these components to function correctly in native image builds.

spring-context-support/src/main/resources/META-INF · medium confidence

The build system now uses a set of centralized Gradle convention plugins to standardize the build environment. The new ConventionsPlugin orchestrates the application of specific conventions, including Checkstyle, Java, Kotlin, and Test configurations. Java compilation is standardized with a baseline of Java 25 and release level 17, while Kotlin compilation targets JVM 17 and language version 2.2. Test tasks are configured with ByteBuddy agent support, test retry logic, and specific JVM arguments. Additionally, the RepositoriesPlugin centralizes the configuration of OSS, commercial, and release train Maven repositories, enabling seamless integration with internal and external artifact sources.

buildSrc/src/main/java/org/springframework/build · high confidence

The project now uses the nohttp Checkstyle plugin to validate URLs in the codebase. A new \allowlist.lines\ file has been added to permit specific external links (such as those from sourceforge.net, objenesis.org, and w3.org), ensuring that the URL validation does not fail on these known, valid references.

src/nohttp · high confidence

The PagedListHolder class, along with the SortDefinition interface and its MutableSortDefinition implementation, are now marked as deprecated for removal in a future release. These legacy utilities for handling paginated lists and sorting bean properties are superseded by more modern solutions, such as those in Spring Data Commons. Developers should migrate away from these classes to avoid future compatibility issues.

spring-beans/src/main/java/org/springframework/beans/support · high confidence

Spring MVC has deprecated and removed several legacy features and configuration options to modernize the framework. Velocity, FreeMarker, and Tiles support have been removed or deprecated in favor of more modern templating solutions. The XML-based MVC configuration namespace is deprecated, encouraging the use of Java-based configuration. Additionally, support for path extension-based content negotiation and trailing slash matching has been deprecated, with the default behavior shifting towards parsed path patterns. The framework also drops support for older servlet versions and removes deprecated APIs such as LastModified headers and ListenableFuture, replacing them with modern alternatives like CompletableFuture and ProblemDetail for error handling.

spring-webmvc · high confidence

The examples directory now uses a symbolic link (docs-src) pointing to the main source code, allowing documentation to include code snippets directly from the project's source tree rather than maintaining separate copies.

framework-docs/modules/ROOT/examples · low confidence

The mail package now uses JSpecify @Nullable annotations to enforce null-safety. This affects the core mail classes, including MailException, MailSender, MailMessage, and SimpleMailMessage, ensuring that null values are explicitly handled and documented in the API.

spring-context-support/src/main/java/org/springframework/mail · high confidence

The Spring Framework's JavaMail integration has been migrated from the Java EE (javax.\) to the Jakarta EE (jakarta.\) namespace. This includes new or updated classes such as JavaMailSender, JavaMailSenderImpl, and MimeMessageHelper, which now depend on jakarta.mail and jakarta.activation. Users must update their dependencies to use the Jakarta Mail and Activation libraries to ensure compatibility.

spring-context-support/src/main/java/org/springframework/mail/javamail · high confidence

The Spring Framework JMS module has been updated to use the Jakarta EE 9 namespace (jakarta.jms.\) instead of the legacy javax.jms.\ API. This change aligns the framework with the JMS 2.0 and JCA 1.7 specifications. As part of this migration, all internal exception classes (such as JmsException, InvalidDestinationException, etc.) and annotation classes (such as @JmsListener, @EnableJms) now reference the Jakarta EE packages. Users must ensure their JMS provider libraries are compatible with the Jakarta EE 9 namespace.

spring-jms · high confidence

The Spring context indexer implementation has been reorganized into the new \org.springframework.context.index.processor\ package. This refactoring moves the core indexing logic, including the \CandidateComponentsIndexer\ and its supporting classes (such as \MetadataCollector\, \MetadataStore\, and stereotype providers), into a dedicated subpackage to support the upcoming AOT engine integration.

spring-context-indexer/src/main/java · high confidence

The Groovy-based dynamic element reader and its associated wrapper classes have been ported from Groovy to Java. This change replaces the previous Groovy implementation with a Java equivalent, ensuring that the Spring Framework's Groovy support is now implemented in Java while maintaining the same functional behavior for users defining beans via Groovy DSL or XML namespaces.

spring-beans/src/main/java/org/springframework/beans/factory/groovy · high confidence

The AOP Alliance interfaces (Advice, AspectException, Interceptor, Joinpoint, Invocation, MethodInterceptor, MethodInvocation, ConstructorInterceptor, ConstructorInvocation) are now included directly in the spring-aop module under the org.aopalliance package. These interfaces are annotated with JSpecify @Nullable and @NullMarked to provide explicit null-safety for the AOP API, ensuring that developers are aware of potential null values in method arguments and return types.

spring-aop/src/main/java/org/aopalliance · high confidence

The \spring-aop\ module's interceptor package has been refactored to improve null-safety and lazy resolution. Key changes include: \AsyncExecutionAspectSupport\ now uses lazy resolution for the default executor and scheduler, supporting placeholders and SpEL expressions in \@Async\ qualifiers; \AsyncExecutionInterceptor\ and \AsyncExecutionAspectSupport\ now support \CompletableFuture\ as a return type; \AbstractTraceInterceptor\ gains a \logExceptionStackTrace\ flag to control whether exception stack traces are logged; \ExposeInvocationInterceptor\ now declares itself as \PriorityOrdered\; and all classes in the package are updated with JSpecify \@Nullable\ annotations and \@NullMarked\ for the package. Additionally, \AsyncUncaughtExceptionHandler\ and \SimpleAsyncUncaughtExceptionHandler\ are introduced to handle uncaught exceptions from async methods.

spring-aop/src/main/java/org/springframework/aop/interceptor · high confidence

The Spring AOP \aspectj\ package has been refactored to improve null-safety and serialization support. All classes in the \org.springframework.aop.aspectj\ package now implement \Serializable\, allowing AOP proxies with annotation-based aspects to be serialized. The codebase has been updated to use JSpecify \@Nullable\ annotations for parameters and return types, and the \AspectInstanceFactory\ interface now exposes the aspect class loader. Additionally, \ShadowMatch\ instances are now cached in \ShadowMatchUtils\ to improve performance, and the \AspectJWeaverMessageHandler\ routes AspectJ weaving messages through the standard logging system.

spring-aop/src/main/java/org/springframework/aop/aspectj · high confidence

The Spring AOP auto-proxying mechanism has been refactored to improve null-safety and internal structure. The \AutoProxyUtils\ class was introduced to centralize logic for exposing target classes, determining exposed interfaces, and applying default proxy configurations. The \ProxyCreationContext\ was added to track the currently proxied bean name during advisor matching. Additionally, the \TargetSourceCreator\ interface was defined to allow for special target sources. These changes, applied across \AbstractAdvisorAutoProxyCreator\, \BeanFactoryAdvisorRetrievalHelper\, and other autoproxy classes, ensure consistent null-safety and provide better hooks for internal AOP behavior.

spring-aop/src/main/java/org/springframework/aop/framework/autoproxy · high confidence

The Spring AOP framework's adapter infrastructure has been refactored to improve modularity and extensibility. The \AdvisorAdapter\ interface and its implementations (e.g., \AfterReturningAdviceAdapter\, \MethodBeforeAdviceAdapter\, \ThrowsAdviceAdapter\) have been reorganized into a dedicated \adapter\ sub-package. A new \AdvisorAdapterRegistry\ interface and its \GlobalAdvisorAdapterRegistry\ singleton provide a centralized registry for managing these adapters. Additionally, a new \AdvisorAdapterRegistrationManager\ \BeanPostProcessor\ automatically registers \AdvisorAdapter\ beans with the global registry, simplifying the integration of custom advice types.

spring-aop/src/main/java/org/springframework/aop/framework/adapter · high confidence

The bean factory now enforces non-null instances in AbstractFactoryBean and consistently enforces non-null values at injection points, tightening null-safety. Merged bean definitions are cached early and selectively evicted after post-processing, improving initialization performance. Additionally, @Autowired-driven ObjectFactory/Provider resolution now works in non-singleton beans, and the AutowireCapableBeanFactory.createBean method now supports flexible constructor resolution for generic types.

spring-beans/src/main/java/org/springframework/beans/factory/config · high confidence

The framework has been updated to consistently declare @Nullable on method parameters and return types, particularly in the core, web, and messaging modules. This change improves null-safety and helps developers avoid NullPointerExceptions and other null-related issues. Specific areas include the AbstractAdvisingBeanPostProcessor, RequestContext, LocaleResolver, and various converter and resolver classes. Additionally, null checks have been added in several places, such as the returned CompletableFuture and the API version setting, to prevent subsequent NPEs.

. · high confidence

The Spring Framework now registers automatic runtime hints for Jakarta annotations and bean utility classes via the new aot.factories configuration. This ensures that the Ahead-of-Time (AOT) compilation process is aware of reflection and resource usage patterns in the beans module, improving native image compatibility and startup performance for users building native applications.

spring-beans/src/main/resources/META-INF/spring · high confidence

The Spring AOP API has been updated to use JSpecify annotations for null-safety, improving type safety for developers. Key interfaces such as \MethodBeforeAdvice\, \AfterReturningAdvice\, and \TargetSource\ now explicitly mark parameters and return values as \@Nullable\ or non-null. This change clarifies which arguments and return values can be null, helping developers avoid \NullPointerException\ and enabling better static analysis. For example, \TargetSource.getTarget()\ and \MethodMatcher.matches()\ methods now explicitly indicate nullability in their signatures.

spring-aop/src/main/java/org/springframework/aop · high confidence

The \org.springframework.aop.target\ package has been updated to use JSpecify \@Nullable\ annotations for improved null-safety. This change affects all \TargetSource\ implementations in the \target\ subpackage, including \AbstractBeanFactoryBasedTargetSource\, \AbstractLazyCreationTargetSource\, \AbstractPoolingTargetSource\, \AbstractPrototypeBasedTargetSource\, \CommonsPool2TargetSource\, \EmptyTargetSource\, \HotSwappableTargetSource\, \LazyInitTargetSource\, \PoolingConfig\, \PrototypeTargetSource\, \SimpleBeanTargetSource\, \SingletonTargetSource\, \ThreadLocalTargetSource\, and \ThreadLocalTargetSourceStats\. The \package-info.java\ for this package is now marked with \@NullMarked\ to enforce these null-safety semantics across the API.

spring-aop/src/main/java/org/springframework/aop/target · high confidence

The Eclipse project settings have been updated to target JDK 17, with source and target compliance set to 17. The configuration now enforces UTF-8 encoding for all project files and Java sources. Code templates have been refreshed, including the @since tag defaulting to 7.0, and the copyright header now uses a \<year\>-present pattern. Additionally, various compiler warnings (such as unclosed AutoCloseable and forbidden references) have been adjusted to reduce noise in the IDE.

src/eclipse · high confidence

The Gradle wrapper has been upgraded to version 9.6.1, ensuring that the project uses a specific, consistent version of the Gradle build tool. This update includes configuration for the distribution URL, network timeout, and retry logic, which helps maintain build reproducibility and reliability across different environments.

gradle · high confidence

The documentation assets in framework-docs/modules/ROOT/assets have been updated with new or replaced files: a modernized SVG diagram for the DispatcherServlet context hierarchy and a new Graffle source file for OXM exceptions. These changes update the visual documentation for Spring MVC and OXM, ensuring the diagrams are current and consistent with the framework's structure.

framework-docs/modules/ROOT/assets · medium confidence

The Spring Framework's XML configuration support has been updated to include schema mappings and namespace handlers for versions 2.0, 2.5, 3.0, 3.1, 3.2, 4.0, 4.1, 4.2, and 4.3. This includes adding missing schema entries for 4.0, 4.1, 4.2, and 4.3, as well as introducing HTTPS mappings for all supported versions. Additionally, tooling metadata has been added to assist IDEs and other tools in recognizing the beans, util, and tool namespaces.

spring-beans/src/main/resources/META-INF · high confidence

This update introduces several behavioral changes and API refinements in Spring WebFlux and WebClient. Key changes include renaming \body(Object)\ to \bodyValue\ and \exchange()\ to \exchangeToMono\/\exchangeToFlux\ in \WebClient.ResponseSpec\, and adding \@Nullable\ annotations to improve null-safety. The \ServerRequest\ API gains \queryParamOrNull\ and \pathVariableOrNull\ for safer access to optional parameters. Additionally, \WebClient\ now supports coroutine context propagation and improved observation handling, while \ServerRequest\ and \WebClient\ APIs are refined to consistently handle null values and improve error reporting.

spring-webflux · medium confidence

Add Kotlin-specific tests for BeanUtils; Add tests for Spring's AspectJ-based async execution; Add unit tests for DefaultNamespaceHandlerResolver; Added AspectJ transactional test fixtures and tests; Added AspectJ-specific cache tests; Added CDI test sample classes for component indexing; Added JCache (JSR-107) cache tests; Added JCache configuration tests; Added JCache test fixtures for cache validation; Added JMH benchmarks for Kotlin bean instantiation; Added JMH benchmarks for Spring BeanFactory performance; Added JPA test candidates for component indexing; Added Kotlin AOP tests for CGLIB proxies and coroutines; Added Kotlin coroutine tests for AopUtils; Added Kotlin test fixtures for bean and factory scenarios; Added Kotlin-specific autowiring tests; Added Kotlin-specific test coverage for AOT and constructor resolution; Added SimpleTarget test fixture for scoped proxy testing; Added TestCompiler utility for Spring context indexer tests; Added and updated tests for Spring AOP components; Added and updated tests for XML bean definition parsing; Added comprehensive tests for Spring Beans Kotlin extensions; Added integration test resources for Spring AOP, beans, and environment profiles; Added integration tests for @EnableCaching and @EnableTransactionManagement; Added integration tests for AOP advice invocation order; Added integration tests for AOP namespace handler behavior; Added integration tests for Environment API support; Added integration tests for SpEL type conversion; Added integration tests for Spring AOP with Kotlin coroutines; Added integration tests for XML-based component bean definition parsing; Added integration tests for the Multi-Release JAR plugin; Added test coverage for AspectJ auto-proxying of code-style aspects; Added test coverage for Spring Beans factory support classes; Added test fixtures for Spring caching configuration; Added test fixtures for the context indexer; Added test for @EnableSpringConfigured aspect registration; Added test resources for Quartz scheduler integration; Added tests for AOT bean factory infrastructure; Added tests for JCache interceptor components; Added tests for PagedListHolder, PropertyComparator, and related support classes; Added tests for Quartz scheduling components; Added tests for SimpleMailMessage defensive copying of sentDate; Added tests for Spring AspectJ integration; Added tests for Spring property editors; Added tests for cache transaction support; Added tests for reflection hint recording; Added unit tests for FreeMarker configuration; Added unit tests for ServiceLoader integration; Added unit tests for Spring Beans factory config components; Expanded test coverage for Spring Beans XML configuration and factory mechanisms; Expanded test coverage for Spring Beans annotation processing; Expanded test coverage for Spring Beans introspection and property access; Integration tests for classpath scanning and bean scopes; New test fixture classes for Spring Beans.

The project's build system has been updated with numerous dependency upgrades, including Kotlin 2.2.10, Netty 4.1.123, and JUnit 5.13.1, alongside other library and plugin version bumps to ensure compatibility and access to new features.

(dependencies) · high confidence

The test suite has been upgraded to JUnit 5.10, bringing the latest improvements and bug fixes from the JUnit Jupiter platform. This update ensures compatibility with the latest JUnit 5 features and improves the overall stability of the test execution environment.

spring-test · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 56.

• Code Health 70
• Architecture 100
• Maturity 59
• Readiness 46
• Security 63

• 300 commits — 281 feature/other, 19 fixes

• (repo) — 84 commits
• spring-core/src — 41 commits
• spring-web/src — 40 commits
• spring-test/src — 14 commits
• spring-webflux/src — 13 commits
• framework-docs/modules — 12 commits
• spring-expression/src — 12 commits
• spring-context/src — 10 commits
• spring-webmvc/src — 10 commits
• framework-platform/framework-platform.gradle — 9 commits
• (root) — 8 commits
• spring-beans/src — 8 commits
• spring-orm/src — 6 commits
• spring-jms/src — 5 commits
• spring-websocket/src — 5 commits
• .github/workflows — 4 commits
• buildSrc/src — 4 commits
• spring-jdbc/src — 4 commits
• framework-docs/package.json — 3 commits
• gradle/spring-module.gradle — 2 commits

• fix: Fix CronExpression day skip on midnight DST gap
• fix: Fix Javadoc error in RetryPolicy
• fix: Fix Javadoc errors in AotContextLoaderTests
• fix: Fix Javadoc in ProtobufDecoder's MessageSizeReader API
• fix: Fix MethodParameter nestingLevel documentation
• fix: Fix URL fetching from environment in Gradle build plugin
• fix: Fix additional links to Selenium documentation
• fix: Fix applicability note on setAutoGrowCollectionLimit
• fix: Fix broken links to Selenium documentation
• fix: Fix build SNAPSHOT workflow
• fix: Fix checkStyleNoHttp errors
• fix: Fix concurrency issue against shared cookie field in setLocaleContext
• fix: Fix data loss in DataBufferUtils synchronous write
• fix: Fix delegation in LifecyclePrintWriter
• fix: Fix docs build trigger
• fix: Fix fragment parsing for relative URI in RfcUriParser
• fix: Fix last flag check in JettyWebSocketSession
• fix: Fix off-by-one error in MimeTypeUtils.parseMimeType()
• fix: Fix primitive array annotation attributes on Java 24 class reading
• change: Adapt query proxy if necessary (for compatibility with Hibernate 8.0)
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

spring-projects/spring-framework was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.