Release v6.0.12

2026-06-08 17:33:33 +00:00 · 2023-09-14 07:51:30 +00:00
546 changed files with 5952 additions and 10622 deletions
@@ -1,33 +0,0 @@
-name: Send notification
-description: Sends a Google Chat message as a notification of the job's outcome
-inputs:
-  webhook-url:
-    description: 'Google Chat Webhook URL'
-    required: true
-  status:
-    description: 'Status of the job'
-    required: true
-  build-scan-url:
-    description: 'URL of the build scan to include in the notification'
-  run-name:
-    description: 'Name of the run to include in the notification'
-    default: ${{ format('{0} {1}', github.ref_name, github.job) }}
-runs:
-  using: composite
-  steps:
-    - shell: bash
-      run: |
-        echo "BUILD_SCAN=${{ inputs.build-scan-url == '' && ' [build scan unavailable]' || format(' [<{0}|Build Scan>]', inputs.build-scan-url) }}" >> "$GITHUB_ENV"
-        echo "RUN_URL=${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" >> "$GITHUB_ENV"
-    - shell: bash
-      if: ${{ inputs.status == 'success' }}
-      run: |
-        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<${{ env.RUN_URL }}|${{ inputs.run-name }}> was successful ${{ env.BUILD_SCAN }}"}' || true
-    - shell: bash
-      if: ${{ inputs.status == 'failure' }}
-      run: |
-        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<users/all> *<${{ env.RUN_URL }}|${{ inputs.run-name }}> failed* ${{ env.BUILD_SCAN }}"}' || true
-    - shell: bash
-      if: ${{ inputs.status == 'cancelled' }}
-      run: |
-        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<${{ env.RUN_URL }}|${{ inputs.run-name }}> was cancelled"}' || true
@@ -18,13 +18,11 @@ jobs:
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Java
-        uses: actions/setup-java@v4
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
        with:
-          distribution: 'liberica'
-          java-version: 17
+          distribution: 'temurin'
+          java-version: '17'
      - name: Download BackportBot
        run: wget https://github.com/spring-io/backport-bot/releases/download/latest/backport-bot-0.0.1-SNAPSHOT.jar
      - name: Backport
@@ -1,63 +0,0 @@
-name: Build and deploy snapshot
-on:
-  push:
-    branches:
-      - 6.0.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  build-and-deploy-snapshot:
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    name: Build and deploy snapshot
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: 17
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Gradle
-        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
-        with:
-          cache-read-only: false
-      - name: Configure Gradle properties
-        shell: bash
-        run: |
-          mkdir -p $HOME/.gradle
-          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
-          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
-      - name: Build and publish
-        id: build
-        env:
-          CI: 'true'
-          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
-          DEVELOCITY_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-        run: ./gradlew -PdeploymentRepository=$(pwd)/deployment-repository build publishAllPublicationsToDeploymentRepository
-      - name: Deploy
-        uses: spring-io/artifactory-deploy-action@v0.0.1
-        with:
-          uri: 'https://repo.spring.io'
-          username: ${{ secrets.ARTIFACTORY_USERNAME }}
-          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-          build-name: ${{ format('spring-framework-{0}', github.ref_name)}}
-          repository: 'libs-snapshot-local'
-          folder: 'deployment-repository'
-          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
-          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          artifact-properties: |
-            /**/framework-docs-*.zip::zip.name=spring-framework,zip.deployed=false
-            /**/framework-docs-*-docs.zip::zip.type=docs
-            /**/framework-docs-*-dist.zip::zip.type=dist
-            /**/framework-docs-*-schema.zip::zip.type=schema
-      - name: Send notification
-        uses: ./.github/actions/send-notification
-        if: always()
-        with:
-          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-          status: ${{ job.status }}
-          build-scan-url: ${{ steps.build.outputs.build-scan-url }}
-          run-name: ${{ format('{0} | Linux | Java 17', github.ref_name) }}
@@ -1,78 +0,0 @@
-name: CI
-on:
-  push:
-    branches:
-      - 6.0.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  ci:
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    strategy:
-      matrix:
-        os:
-          - id: ubuntu-latest
-            name: Linux
-        java:
-          - version: 17
-            toolchain: false
-          - version: 21
-            toolchain: true
-        exclude:
-          - os:
-              name: Linux
-            java:
-              version: 17
-    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
-    runs-on: ${{ matrix.os.id }}
-    steps:
-      - name: Set up Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: |
-            ${{ matrix.java.version }}
-            ${{ matrix.java.toolchain && '17' || '' }}
-      - name: Prepare Windows runner
-        if: ${{ runner.os == 'Windows' }}
-        run: |
-          git config --global core.autocrlf true
-          git config --global core.longPaths true
-          Stop-Service -name Docker
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Gradle
-        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
-        with:
-          cache-read-only: false
-      - name: Configure Gradle properties
-        shell: bash
-        run: |
-          mkdir -p $HOME/.gradle
-          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
-          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
-      - name: Configure toolchain properties
-        if: ${{ matrix.java.toolchain }}
-        shell: bash
-        run: |
-          echo toolchainVersion=${{ matrix.java.version }} >> $HOME/.gradle/gradle.properties
-          echo systemProp.org.gradle.java.installations.auto-detect=false >> $HOME/.gradle/gradle.properties
-          echo systemProp.org.gradle.java.installations.auto-download=false >> $HOME/.gradle/gradle.properties
-          echo systemProp.org.gradle.java.installations.paths=${{ format('$JAVA_HOME_{0}_X64', matrix.java.version) }} >> $HOME/.gradle/gradle.properties
-      - name: Build
-        id: build
-        env:
-          CI: 'true'
-          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
-          DEVELOCITY_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-        run: ./gradlew check antora
-      - name: Send notification
-        uses: ./.github/actions/send-notification
-        if: always()
-        with:
-          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-          status: ${{ job.status }}
-          build-scan-url: ${{ steps.build.outputs.build-scan-url }}
-          run-name: ${{ format('{0} | {1} | Java {2}', github.ref_name, matrix.os.name, matrix.java.version) }}
@@ -1,14 +1,12 @@
 name: Deploy Docs
 on:
  push:
-    branches:
-      - 'main'
-      - '*.x'
-      - '!gh-pages'
-    tags:
-      - 'v*'
+    branches-ignore: [ gh-pages ]
+    tags: '**'
  repository_dispatch:
    types: request-build-reference # legacy
+  schedule:
+  - cron: '0 10 * * *' # Once per day at 10am UTC
  workflow_dispatch:
 permissions:
  actions: write
@@ -17,8 +15,8 @@ jobs:
    runs-on: ubuntu-latest
    if: github.repository_owner == 'spring-projects'
    steps:
-    - name: Check out code
-      uses: actions/checkout@v4
+    - name: Checkout
+      uses: actions/checkout@v3
      with:
        ref: docs-build
        fetch-depth: 1
@@ -9,5 +9,5 @@ jobs:
    name: "Validation"
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
-      - uses: gradle/wrapper-validation-action@v2
+      - uses: actions/checkout@v3
+      - uses: gradle/wrapper-validation-action@v1
@@ -0,0 +1,36 @@
+Juergen Hoeller <jhoeller@vmware.com>
+Juergen Hoeller <jhoeller@vmware.com> <jhoeller@pivotal.io>
+Juergen Hoeller <jhoeller@vmware.com> <jhoeller@gopivotal.com>
+Rossen Stoyanchev <rstoyanchev@vmware.com>
+Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@pivotal.io>
+Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@gopivotal.com>
+Phillip Webb <pwebb@vmware.com>
+Phillip Webb <pwebb@vmware.com> <pwebb@pivotal.io>
+Phillip Webb <pwebb@vmware.com> <pwebb@gopivotal.com>
+Chris Beams <cbeams@vmware.com>
+Chris Beams <cbeams@vmware.com> <cbeams@pivotal.io>
+Chris Beams <cbeams@vmware.com> <cbeams@gopivotal.com>
+Arjen Poutsma <poutsmaa@vmware.com>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@pivotal.io>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@gopivotal.com>
+Arjen Poutsma <poutsmaa@vmware.com> <poutsma@mac.com>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@vmware.com>
+Oliver Drotbohm <odrotbohm@vmware.com>
+Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@vmware.com>
+Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@pivotal.io>
+Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@gopivotal.com>
+Dave Syer <dsyer@vmware.com>
+Dave Syer <dsyer@vmware.com> <dsyer@pivotal.io>
+Dave Syer <dsyer@vmware.com> <dsyer@gopivotal.com>
+Dave Syer <dsyer@vmware.com> <david_syer@hotmail.com>
+Andy Clement <aclement@vmware.com>
+Andy Clement <aclement@vmware.com> <aclement@pivotal.io>
+Andy Clement <aclement@vmware.com> <aclement@gopivotal.com>
+Andy Clement <aclement@vmware.com> <andrew.clement@gmail.com>
+Sam Brannen <sbrannen@vmware.com>
+Sam Brannen <sbrannen@vmware.com> <sbrannen@pivotal.io>
+Sam Brannen <sbrannen@vmware.com> <sam@sambrannen.com>
+Simon Basle <sbasle@vmware.com>
+Simon Baslé <sbasle@vmware.com>
+<dmitry.katsubo@gmail.com> <dmitry.katsubo@gmai.com>
+Nick Williams <nicholas@nicholaswilliams.net>
@@ -1,3 +1,3 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
-java=17.0.11-librca
+java=17.0.7-librca
@@ -1,4 +1,4 @@
-# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://github.com/spring-projects/spring-framework/actions/workflows/build-and-deploy-snapshot.yml/badge.svg?branch=6.0.x)](https://github.com/spring-projects/spring-framework/actions/workflows/build-and-deploy-snapshot.yml?query=branch%3A6.0.x) [![Revved up by Develocity](https://img.shields.io/badge/Revved%20up%20by-Develocity-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
+# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-6.0.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)

 This is the home of the Spring Framework: the foundation for all [Spring projects](https://spring.io/projects). Collectively the Spring Framework and the family of Spring projects are often referred to simply as "Spring". 

@@ -3,12 +3,12 @@ plugins {
 	id 'io.freefair.aspectj' version '8.0.1' apply false
 	// kotlinVersion is managed in gradle.properties
 	id 'org.jetbrains.kotlin.plugin.serialization' version "${kotlinVersion}" apply false
-	id 'org.jetbrains.dokka' version '1.8.20'
+	id 'org.jetbrains.dokka' version '1.8.10'
 	id 'org.unbroken-dome.xjc' version '2.0.0' apply false
-	id 'com.github.ben-manes.versions' version '0.51.0'
+	id 'com.github.ben-manes.versions' version '0.46.0'
 	id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
 	id 'de.undercouch.download' version '5.4.0'
-	id 'me.champeau.jmh' version '0.7.2' apply false
+	id 'me.champeau.jmh' version '0.7.1' apply false
 }

 ext {
@@ -75,7 +75,7 @@ configure([rootProject] + javaProjects) { project ->
 	}

 	checkstyle {
-		toolVersion = "10.12.7"
+		toolVersion = "10.12.3"
 		configDirectory.set(rootProject.file("src/checkstyle"))
 	}

@@ -106,13 +106,14 @@ configure([rootProject] + javaProjects) { project ->
 		// JSR-305 only used for non-required meta-annotations
 		compileOnly("com.google.code.findbugs:jsr305")
 		testCompileOnly("com.google.code.findbugs:jsr305")
-		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.41")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.39")
 	}

 	ext.javadocLinks = [
 			"https://docs.oracle.com/en/java/javase/17/docs/api/",
 			"https://jakarta.ee/specifications/platform/9/apidocs/",
 			"https://docs.oracle.com/cd/E13222_01/wls/docs90/javadocs/",  // CommonJ and weblogic.* packages
+			"https://www.ibm.com/docs/api/v1/content/SSEQTP_8.5.5/com.ibm.websphere.javadoc.doc/web/apidocs/", // com.ibm.*
 			"https://docs.jboss.org/jbossas/javadoc/4.0.5/connector/", // org.jboss.resource.*
 			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
 			"https://eclipse.dev/aspectj/doc/released/aspectj5rt-api",
@@ -145,6 +146,7 @@ configure(rootProject) {
 	description = "Spring Framework"

 	apply plugin: "io.spring.nohttp"
+	apply plugin: 'org.springframework.build.api-diff'

 	nohttp {
 		source.exclude "**/test-output/**"
@@ -22,6 +22,21 @@ but doesn't affect the classpath of dependent projects.
 This plugin does not provide a `provided` configuration, as the native `compileOnly` and `testCompileOnly`
 configurations are preferred.

+### API Diff
+
+This plugin uses the [Gradle JApiCmp](https://github.com/melix/japicmp-gradle-plugin) plugin
+to generate API Diff reports for each Spring Framework module. This plugin is applied once on the root
+project and creates tasks in each framework module. Unlike previous versions of this part of the build,
+there is no need for checking out a specific tag. The plugin will fetch the JARs we want to compare the
+current working version with. You can generate the reports for all modules or a single module:
+
+```
+./gradlew apiDiff -PbaselineVersion=5.1.0.RELEASE
+./gradlew :spring-core:apiDiff -PbaselineVersion=5.1.0.RELEASE
+```      
+
+The reports are located under `build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/`.
+                                                                                       

 ### RuntimeHints Java Agent

@@ -19,11 +19,16 @@ ext {
 dependencies {
 	implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
 	implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}")
-	implementation "org.gradle:test-retry-gradle-plugin:1.5.6"
+	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.3.0"
+	implementation "org.gradle:test-retry-gradle-plugin:1.4.1"
 }

 gradlePlugin {
 	plugins {
+		apiDiffPlugin {
+			id = "org.springframework.build.api-diff"
+			implementationClass = "org.springframework.build.api.ApiDiffPlugin"
+		}
 		conventionsPlugin {
 			id = "org.springframework.build.conventions"
 			implementationClass = "org.springframework.build.ConventionsPlugin"
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2002-2019 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
+ *
+ *      https://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.build.api;
+
+import java.io.File;
+import java.net.URI;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+
+import me.champeau.gradle.japicmp.JapicmpPlugin;
+import me.champeau.gradle.japicmp.JapicmpTask;
+import org.gradle.api.GradleException;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
+import org.gradle.api.tasks.TaskProvider;
+import org.gradle.jvm.tasks.Jar;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * {@link Plugin} that applies the {@code "japicmp-gradle-plugin"}
+ * and create tasks for all subprojects named {@code "spring-*"}, diffing the public API one by one
+ * and creating the reports in {@code "build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/"}.
+ * <p>{@code "./gradlew apiDiff -PbaselineVersion=5.1.0.RELEASE"} will output the
+ * reports for the API diff between the baseline version and the current one for all modules.
+ * You can limit the report to a single module with
+ * {@code "./gradlew :spring-core:apiDiff -PbaselineVersion=5.1.0.RELEASE"}.
+ *
+ * @author Brian Clozel
+ */
+public class ApiDiffPlugin implements Plugin<Project> {
+
+	private static final Logger logger = LoggerFactory.getLogger(ApiDiffPlugin.class);
+
+	public static final String TASK_NAME = "apiDiff";
+
+	private static final String BASELINE_VERSION_PROPERTY = "baselineVersion";
+
+	private static final List<String> PACKAGE_INCLUDES = Collections.singletonList("org.springframework.*");
+
+	private static final URI SPRING_MILESTONE_REPOSITORY = URI.create("https://repo.spring.io/milestone");
+
+	@Override
+	public void apply(Project project) {
+		if (project.hasProperty(BASELINE_VERSION_PROPERTY) && project.equals(project.getRootProject())) {
+			project.getPluginManager().apply(JapicmpPlugin.class);
+			project.getPlugins().withType(JapicmpPlugin.class,
+					plugin -> applyApiDiffConventions(project));
+		}
+	}
+
+	private void applyApiDiffConventions(Project project) {
+		String baselineVersion = project.property(BASELINE_VERSION_PROPERTY).toString();
+		project.subprojects(subProject -> {
+			if (subProject.getName().startsWith("spring-")) {
+				createApiDiffTask(baselineVersion, subProject);
+			}
+		});
+	}
+
+	private void createApiDiffTask(String baselineVersion, Project project) {
+		if (isProjectEligible(project)) {
+			// Add Spring Milestone repository for generating diffs against previous milestones
+			project.getRootProject()
+					.getRepositories()
+					.maven(mavenArtifactRepository -> mavenArtifactRepository.setUrl(SPRING_MILESTONE_REPOSITORY));
+			JapicmpTask apiDiff = project.getTasks().create(TASK_NAME, JapicmpTask.class);
+			apiDiff.setDescription("Generates an API diff report with japicmp");
+			apiDiff.setGroup(JavaBasePlugin.DOCUMENTATION_GROUP);
+
+			apiDiff.setOldClasspath(createBaselineConfiguration(baselineVersion, project));
+			TaskProvider<Jar> jar = project.getTasks().withType(Jar.class).named("jar");
+			apiDiff.setNewArchives(project.getLayout().files(jar.get().getArchiveFile().get().getAsFile()));
+			apiDiff.setNewClasspath(getRuntimeClassPath(project));
+			apiDiff.setPackageIncludes(PACKAGE_INCLUDES);
+			apiDiff.setOnlyModified(true);
+			apiDiff.setIgnoreMissingClasses(true);
+			// Ignore Kotlin metadata annotations since they contain
+			// illegal HTML characters and fail the report generation
+			apiDiff.setAnnotationExcludes(Collections.singletonList("@kotlin.Metadata"));
+
+			apiDiff.setHtmlOutputFile(getOutputFile(baselineVersion, project));
+
+			apiDiff.dependsOn(project.getTasks().getByName("jar"));
+		}
+	}
+
+	private boolean isProjectEligible(Project project) {
+		return project.getPlugins().hasPlugin(JavaPlugin.class)
+				&& project.getPlugins().hasPlugin(MavenPublishPlugin.class);
+	}
+
+	private Configuration createBaselineConfiguration(String baselineVersion, Project project) {
+		String baseline = String.join(":",
+				project.getGroup().toString(), project.getName(), baselineVersion);
+		Dependency baselineDependency = project.getDependencies().create(baseline + "@jar");
+		Configuration baselineConfiguration = project.getRootProject().getConfigurations().detachedConfiguration(baselineDependency);
+		try {
+			// eagerly resolve the baseline configuration to check whether this is a new Spring module
+			baselineConfiguration.resolve();
+			return baselineConfiguration;
+		}
+		catch (GradleException exception) {
+			logger.warn("Could not resolve {} - assuming this is a new Spring module.", baseline);
+		}
+		return project.getRootProject().getConfigurations().detachedConfiguration();
+	}
+
+	private Configuration getRuntimeClassPath(Project project) {
+		return project.getConfigurations().getByName(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME);
+	}
+
+	private File getOutputFile(String baseLineVersion, Project project) {
+		Path outDir = Paths.get(project.getRootProject().getBuildDir().getAbsolutePath(),
+				"reports", "api-diff",
+				baseLineVersion + "_to_" + project.getRootProject().getVersion());
+		return project.file(outDir.resolve(project.getName() + ".html").toString());
+	}
+
+}
@@ -1,7 +1,5 @@
 == Spring Framework Concourse pipeline

-NOTE: CI is being migrated to GitHub Actions.
-
 The Spring Framework uses https://concourse-ci.org/[Concourse] for its CI build and other automated tasks.
 The Spring team has a dedicated Concourse instance available at https://ci.spring.io with a build pipeline
 for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x[Spring Framework 6.0.x].
@@ -1,4 +1,4 @@
-FROM ubuntu:jammy-20240125
+FROM ubuntu:jammy-20230816

 ADD setup.sh /setup.sh
 ADD get-jdk-url.sh /get-jdk-url.sh
@@ -6,5 +6,6 @@ RUN ./setup.sh

 ENV JAVA_HOME /opt/openjdk/java17
 ENV JDK17 /opt/openjdk/java17
+ENV JDK20 /opt/openjdk/java20

 ENV PATH $JAVA_HOME/bin:$PATH
@@ -3,7 +3,10 @@ set -e

 case "$1" in
 	java17)
-		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.10%2B13/bellsoft-jdk17.0.10+13-linux-amd64.tar.gz"
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.7+7/bellsoft-jdk17.0.7+7-linux-amd64.tar.gz"
+	;;
+	java20)
+		echo "https://github.com/bell-sw/Liberica/releases/download/20.0.1+10/bellsoft-jdk20.0.1+10-linux-amd64.tar.gz"
 	;;
 	*)
 		echo $"Unknown java version"
@@ -20,7 +20,7 @@ curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/c

 mkdir -p /opt/openjdk
 pushd /opt/openjdk > /dev/null
-for jdk in java17
+for jdk in java17 java20
 do
  JDK_URL=$( /get-jdk-url.sh $jdk )
  mkdir $jdk
@@ -8,3 +8,4 @@ milestone: "6.0.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
 concourse-url: "https://ci.spring.io"
+task-timeout: 1h00m
@@ -5,7 +5,9 @@ anchors:
    password: ((github-ci-release-token))
    branch: ((branch))
  gradle-enterprise-task-params: &gradle-enterprise-task-params
-    DEVELOCITY_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
+    GRADLE_ENTERPRISE_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
+    GRADLE_ENTERPRISE_CACHE_USERNAME: ((gradle_enterprise_cache_user.username))
+    GRADLE_ENTERPRISE_CACHE_PASSWORD: ((gradle_enterprise_cache_user.password))
  sonatype-task-params: &sonatype-task-params
    SONATYPE_USERNAME: ((sonatype-username))
    SONATYPE_PASSWORD: ((sonatype-password))
@@ -21,6 +23,14 @@ anchors:
  docker-resource-source: &docker-resource-source
    username: ((docker-hub-username))
    password: ((docker-hub-password))
+  slack-fail-params: &slack-fail-params
+    text: >
+      :concourse-failed: <https://ci.spring.io/teams/${BUILD_TEAM_NAME}/pipelines/${BUILD_PIPELINE_NAME}/jobs/${BUILD_JOB_NAME}/builds/${BUILD_NAME}|${BUILD_PIPELINE_NAME} ${BUILD_JOB_NAME} failed!>
+      [$TEXT_FILE_CONTENT]
+    text_file: git-repo/build/build-scan-uri.txt
+    silent: true
+    icon_emoji: ":concourse:"
+    username: concourse-ci
  changelog-task-params: &changelog-task-params
    name: generated-changelog/tag
    tag: generated-changelog/tag
@@ -35,7 +45,7 @@ resource_types:
  source:
    <<: *docker-resource-source
    repository: concourse/registry-image-resource
-    tag: 1.8.0
+    tag: 1.5.0
 - name: artifactory-resource
  type: registry-image
  source:
@@ -47,13 +57,19 @@ resource_types:
  source:
    <<: *docker-resource-source
    repository: concourse/github-release-resource
-    tag: 1.8.0
+    tag: 1.5.5
 - name: github-status-resource
  type: registry-image
  source:
    <<: *docker-resource-source
    repository: dpb587/github-status-resource
    tag: master
+- name: slack-notification
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: cfcommunity/slack-notification-resource
+    tag: latest
 resources:
 - name: git-repo
  type: git
@@ -74,6 +90,13 @@ resources:
    <<: *docker-resource-source
    repository: ((docker-hub-organization))/spring-framework-ci
    tag: ((milestone))
+- name: every-morning
+  type: time
+  icon: alarm
+  source:
+    start: 8:00 AM
+    stop: 9:00 AM
+    location: Europe/Vienna
 - name: artifactory-repo
  type: artifactory-resource
  icon: package-variant
@@ -82,6 +105,27 @@ resources:
    username: ((artifactory-username))
    password: ((artifactory-password))
    build_name: ((build-name))
+- name: repo-status-build
+  type: github-status-resource
+  icon: eye-check-outline
+  source:
+    repository: ((github-repo-name))
+    access_token: ((github-ci-status-token))
+    branch: ((branch))
+    context: build
+- name: repo-status-jdk20-build
+  type: github-status-resource
+  icon: eye-check-outline
+  source:
+    repository: ((github-repo-name))
+    access_token: ((github-ci-status-token))
+    branch: ((branch))
+    context: jdk20-build
+- name: slack-alert
+  type: slack-notification
+  icon: slack
+  source:
+    url: ((slack-webhook-url))
 - name: github-pre-release
  type: github-release
  icon: briefcase-download-outline
@@ -116,23 +160,37 @@ jobs:
    - put: ci-image
      params:
        image: ci-image/image.tar
- name: stage-milestone
+- name: build
  serial: true
+  public: true
  plan:
  - get: ci-image
  - get: git-repo
-    trigger: false
-  - task: stage
-    image: ci-image
-    file: git-repo/ci/tasks/stage-version.yml
-    params:
-      RELEASE_TYPE: M
-      <<: *gradle-enterprise-task-params
+    trigger: true
+  - put: repo-status-build
+    params: { state: "pending", commit: "git-repo" }
+  - do:
+    - task: build-project
+      image: ci-image
+      file: git-repo/ci/tasks/build-project.yml
+      privileged: true
+      timeout: ((task-timeout))
+      params:
+        <<: *build-project-task-params
+    on_failure:
+      do:
+      - put: repo-status-build
+        params: { state: "failure", commit: "git-repo" }
+      - put: slack-alert
+        params:
+          <<: *slack-fail-params
+  - put: repo-status-build
+    params: { state: "success", commit: "git-repo" }
  - put: artifactory-repo
    params: &artifactory-params
      signing_key: ((signing-key))
      signing_passphrase: ((signing-passphrase))
-      repo: libs-staging-local
+      repo: libs-snapshot-local
      folder: distribution-repository
      build_uri: "https://ci.spring.io/teams/${BUILD_TEAM_NAME}/pipelines/${BUILD_PIPELINE_NAME}/jobs/${BUILD_JOB_NAME}/builds/${BUILD_NAME}"
      build_number: "${BUILD_PIPELINE_NAME}-${BUILD_JOB_NAME}-${BUILD_NAME}"
@@ -157,9 +215,55 @@ jobs:
        - "/**/framework-docs-*-schema.zip"
        properties:
          "zip.type": "schema"
-  - put: git-repo
-    params:
-      repository: stage-git-repo
+    get_params:
+      threads: 8
+- name: jdk20-build
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: every-morning
+      trigger: true
+    - put: repo-status-jdk20-build
+      params: { state: "pending", commit: "git-repo" }
+    - do:
+        - task: check-project
+          image: ci-image
+          file: git-repo/ci/tasks/check-project.yml
+          privileged: true
+          timeout: ((task-timeout))
+          params:
+            TEST_TOOLCHAIN: 20
+            <<: *build-project-task-params
+      on_failure:
+        do:
+          - put: repo-status-jdk20-build
+            params: { state: "failure", commit: "git-repo" }
+          - put: slack-alert
+            params:
+              <<: *slack-fail-params
+    - put: repo-status-jdk20-build
+      params: { state: "success", commit: "git-repo" }
+- name: stage-milestone
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - task: stage
+      image: ci-image
+      file: git-repo/ci/tasks/stage-version.yml
+      params:
+        RELEASE_TYPE: M
+        <<: *gradle-enterprise-task-params
+    - put: artifactory-repo
+      params:
+        <<: *artifactory-params
+        repo: libs-staging-local
+    - put: git-repo
+      params:
+        repository: stage-git-repo
 - name: promote-milestone
  serial: true
  plan:
@@ -201,6 +305,7 @@ jobs:
    - put: artifactory-repo
      params:
        <<: *artifactory-params
+        repo: libs-staging-local
    - put: git-repo
      params:
        repository: stage-git-repo
@@ -245,6 +350,7 @@ jobs:
    - put: artifactory-repo
      params:
        <<: *artifactory-params
+        repo: libs-staging-local
    - put: git-repo
      params:
        repository: stage-git-repo
@@ -289,6 +395,8 @@ jobs:
        <<: *changelog-task-params

 groups:
+- name: "builds"
+  jobs: ["build", "jdk20-build"]
 - name: "releases"
  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
 - name: "ci-images"
@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+
+pushd git-repo > /dev/null
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --max-workers=4 check
+popd > /dev/null
@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+repository=$(pwd)/distribution-repository
+
+pushd git-repo > /dev/null
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
+popd > /dev/null
@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+
+pushd git-repo > /dev/null
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK20 \
+  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check antora
+popd > /dev/null
@@ -0,0 +1,19 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+caches:
+- path: gradle
+params:
+  BRANCH:
+  CI: true
+  GRADLE_ENTERPRISE_ACCESS_KEY:
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+run:
+  path: bash
+  args:
+    - -ec
+    - |
+      ${PWD}/git-repo/ci/scripts/build-pr.sh
@@ -0,0 +1,22 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+outputs:
+- name: distribution-repository
+- name: git-repo
+caches:
+- path: gradle
+params:
+  BRANCH:
+  CI: true
+  GRADLE_ENTERPRISE_ACCESS_KEY:
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+run:
+  path: bash
+  args:
+    - -ec
+    - |
+      ${PWD}/git-repo/ci/scripts/build-project.sh
@@ -0,0 +1,24 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+outputs:
+- name: distribution-repository
+- name: git-repo
+caches:
+- path: gradle
+params:
+  BRANCH:
+  CI: true
+  MAIN_TOOLCHAIN:
+  TEST_TOOLCHAIN:
+  GRADLE_ENTERPRISE_ACCESS_KEY:
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+run:
+  path: bash
+  args:
+    - -ec
+    - |
+      ${PWD}/git-repo/ci/scripts/check-project.sh
@@ -4,7 +4,7 @@ image_resource:
  type: registry-image
  source:
    repository: springio/concourse-release-scripts
-    tag: '0.4.0'
+    tag: '0.3.4'
    username: ((docker-hub-username))
    password: ((docker-hub-password))
 inputs:
@@ -39,8 +39,8 @@
 ** xref:core/resources.adoc[]
 ** xref:core/validation.adoc[]
 *** xref:core/validation/validator.adoc[]
-*** xref:core/validation/beans-beans.adoc[]
 *** xref:core/validation/conversion.adoc[]
+*** xref:core/validation/beans-beans.adoc[]
 *** xref:core/validation/convert.adoc[]
 *** xref:core/validation/format.adoc[]
 *** xref:core/validation/format-configuring-formatting-globaldatetimeformat.adoc[]
@@ -431,4 +431,4 @@
 ** xref:languages/groovy.adoc[]
 ** xref:languages/dynamic.adoc[]
 * xref:appendix.adoc[]
-* https://github.com/spring-projects/spring-framework/wiki[Wiki]
+* https://github.com/spring-projects/spring-framework/wiki[Wiki]
@@ -168,7 +168,7 @@ Kotlin::
 ======

 NOTE: Pooling stateless service objects is not usually necessary. We do not believe it should
-be the default choice, as most stateless objects are naturally thread-safe, and instance
+be the default choice, as most stateless objects are naturally thread safe, and instance
 pooling is problematic if resources are cached.

 Simpler pooling is available by using auto-proxying. You can set the `TargetSource` implementations
@@ -6,8 +6,8 @@ it until later.

 By default, there is a single instance of each aspect within the application
 context. AspectJ calls this the singleton instantiation model. It is possible to define
-aspects with alternate lifecycles. Spring supports AspectJ's `perthis`, `pertarget`, and
-`pertypewithin` instantiation models; `percflow` and `percflowbelow` are not currently
+aspects with alternate lifecycles. Spring supports AspectJ's `perthis` and `pertarget`
+instantiation models; `percflow`, `percflowbelow`, and `pertypewithin` are not currently
 supported.

 You can declare a `perthis` aspect by specifying a `perthis` clause in the `@Aspect`
@@ -565,17 +565,6 @@ is a convenience mechanism that sets up a xref:core/beans/factory-extension.adoc
 for you. If you need more control over the specific
 `PropertySourcesPlaceholderConfigurer` setup, you can explicitly define it as a bean yourself.

-[WARNING]
-=====
-Only one such element should be defined for a given application with the properties
-that it needs. Several property placeholders can be configured as long as they have distinct
-placeholder syntax (`${...}`).
-
-If you need to modularize the source of properties used for the replacement, you should
-not create multiple properties placeholders. Rather, each module should contribute a
-`PropertySource` to the `Environment`. Alternatively, you can create your own
-`PropertySourcesPlaceholderConfigurer` bean that gathers the properties to use.
-=====

 [[xsd-schemas-context-ac]]
 === Using `<annotation-config/>`
@@ -141,7 +141,7 @@ Kotlin::
 ====
 After you learn about Spring's IoC container, you may want to know more about Spring's
 `Resource` abstraction (as described in
-xref:core/resources.adoc[Resources])
+xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources])
 which provides a convenient mechanism for reading an InputStream from locations defined
 in a URI syntax. In particular, `Resource` paths are used to construct applications contexts,
 as described in xref:core/resources.adoc#resources-app-ctx[Application Contexts and Resource Paths].
@@ -562,9 +562,8 @@ If no profile is active, the `dataSource` is created. You can see this
 as a way to provide a default definition for one or more beans. If any
 profile is enabled, the default profile does not apply.

-The name of the default profile is `default`. You can change the name of
-the default profile by using `setDefaultProfiles()` on the `Environment` or,
-declaratively, by using the `spring.profiles.default` property.
+You can change the name of the default profile by using `setDefaultProfiles()` on
+the `Environment` or, declaratively, by using the `spring.profiles.default` property.



@@ -372,17 +372,6 @@ The `PropertySourcesPlaceholderConfigurer` not only looks for properties in the
 file you specify. By default, if it cannot find a property in the specified properties files,
 it checks against Spring `Environment` properties and regular Java `System` properties.

-[WARNING]
-=====
-Only one such element should be defined for a given application with the properties
-that it needs. Several property placeholders can be configured as long as they have distinct
-placeholder syntax (`${...}`).
-
-If you need to modularize the source of properties used for the replacement, you should
-not create multiple properties placeholders. Rather, you should create your own
-`PropertySourcesPlaceholderConfigurer` bean that gathers the properties to use.
-=====
-
 [TIP]
 =====
 You can use the `PropertySourcesPlaceholderConfigurer` to substitute class names, which
@@ -324,6 +324,7 @@ Kotlin::



+
 [[beans-factory-scopes-application]]
 === Application Scope

@@ -373,6 +374,7 @@ Kotlin::



+
 [[beans-factory-scopes-websocket]]
 === WebSocket Scope

@@ -382,6 +384,7 @@ xref:web/websocket/stomp/scope.adoc[WebSocket scope] for more details.



+
 [[beans-factory-scopes-other-injection]]
 === Scoped Beans as Dependencies

@@ -511,8 +514,8 @@ the `<aop:scoped-proxy/>` element, a CGLIB-based class proxy is created.

 [NOTE]
 ====
-CGLIB proxies do not intercept private methods. Attempting to call a private method
-on such a proxy will not delegate to the actual scoped target object.
+CGLIB proxies intercept only public method calls! Do not call non-public methods
+on such a proxy. They are not delegated to the actual scoped target object.
 ====

 Alternatively, you can configure the Spring container to create standard JDK
@@ -113,8 +113,7 @@ issue, because no compiler is involved, and you can declare
 When using `@Configuration` classes, the Java compiler places constraints on
 the configuration model, in that references to other beans must be valid Java syntax.

-Fortunately, solving this problem is simple. As
-xref:core/beans/java/bean-annotation.adoc#beans-java-dependencies[we already discussed],
+Fortunately, solving this problem is simple. As xref:core/beans/java/bean-annotation.adoc#beans-java-dependencies[we already discussed],
 a `@Bean` method can have an arbitrary number of parameters that describe the bean
 dependencies. Consider the following more real-world scenario with several `@Configuration`
 classes, each depending on beans declared in the others:
@@ -205,6 +204,7 @@ Kotlin::
 ----
 ======

+
 There is another way to achieve the same result. Remember that `@Configuration` classes are
 ultimately only another bean in the container: This means that they can take advantage of
 `@Autowired` and `@Value` injection and other features the same as any other bean.
@@ -216,11 +216,6 @@ classes are processed quite early during the initialization of the context, and
 to be injected this way may lead to unexpected early initialization. Whenever possible, resort to
 parameter-based injection, as in the preceding example.

-Avoid access to locally defined beans within a `@PostConstruct` method on the same configuration
-class. This effectively leads to a circular reference since non-static `@Bean` methods semantically
-require a fully initialized configuration class instance to be called on. With circular references
-disallowed (e.g. in Spring Boot 2.6+), this may trigger a `BeanCurrentlyInCreationException`.
-
 Also, be particularly careful with `BeanPostProcessor` and `BeanFactoryPostProcessor` definitions
 through `@Bean`. Those should usually be declared as `static @Bean` methods, not triggering the
 instantiation of their containing configuration class. Otherwise, `@Autowired` and `@Value` may not
@@ -4,7 +4,7 @@
 Projection lets a collection drive the evaluation of a sub-expression, and the result is
 a new collection. The syntax for projection is `.![projectionExpression]`. For example,
 suppose we have a list of inventors but want the list of cities where they were born.
-Effectively, we want to evaluate `placeOfBirth.city` for every entry in the inventor
+Effectively, we want to evaluate 'placeOfBirth.city' for every entry in the inventor
 list. The following example uses projection to do so:

 [tabs]
@@ -13,18 +13,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	// evaluates to ["SmilJan", "Idvor"]
-	List placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]")
-			.getValue(societyContext, List.class);
+	// returns ['Smiljan', 'Idvor' ]
+	List placesOfBirth = (List)parser.parseExpression("members.![placeOfBirth.city]");
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	// evaluates to ["SmilJan", "Idvor"]
-	val placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]")
-	 		.getValue(societyContext) as List<*>
+	// returns ['Smiljan', 'Idvor' ]
+	val placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]") as List<*>
 ----
 ======

@@ -28,14 +28,13 @@ Kotlin::
 ======

 Selection is supported for arrays and anything that implements `java.lang.Iterable` or
-`java.util.Map`. For an array or `Iterable`, the selection expression is evaluated
-against each individual element. Against a map, the selection expression is evaluated
-against each map entry (objects of the Java type `Map.Entry`). Each map entry has its
-`key` and `value` accessible as properties for use in the selection.
+`java.util.Map`. For a list or array, the selection criteria is evaluated against each
+individual element. Against a map, the selection criteria is evaluated against each map
+entry (objects of the Java type `Map.Entry`). Each map entry has its `key` and `value`
+accessible as properties for use in the selection.

-Given a `Map` stored in a variable named `#map`, the following expression returns a new
-map that consists of those elements of the original map where the entry's value is less
-than 27:
+The following expression returns a new map that consists of those elements of the
+original map where the entry's value is less than 27:

 [tabs]
 ======
@@ -43,21 +42,21 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	Map newMap = parser.parseExpression("#map.?[value < 27]").getValue(Map.class);
+	Map newMap = parser.parseExpression("map.?[value<27]").getValue();
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	val newMap = parser.parseExpression("#map.?[value < 27]").getValue() as Map
+	val newMap = parser.parseExpression("map.?[value<27]").getValue()
 ----
 ======

 In addition to returning all the selected elements, you can retrieve only the first or
-the last element. To obtain the first element matching the selection expression, the
-syntax is `.^[selectionExpression]`. To obtain the last element matching the selection
-expression, the syntax is `.$[selectionExpression]`.
+the last element. To obtain the first element matching the selection, the syntax is
+`.^[selectionExpression]`. To obtain the last matching selection, the syntax is
+`.$[selectionExpression]`.



@@ -268,8 +268,6 @@ Java::
 	@Service
 	public class MyService {

-		private final ConversionService conversionService;
-
 		public MyService(ConversionService conversionService) {
 			this.conversionService = conversionService;
 		}
@@ -268,8 +268,8 @@ The actual JPA provider bootstrapping is handed off to the specified executor an
 running in parallel, to the application bootstrap thread. The exposed `EntityManagerFactory`
 proxy can be injected into other application components and is even able to respond to
 `EntityManagerFactoryInfo` configuration inspection. However, once the actual JPA provider
-is being accessed by other components (for example, calling `createEntityManager`), those
-calls block until the background bootstrapping has completed. In particular, when you use
+is being accessed by other components (for example, calling `createEntityManager`), those calls
+block until the background bootstrapping has completed. In particular, when you use
 Spring Data JPA, make sure to set up deferred bootstrapping for its repositories as well.


@@ -284,9 +284,9 @@ to a newly created `EntityManager` per operation, in effect making its usage thr

 It is possible to write code against the plain JPA without any Spring dependencies, by
 using an injected `EntityManagerFactory` or `EntityManager`. Spring can understand the
-`@PersistenceUnit` and `@PersistenceContext` annotations both at the field and the method
-level if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example
-shows a plain JPA DAO implementation that uses the `@PersistenceUnit` annotation:
+`@PersistenceUnit` and `@PersistenceContext` annotations both at the field and the method level
+if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example shows a plain
+JPA DAO implementation that uses the `@PersistenceUnit` annotation:

 [tabs]
 ======
@@ -76,7 +76,7 @@ Kotlin::

 Used at the class level as above, the annotation indicates a default for all methods of
 the declaring class (as well as its subclasses). Alternatively, each method can be
-annotated individually. See xref:data-access/transaction/declarative/annotations.adoc#transaction-declarative-annotations-method-visibility[method visibility] for
+annotated individually. See xref:data-access/transaction/declarative/annotations.adoc#transaction-declarative-annotations-method-visibility[null] for
 further details on which methods Spring considers transactional. Note that a class-level
 annotation does not apply to ancestor classes up the class hierarchy; in such a scenario,
 inherited methods need to be locally redeclared in order to participate in a
@@ -229,27 +229,30 @@ in the testing chapter for examples.
 ====

 You can apply the `@Transactional` annotation to an interface definition, a method
-on an interface, a class definition, or a method on a class. However, the mere presence
-of the `@Transactional` annotation is not enough to activate the transactional behavior.
-The `@Transactional` annotation is merely metadata that can be consumed by corresponding
-runtime infrastructure which uses that metadata to configure the appropriate beans with
-transactional behavior. In the preceding example, the `<tx:annotation-driven/>` element
-switches on actual transaction management at runtime.
+on an interface, a class definition, or a method on a class. However, the
+mere presence of the `@Transactional` annotation is not enough to activate the
+transactional behavior. The `@Transactional` annotation is merely metadata that can
+be consumed by some runtime infrastructure that is `@Transactional`-aware and that
+can use the metadata to configure the appropriate beans with transactional behavior.
+In the preceding example, the `<tx:annotation-driven/>` element switches on the
+transactional behavior.

-TIP: The Spring team recommends that you annotate methods of concrete classes with the
-`@Transactional` annotation, rather than relying on annotated methods in interfaces,
-even if the latter does work for interface-based and target-class proxies as of 5.0.
-Since Java annotations are not inherited from interfaces, interface-declared annotations
-are still not recognized by the weaving infrastructure when using AspectJ mode, so the
-aspect does not get applied. As a consequence, your transaction annotations may be
-silently ignored: Your code might appear to "work" until you test a rollback scenario.
+TIP: The Spring team recommends that you annotate only concrete classes (and methods of
+concrete classes) with the `@Transactional` annotation, as opposed to annotating interfaces.
+You certainly can place the `@Transactional` annotation on an interface (or an interface
+method), but this works only as you would expect it to if you use interface-based
+proxies. The fact that Java annotations are not inherited from interfaces means that,
+if you use class-based proxies (`proxy-target-class="true"`) or the weaving-based
+aspect (`mode="aspectj"`), the transaction settings are not recognized by the proxying
+and weaving infrastructure, and the object is not wrapped in a transactional proxy.

 NOTE: In proxy mode (which is the default), only external method calls coming in through
 the proxy are intercepted. This means that self-invocation (in effect, a method within
 the target object calling another method of the target object) does not lead to an actual
 transaction at runtime even if the invoked method is marked with `@Transactional`. Also,
 the proxy must be fully initialized to provide the expected behavior, so you should not
-rely on this feature in your initialization code -- e.g. in a `@PostConstruct` method.
+rely on this feature in your initialization code -- for example, in a `@PostConstruct`
+method.

 Consider using AspectJ mode (see the `mode` attribute in the following table) if you
 expect self-invocations to be wrapped with transactions as well. In this case, there is
@@ -274,20 +277,20 @@ is modified) to support `@Transactional` runtime behavior on any kind of method.
  framework (following proxy semantics, as discussed earlier, applying to method calls
  coming in through the proxy only). The alternative mode (`aspectj`) instead weaves the
  affected classes with Spring's AspectJ transaction aspect, modifying the target class
-  byte code to apply to any kind of method call. AspectJ weaving requires `spring-aspects.jar`
-  in the classpath as well as having load-time weaving (or compile-time weaving) enabled.
-  (See xref:core/aop/using-aspectj.adoc#aop-aj-ltw-spring[Spring configuration] for details
-  on how to set up load-time weaving.)
+  byte code to apply to any kind of method call. AspectJ weaving requires
+  `spring-aspects.jar` in the classpath as well as having load-time weaving (or compile-time
+  weaving) enabled. (See xref:core/aop/using-aspectj.adoc#aop-aj-ltw-spring[Spring configuration]
+  for details on how to set up load-time weaving.)

 | `proxy-target-class`
 | `proxyTargetClass`
 | `false`
 | Applies to `proxy` mode only. Controls what type of transactional proxies are created
-  for classes annotated with the `@Transactional` annotation. If the `proxy-target-class`
-  attribute is set to `true`, class-based proxies are created. If `proxy-target-class` is
-  `false` or if the attribute is omitted, then standard JDK interface-based proxies are
-  created. (See xref:core/aop/proxying.adoc[Proxying Mechanisms] for a detailed examination
-  of the different proxy types.)
+  for classes annotated with the `@Transactional` annotation. If the
+  `proxy-target-class` attribute is set to `true`, class-based proxies are created.
+  If `proxy-target-class` is `false` or if the attribute is omitted, then standard JDK
+  interface-based proxies are created. (See xref:core/aop/proxying.adoc[Proxying Mechanisms]
+  for a detailed examination of the different proxy types.)

 | `order`
 | `order`
@@ -23,7 +23,7 @@ As of Spring Framework 5.2, the default configuration also provides support for
 Vavr's `Try` method to trigger transaction rollbacks when it returns a 'Failure'.
 This allows you to handle functional-style errors using Try and have the transaction
 automatically rolled back in case of a failure. For more information on Vavr's Try,
-refer to the https://docs.vavr.io/#_try[official Vavr documentation].
+refer to the [official Vavr documentation](https://www.vavr.io/vavr-docs/#_try).

 Here's an example of how to use Vavr's Try with a transactional method:
 [tabs]
@@ -85,7 +85,7 @@ email when someone places an order:

 			// Call the collaborators to persist the order...

-			// Create a thread-safe "copy" of the template message and customize it
+			// Create a thread safe "copy" of the template message and customize it
 			SimpleMailMessage msg = new SimpleMailMessage(this.templateMessage);
 			msg.setTo(order.getCustomer().getEmailAddress());
 			msg.setText(
@@ -108,7 +108,7 @@ By default, the following `KeyValues` are created:
 |===
 |Name | Description
 |`exception` _(required)_|Name of the exception thrown during the exchange, or `KeyValue#NONE_VALUE`} if no exception happened.
-|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
+|`method` _(required)_|Name of HTTP request method or `"none"` if the request was not received properly.
 |`outcome` _(required)_|Outcome of the HTTP server exchange.
 |`status` _(required)_|HTTP response raw status code, or `"UNKNOWN"` if no response was created.
 |`uri` _(required)_|URI pattern for the matching handler if available, falling back to `REDIRECTION` for 3xx responses, `NOT_FOUND` for 404 responses, `root` for requests with no path info, and `UNKNOWN` for all other requests.
@@ -141,7 +141,7 @@ By default, the following `KeyValues` are created:
 |===
 |Name | Description
 |`exception` _(required)_|Name of the exception thrown during the exchange, or `"none"` if no exception happened.
-|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
+|`method` _(required)_|Name of HTTP request method or `"none"` if the request was not received properly.
 |`outcome` _(required)_|Outcome of the HTTP server exchange.
 |`status` _(required)_|HTTP response raw status code, or `"UNKNOWN"` if no response was created.
 |`uri` _(required)_|URI pattern for the matching handler if available, falling back to `REDIRECTION` for 3xx responses, `NOT_FOUND` for 404 responses, `root` for requests with no path info, and `UNKNOWN` for all other requests.
@@ -174,7 +174,7 @@ Instrumentation uses the `org.springframework.http.client.observation.ClientRequ
 [cols="a,a"]
 |===
 |Name | Description
-|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
+|`method` _(required)_|Name of HTTP request method or `"none"` if the request could not be created.
 |`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. Only the path part of the URI is considered.
 |`client.name` _(required)_|Client name derived from the request URI host.
 |`status` _(required)_|HTTP response raw status code, or `"IO_ERROR"` in case of `IOException`, or `"CLIENT_ERROR"` if no response was received.
@@ -203,7 +203,7 @@ Instrumentation uses the `org.springframework.web.reactive.function.client.Clien
 [cols="a,a"]
 |===
 |Name | Description
-|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
+|`method` _(required)_|Name of HTTP request method or `"none"` if the request could not be created.
 |`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. Only the path part of the URI is considered.
 |`client.name` _(required)_|Client name derived from the request URI host.
 |`status` _(required)_|HTTP response raw status code, or `"IO_ERROR"` in case of `IOException`, or `"CLIENT_ERROR"` if no response was received.
@@ -97,7 +97,11 @@ preparation and response extraction through callback interfaces.

 The default constructor uses `java.net.HttpURLConnection` to perform requests. You can
 switch to a different HTTP library with an implementation of `ClientHttpRequestFactory`.
-Currently, there is also built-in support for Apache HttpComponents and OkHttp.
+There is built-in support for the following:
+
+* Apache HttpComponents
+* Netty
+* OkHttp

 For example, to switch to Apache HttpComponents, you can use the following:

@@ -236,42 +236,6 @@ be matched, not only the `GET` method.



-[[declaration-site-variance]]
-== Declaration-site variance
-
-Dealing with generic types in Spring applications written in Kotlin may require, for some use cases, to understand
-Kotlin https://kotlinlang.org/docs/generics.html#declaration-site-variance[declaration-site variance]
-which allows to define the variance when declaring a type, which is not possible in Java which supports only use-site
-variance.
-
-For example, declaring `List<Foo>` in Kotlin is conceptually equivalent to `java.util.List<? extends Foo>` because
-`kotlin.collections.List` is declared as
-https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/[`interface List<out E> : kotlin.collections.Collection<E>`].
-
-This needs to be taken in account by using the `out` Kotlin keyword on generic types when using Java classes,
-for example when writing a `org.springframework.core.convert.converter.Converter` from a Kotlin type to a Java type.
-
-[source,kotlin,indent=0]
----
-class ListOfFooConverter : Converter<List<Foo>, CustomJavaList<out Foo>> {
-    // ...
-}
----
-
-When converting any kind of objects, star projection with `*` can be used instead of `out Any`.
-[source,kotlin,indent=0]
----
-class ListOfAnyConverter : Converter<List<*>, CustomJavaList<*>> {
-    // ...
-}
----
-
-NOTE: Spring Framework does not leverage yet declaration-site variance type information for injecting beans,
-subscribe to https://github.com/spring-projects/spring-framework/issues/22313[spring-framework#22313] to track related
-progresses.
-
-
-
 [[testing]]
 == Testing

@@ -152,7 +152,7 @@ Kotlin::
 		@Autowired
 		lateinit var accountService: AccountService

-		lateinit var mockMvc: MockMvc
+		lateinit mockMvc: MockMvc

 		@BeforeEach
 		fun setup(wac: WebApplicationContext) {
@@ -1,7 +1,7 @@
 [[spring-mvc-test-vs-end-to-end-integration-tests]]
 = MockMvc vs End-to-End Tests

-MockMvc is built on Servlet API mock implementations from the
+MockMVc is built on Servlet API mock implementations from the
 `spring-test` module and does not rely on a running container. Therefore, there are
 some differences when compared to full end-to-end integration tests with an actual
 client and a live server running.
@@ -1,15 +1,38 @@
 [[spring-mvc-test-vs-streaming-response]]
 = Streaming Responses

-You can use `WebTestClient` to test xref:testing/webtestclient.adoc#webtestclient-stream[streaming responses]
-such as Server-Sent Events. However, `MockMvcWebTestClient` doesn't support infinite
-streams because there is no way to cancel the server stream from the client side.
-To test infinite streams, you'll need to
-xref:testing/webtestclient.adoc#webtestclient-server-config[bind to] a running server,
-or when using Spring Boot,
-{docs-spring-boot}/spring-boot-features.html#boot-features-testing-spring-boot-applications-testing-with-running-server[test with a running server].
+The best way to test streaming responses such as Server-Sent Events is through the
+<<WebTestClient>> which can be used as a test client to connect to a `MockMvc` instance
+to perform tests on Spring MVC controllers without a running server. For example:
+
+[tabs]
+======
+Java::
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	WebTestClient client = MockMvcWebTestClient.bindToController(new SseController()).build();
+
+	FluxExchangeResult<Person> exchangeResult = client.get()
+			.uri("/persons")
+			.exchange()
+			.expectStatus().isOk()
+			.expectHeader().contentType("text/event-stream")
+			.returnResult(Person.class);
+
+	// Use StepVerifier from Project Reactor to test the streaming response
+
+	StepVerifier.create(exchangeResult.getResponseBody())
+			.expectNext(new Person("N0"), new Person("N1"), new Person("N2"))
+			.expectNextCount(4)
+			.consumeNextWith(person -> assertThat(person.getName()).endsWith("7"))
+			.thenCancel()
+			.verify();
+----
+======
+
+`WebTestClient` can also connect to a live server and perform full end-to-end integration
+tests. This is also supported in Spring Boot where you can
+{docs-spring-boot}/html/spring-boot-features.html#boot-features-testing-spring-boot-applications-testing-with-running-server[test a running server].

-`MockMvcWebTestClient` does support asynchronous responses, and even streaming responses.
-The limitation is that it can't influence the server to stop, and therefore the server
-must finish writing the response on its own.

@@ -166,7 +166,4 @@ By default, any argument that is not a simple value type (as determined by
 and is not resolved by any other argument resolver is treated as if it were annotated
 with `@ModelAttribute`.

-WARNING: When compiling to a native image with GraalVM, the implicit `@ModelAttribute`
-support described above does not allow proper ahead-of-time inference of related data
-binding reflection hints. As a consequence, it is recommended to explicitly annotate
-method parameters with `@ModelAttribute` for use in a GraalVM native image.
+
@@ -70,9 +70,8 @@ it does the same, but it also compares the computed value against the `If-None-M
 request header and, if the two are equal, returns a 304 (NOT_MODIFIED).

 This strategy saves network bandwidth but not CPU, as the full response must be computed for each request.
-State-changing HTTP methods and other HTTP conditional request headers such as `If-Match` and
-`If-Unmodified-Since` are outside the scope of this filter. Other strategies at the controller level
-can avoid the computation and have a broader support for HTTP conditional requests.
+State-changing HTTP methods and other HTTP conditional request headers such as `If-Match` and `If-Unmodified-Since` are outside the scope of this filter.
+Other strategies at the controller level can avoid the computation and have a broader support for HTTP conditional requests.
 See xref:web/webmvc/mvc-caching.adoc[HTTP Caching].

 This filter has a `writeWeakETag` parameter that configures the filter to write weak ETags
@@ -52,10 +52,14 @@ The following example shows how to achieve the same configuration in XML:
 	</mvc:interceptors>
 ----

-WARNING: Interceptors are not ideally suited as a security layer due to the potential for
-a mismatch with annotated controller path matching. Generally, we recommend using Spring
-Security, or alternatively a similar approach integrated with the Servlet filter chain,
-and applied as early as possible.
+NOTE: Interceptors are not ideally suited as a security layer due to the potential
+for a mismatch with annotated controller path matching, which can also match trailing
+slashes and path extensions transparently, along with other path matching options. Many
+of these options have been deprecated but the potential for a mismatch remains.
+Generally, we recommend using Spring Security which includes a dedicated
+https://docs.spring.io/spring-security/reference/servlet/integrations/mvc.html#mvc-requestmatcher[MvcRequestMatcher]
+to align with Spring MVC path matching and also has a security firewall that blocks many
+unwanted characters in URL paths.

 NOTE: The XML config declares interceptors as `MappedInterceptor` beans, and those are in
 turn detected by any `HandlerMapping` bean, including those from other frameworks.
@@ -216,7 +216,4 @@ By default, any argument that is not a simple value type (as determined by
 and is not resolved by any other argument resolver is treated as if it were annotated
 with `@ModelAttribute`.

-WARNING: When compiling to a native image with GraalVM, the implicit `@ModelAttribute`
-support described above does not allow proper ahead-of-time inference of related data
-binding reflection hints. As a consequence, it is recommended to explicitly annotate
-method parameters with `@ModelAttribute` for use in a GraalVM native image.
+
@@ -220,7 +220,7 @@ one of the following depending on whether use of parsed `PathPattern` is enabled
 * {api-spring-framework}/web/util/pattern/PathPattern.html#SPECIFICITY_COMPARATOR[`PathPattern.SPECIFICITY_COMPARATOR`]
 * {api-spring-framework}/util/AntPathMatcher.html#getPatternComparator-java.lang.String-[`AntPathMatcher.getPatternComparator(String path)`]

-Both help to sort patterns with more specific ones on top. A pattern is more specific if
+Both help to sort patterns with more specific ones on top. A pattern is less specific if
 it has a lower count of URI variables (counted as 1), single wildcards (counted as 1),
 and double wildcards (counted as 2). Given an equal score, the longer pattern is chosen.
 Given the same score and length, the pattern with more URI variables than wildcards is
@@ -1,29 +1,34 @@
 [[mvc-handlermapping-interceptor]]
 = Interception

-All `HandlerMapping` implementations support handler interception which is useful when
-you want to apply functionality across requests. A `HandlerInterceptor` can implement the
-following:
+All `HandlerMapping` implementations support handler interceptors that are useful when
+you want to apply specific functionality to certain requests -- for example, checking for
+a principal. Interceptors must implement `HandlerInterceptor` from the
+`org.springframework.web.servlet` package with three methods that should provide enough
+flexibility to do all kinds of pre-processing and post-processing:

-* `preHandle(..)` -- callback before the actual handler is run that returns a boolean.
-If the method returns `true`, execution continues; if it returns `false`, the rest of the
-execution chain is bypassed and the handler is not called.
-* `postHandle(..)` -- callback after the handler is run.
-* `afterCompletion(..)` -- callback after the complete request has finished.
+* `preHandle(..)`: Before the actual handler is run
+* `postHandle(..)`: After the handler is run
+* `afterCompletion(..)`: After the complete request has finished

-NOTE: For `@ResponseBody` and `ResponseEntity` controller methods, the response is written
-and committed within the `HandlerAdapter`, before `postHandle` is called. That means it is
-too late to change the response, such as to add an extra header. You can implement
-`ResponseBodyAdvice` and declare it as an
-xref:web/webmvc/mvc-controller/ann-advice.adoc[Controller Advice] bean or configure it
-directly on `RequestMappingHandlerAdapter`.
+The `preHandle(..)` method returns a boolean value. You can use this method to break or
+continue the processing of the execution chain. When this method returns `true`, the
+handler execution chain continues. When it returns false, the `DispatcherServlet`
+assumes the interceptor itself has taken care of requests (and, for example, rendered an
+appropriate view) and does not continue executing the other interceptors and the actual
+handler in the execution chain.

 See xref:web/webmvc/mvc-config/interceptors.adoc[Interceptors] in the section on MVC configuration for examples of how to
 configure interceptors. You can also register them directly by using setters on individual
 `HandlerMapping` implementations.

-WARNING: Interceptors are not ideally suited as a security layer due to the potential for
-a mismatch with annotated controller path matching. Generally, we recommend using Spring
-Security, or alternatively a similar approach integrated with the Servlet filter chain,
-and applied as early as possible.
+`postHandle` method is less useful with `@ResponseBody` and `ResponseEntity` methods for
+which the response is written and committed within the `HandlerAdapter` and before
+`postHandle`. That means it is too late to make any changes to the response, such as adding
+an extra header. For such scenarios, you can implement `ResponseBodyAdvice` and either
+declare it as an xref:web/webmvc/mvc-controller/ann-advice.adoc[Controller Advice] bean or configure it directly on
+`RequestMappingHandlerAdapter`.
+
+
+

@@ -229,27 +229,34 @@ Java initialization API. The following example shows how to do so:


 [[websocket-server-runtime-configuration]]
-== Configuring the Server
+== Server Configuration
 [.small]#xref:web/webflux-websocket.adoc#webflux-websocket-server-config[See equivalent in the Reactive stack]#

-You can configure of the underlying WebSocket server such as input message buffer size,
-idle timeout, and more.
+Each underlying WebSocket engine exposes configuration properties that control
+runtime characteristics, such as the size of message buffer sizes, idle timeout,
+and others.

-For Jakarta WebSocket servers, you can add a `ServletServerContainerFactoryBean` to your
-Java configuration. For example:
+For Tomcat, WildFly, and GlassFish, you can add a `ServletServerContainerFactoryBean` to your
+WebSocket Java config, as the following example shows:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-     @Bean
-     public ServletServerContainerFactoryBean createWebSocketContainer() {
-         ServletServerContainerFactoryBean container = new ServletServerContainerFactoryBean();
-         container.setMaxTextMessageBufferSize(8192);
-         container.setMaxBinaryMessageBufferSize(8192);
-         return container;
-     }
+	@Configuration
+	@EnableWebSocket
+	public class WebSocketConfig implements WebSocketConfigurer {
+
+		@Bean
+		public ServletServerContainerFactoryBean createWebSocketContainer() {
+			ServletServerContainerFactoryBean container = new ServletServerContainerFactoryBean();
+			container.setMaxTextMessageBufferSize(8192);
+			container.setMaxBinaryMessageBufferSize(8192);
+			return container;
+		}
+
+	}
 ----

-Or to your XML configuration:
+The following example shows the XML configuration equivalent of the preceding example:

 [source,xml,indent=0,subs="verbatim,quotes,attributes"]
 ----
@@ -270,11 +277,12 @@ Or to your XML configuration:
 	</beans>
 ----

-NOTE: For client Jakarta WebSocket configuration, use
-ContainerProvider.getWebSocketContainer() in Java configuration, or
-`WebSocketContainerFactoryBean` in XML.
+NOTE: For client-side WebSocket configuration, you should use `WebSocketContainerFactoryBean`
+(XML) or `ContainerProvider.getWebSocketContainer()` (Java configuration).

-For Jetty, you can supply a `Consumer` callback to configure the WebSocket server:
+For Jetty, you need to supply a pre-configured Jetty `WebSocketServerFactory` and plug
+that into Spring's `DefaultHandshakeHandler` through your WebSocket Java config.
+The following example shows how to do so:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -290,9 +298,11 @@ For Jetty, you can supply a `Consumer` callback to configure the WebSocket serve

 		@Bean
 		public DefaultHandshakeHandler handshakeHandler() {
+
 			WebSocketPolicy policy = new WebSocketPolicy(WebSocketBehavior.SERVER);
 			policy.setInputBufferSize(8192);
 			policy.setIdleTimeout(600000);
+
 			return new DefaultHandshakeHandler(
 					new JettyRequestUpgradeStrategy(new WebSocketServerFactory(policy)));
 		}
@@ -339,10 +349,6 @@ The following example shows the XML configuration equivalent of the preceding ex
 	</beans>
 ----

-TIP: When using STOMP over WebSocket, you will also need to configure
-xref:web/websocket/stomp/server-config.adoc[STOMP WebSocket transport]
-properties.
-


 [[websocket-server-allowed-origins]]
@@ -103,9 +103,9 @@ You can also use the WebSocket transport configuration shown earlier to configur
 maximum allowed size for incoming STOMP messages. In theory, a WebSocket
 message can be almost unlimited in size. In practice, WebSocket servers impose
 limits -- for example, 8K on Tomcat and 64K on Jetty. For this reason, STOMP clients
-such as https://github.com/stomp-js/stompjs[`stomp-js/stompjs`] and others split larger
-STOMP messages at 16K boundaries and send them as multiple WebSocket messages,
-which requires the server to buffer and re-assemble.
+(such as the JavaScript https://github.com/JSteunou/webstomp-client[webstomp-client]
+and others) split larger STOMP messages at 16K boundaries and send them as multiple
+WebSocket  messages, which requires the server to buffer and re-assemble.

 Spring's STOMP-over-WebSocket support does this ,so applications can configure the
 maximum size for STOMP messages irrespective of WebSocket server-specific message
@@ -1,14 +1,9 @@
 [[websocket-stomp-server-config]]
-= WebSocket Transport
+= WebSocket Server

-This section explains how to configure the underlying WebSocket server transport.
-
-For Jakarta WebSocket servers, add a `ServletServerContainerFactoryBean` to your
-configuration. For examples, see
-xref:web/websocket/server.adoc#websocket-server-runtime-configuration[Configuring the Server]
-under the WebSocket section.
-
-For Jetty WebSocket servers, customize the `JettyRequestUpgradeStrategy` as follows:
+To configure the underlying WebSocket server, the information in
+xref:web/websocket/server.adoc#websocket-server-runtime-configuration[Server Configuration] applies. For Jetty, however you need to set
+the `HandshakeHandler` and `WebSocketPolicy` through the `StompEndpointRegistry`:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -34,20 +29,5 @@ For Jetty WebSocket servers, customize the `JettyRequestUpgradeStrategy` as foll
 	}
 ----

-In addition to WebSocket server properties, there are also STOMP WebSocket transport properties
-to customize as follows:

-[source,java,indent=0,subs="verbatim,quotes"]
----
-	@Configuration
-	@EnableWebSocketMessageBroker
-	public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

-		@Override
-		public void configureWebSocketTransport(WebSocketTransportRegistration registry) {
-			registry.setMessageSizeLimit(4 * 8192);
-			registry.setTimeToFirstMessage(30000);
-		}
-
-	}
----
@@ -8,30 +8,30 @@ javaPlatform {

 dependencies {
 	api(platform("com.fasterxml.jackson:jackson-bom:2.14.3"))
-	api(platform("io.micrometer:micrometer-bom:1.10.13"))
-	api(platform("io.netty:netty-bom:4.1.109.Final"))
+	api(platform("io.micrometer:micrometer-bom:1.10.11"))
+	api(platform("io.netty:netty-bom:4.1.97.Final"))
 	api(platform("io.netty:netty5-bom:5.0.0.Alpha5"))
-	api(platform("io.projectreactor:reactor-bom:2022.0.19"))
+	api(platform("io.projectreactor:reactor-bom:2022.0.11"))
 	api(platform("io.rsocket:rsocket-bom:1.1.3"))
-	api(platform("org.apache.groovy:groovy-bom:4.0.21"))
-	api(platform("org.apache.logging.log4j:log4j-bom:2.21.1"))
-	api(platform("org.eclipse.jetty:jetty-bom:11.0.20"))
+	api(platform("org.apache.groovy:groovy-bom:4.0.14"))
+	api(platform("org.apache.logging.log4j:log4j-bom:2.20.0"))
+	api(platform("org.eclipse.jetty:jetty-bom:11.0.16"))
 	api(platform("org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.6.4"))
 	api(platform("org.jetbrains.kotlinx:kotlinx-serialization-bom:1.4.0"))
 	api(platform("org.junit:junit-bom:5.9.3"))
-	api(platform("org.mockito:mockito-bom:5.12.0"))
+	api(platform("org.mockito:mockito-bom:5.5.0"))

 	constraints {
 		api("com.fasterxml:aalto-xml:1.3.2")
 		api("com.fasterxml.woodstox:woodstox-core:6.5.1")
 		api("com.github.ben-manes.caffeine:caffeine:3.1.8")
-		api("com.github.librepdf:openpdf:1.3.43")
+		api("com.github.librepdf:openpdf:1.3.30")
 		api("com.google.code.findbugs:findbugs:3.0.1")
 		api("com.google.code.findbugs:jsr305:3.0.2")
 		api("com.google.code.gson:gson:2.10.1")
 		api("com.google.protobuf:protobuf-java-util:3.23.2")
 		api("com.googlecode.protobuf-java-format:protobuf-java-format:1.4")
-		api("com.h2database:h2:2.2.224")
+		api("com.h2database:h2:2.2.220")
 		api("com.jayway.jsonpath:json-path:2.8.0")
 		api("com.rometools:rome:1.19.0")
 		api("com.squareup.okhttp3:mockwebserver:3.14.9")
@@ -43,20 +43,20 @@ dependencies {
 		api("com.sun.xml.bind:jaxb-xjc:3.0.2")
 		api("com.thoughtworks.qdox:qdox:2.0.3")
 		api("com.thoughtworks.xstream:xstream:1.4.20")
-		api("commons-io:commons-io:2.15.0")
+		api("commons-io:commons-io:2.11.0")
 		api("de.bechte.junit:junit-hierarchicalcontextrunner:4.12.2")
-		api("io.micrometer:context-propagation:1.0.6")
+		api("io.micrometer:context-propagation:1.0.5")
 		api("io.mockk:mockk:1.13.4")
 		api("io.projectreactor.netty:reactor-netty5-http:2.0.0-M3")
 		api("io.projectreactor.tools:blockhound:1.0.8.RELEASE")
 		api("io.r2dbc:r2dbc-h2:1.0.0.RELEASE")
 		api("io.r2dbc:r2dbc-spi-test:1.0.0.RELEASE")
 		api("io.r2dbc:r2dbc-spi:1.0.0.RELEASE")
-		api("io.reactivex.rxjava3:rxjava:3.1.8")
-		api("io.smallrye.reactive:mutiny:1.10.0")
-		api("io.undertow:undertow-core:2.3.13.Final")
-		api("io.undertow:undertow-servlet:2.3.13.Final")
-		api("io.undertow:undertow-websockets-jsr:2.3.13.Final")
+		api("io.reactivex.rxjava3:rxjava:3.1.6")
+		api("io.smallrye.reactive:mutiny:1.9.0")
+		api("io.undertow:undertow-core:2.3.8.Final")
+		api("io.undertow:undertow-servlet:2.3.8.Final")
+		api("io.undertow:undertow-websockets-jsr:2.3.8.Final")
 		api("io.vavr:vavr:0.10.4")
 		api("jakarta.activation:jakarta.activation-api:2.0.1")
 		api("jakarta.annotation:jakarta.annotation-api:2.0.0")
@@ -89,44 +89,46 @@ dependencies {
 		api("net.sf.jopt-simple:jopt-simple:5.0.4")
 		api("net.sourceforge.htmlunit:htmlunit:2.70.0")
 		api("org.apache-extras.beanshell:bsh:2.0b6")
-		api("org.apache.activemq:activemq-broker:5.17.6")
-		api("org.apache.activemq:activemq-kahadb-store:5.17.6")
-		api("org.apache.activemq:activemq-stomp:5.17.6")
+		api("org.apache.activemq:activemq-broker:5.17.4")
+		api("org.apache.activemq:activemq-kahadb-store:5.17.4")
+		api("org.apache.activemq:activemq-stomp:5.17.4")
 		api("org.apache.commons:commons-pool2:2.9.0")
 		api("org.apache.derby:derby:10.16.1.1")
 		api("org.apache.derby:derbyclient:10.16.1.1")
 		api("org.apache.derby:derbytools:10.16.1.1")
-		api("org.apache.httpcomponents.client5:httpclient5:5.2.3")
-		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.2.4")
-		api("org.apache.poi:poi-ooxml:5.2.5")
-		api("org.apache.tomcat.embed:tomcat-embed-core:10.1.15")
-		api("org.apache.tomcat.embed:tomcat-embed-websocket:10.1.15")
-		api("org.apache.tomcat:tomcat-util:10.1.15")
-		api("org.apache.tomcat:tomcat-websocket:10.1.15")
-		api("org.aspectj:aspectjrt:1.9.22.1")
-		api("org.aspectj:aspectjtools:1.9.22.1")
-		api("org.aspectj:aspectjweaver:1.9.22.1")
+		api("org.apache.httpcomponents.client5:httpclient5:5.2.1")
+		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.2.2")
+		api("org.apache.poi:poi-ooxml:5.2.3")
+		api("org.apache.tomcat.embed:tomcat-embed-core:10.1.13")
+		api("org.apache.tomcat.embed:tomcat-embed-websocket:10.1.13")
+		api("org.apache.tomcat:tomcat-util:10.1.13")
+		api("org.apache.tomcat:tomcat-websocket:10.1.13")
+		api("org.aspectj:aspectjrt:1.9.20")
+		api("org.aspectj:aspectjtools:1.9.20")
+		api("org.aspectj:aspectjweaver:1.9.20")
 		api("org.assertj:assertj-core:3.24.2")
 		api("org.awaitility:awaitility:4.2.0")
 		api("org.bouncycastle:bcpkix-jdk18on:1.72")
 		api("org.codehaus.jettison:jettison:1.5.4")
 		api("org.dom4j:dom4j:2.1.4")
-		api("org.eclipse.jetty:jetty-reactive-httpclient:3.0.12")
-		api("org.eclipse.persistence:org.eclipse.persistence.jpa:3.0.4")
+		api("org.eclipse.jetty:jetty-reactive-httpclient:3.0.8")
+		api("org.eclipse.persistence:org.eclipse.persistence.jpa:3.0.3")
 		api("org.eclipse:yasson:2.0.4")
 		api("org.ehcache:ehcache:3.10.8")
 		api("org.ehcache:jcache:1.0.1")
 		api("org.freemarker:freemarker:2.3.32")
+		// Substitute for "javax.management:jmxremote_optional:1.0.1_04" which
+		// is not available on Maven Central
 		api("org.glassfish.external:opendmk_jmxremote_optional_jar:1.0-b01-ea")
-		api("org.glassfish:jakarta.el:4.0.2")
 		api("org.glassfish.tyrus:tyrus-container-servlet:2.1.3")
+		api("org.glassfish:jakarta.el:4.0.2")
 		api("org.graalvm.sdk:graal-sdk:22.3.1")
 		api("org.hamcrest:hamcrest:2.2")
 		api("org.hibernate:hibernate-core-jakarta:5.6.15.Final")
 		api("org.hibernate:hibernate-validator:7.0.5.Final")
 		api("org.hsqldb:hsqldb:2.7.2")
 		api("org.javamoney:moneta:1.4.2")
-		api("org.jruby:jruby:9.4.6.0")
+		api("org.jruby:jruby:9.4.3.0")
 		api("org.junit.support:testng-engine:1.0.4")
 		api("org.mozilla:rhino:1.7.14")
 		api("org.ogce:xpp3:1.1.6")
@@ -135,10 +137,10 @@ dependencies {
 		api("org.seleniumhq.selenium:htmlunit-driver:2.70.0")
 		api("org.seleniumhq.selenium:selenium-java:3.141.59")
 		api("org.skyscreamer:jsonassert:1.5.1")
-		api("org.slf4j:slf4j-api:2.0.12")
+		api("org.slf4j:slf4j-api:2.0.7")
 		api("org.testng:testng:7.8.0")
 		api("org.webjars:underscorejs:1.8.3")
-		api("org.webjars:webjars-locator-core:0.55")
+		api("org.webjars:webjars-locator-core:0.53")
 		api("org.xmlunit:xmlunit-assertj:2.9.1")
 		api("org.xmlunit:xmlunit-matchers:2.9.1")
 		api("org.yaml:snakeyaml:1.33")
@@ -1,4 +1,4 @@
-version=6.0.20
+version=6.0.12

 org.gradle.caching=true
 org.gradle.jvmargs=-Xmx2048m
@@ -6,7 +6,6 @@ tasks.findByName("dokkaHtmlPartial")?.configure {
 			classpath.from(sourceSets["main"].runtimeClasspath)
 			externalDocumentationLink {
 				url.set(new URL("https://docs.spring.io/spring-framework/docs/current/javadoc-api/"))
-				packageListUrl.set(new URL("https://docs.spring.io/spring-framework/docs/current/javadoc-api/element-list"))
 			}
 			externalDocumentationLink {
 				url.set(new URL("https://projectreactor.io/docs/core/release/api/"))
@@ -22,7 +21,6 @@ tasks.findByName("dokkaHtmlPartial")?.configure {
 			}
 			externalDocumentationLink {
 				url.set(new URL("https://javadoc.io/doc/jakarta.servlet/jakarta.servlet-api/latest/"))
-				packageListUrl.set(new URL("https://javadoc.io/doc/jakarta.servlet/jakarta.servlet-api/latest/element-list"))
 			}
 			externalDocumentationLink {
 				url.set(new URL("https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/"))
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
@@ -145,7 +145,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
    case $MAX_FD in #(
      max*)
        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
+        # shellcheck disable=SC3045
        MAX_FD=$( ulimit -H -n ) ||
            warn "Could not query maximum file descriptor limit"
    esac
@@ -153,7 +153,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
      '' | soft) :;; #(
      *)
        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
+        # shellcheck disable=SC3045
        ulimit -n "$MAX_FD" ||
            warn "Could not set maximum file descriptor limit to $MAX_FD"
    esac
@@ -202,11 +202,11 @@ fi
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'

-# Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     and any embedded shellness will be escaped.
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#     treated as '${Hostname}' itself on the command line.
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.

 set -- \
        "-Dorg.gradle.appname=$APP_BASE_NAME" \
@@ -43,11 +43,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute

-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.

 goto fail

@@ -57,11 +57,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe

 if exist "%JAVA_EXE%" goto execute

-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.

 goto fail

@@ -7,8 +7,8 @@ pluginManagement {
 }

 plugins {
-	id "com.gradle.develocity" version "3.17.2"
-	id "io.spring.ge.conventions" version "0.0.17"
+	id "com.gradle.enterprise" version "3.12.6"
+	id "io.spring.ge.conventions" version "0.0.13"
 }

 include "spring-aop"
@@ -45,10 +45,9 @@ rootProject.children.each {project ->
 }

 settings.gradle.projectsLoaded {
-	develocity {
+	gradleEnterprise {
 		buildScan {
-			File buildDir = settings.gradle.rootProject
-					.getLayout().getBuildDirectory().getAsFile().get()
+			File buildDir = settings.gradle.rootProject.getBuildDir()
 			buildDir.mkdirs()
 			new File(buildDir, "build-scan-uri.txt").text = "(build scan not generated)"
 			buildScanPublished { scan ->
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2019 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,23 +17,18 @@
 package org.springframework.aop;

 /**
- * Filter that restricts matching of a pointcut or introduction to a given set
- * of target classes.
+ * Filter that restricts matching of a pointcut or introduction to
+ * a given set of target classes.
 *
- * <p>Can be used as part of a {@link Pointcut} or for the entire targeting of
- * an {@link IntroductionAdvisor}.
+ * <p>Can be used as part of a {@link Pointcut} or for the entire
+ * targeting of an {@link IntroductionAdvisor}.
 *
- * <p><strong>WARNING</strong>: Concrete implementations of this interface must
- * provide proper implementations of {@link Object#equals(Object)},
- * {@link Object#hashCode()}, and {@link Object#toString()} in order to allow the
- * filter to be used in caching scenarios &mdash; for example, in proxies generated
- * by CGLIB. As of Spring Framework 6.0.13, the {@code toString()} implementation
- * must generate a unique string representation that aligns with the logic used
- * to implement {@code equals()}. See concrete implementations of this interface
- * within the framework for examples.
+ * <p>Concrete implementations of this interface typically should provide proper
+ * implementations of {@link Object#equals(Object)} and {@link Object#hashCode()}
+ * in order to allow the filter to be used in caching scenarios &mdash; for
+ * example, in proxies generated by CGLIB.
 *
 * @author Rod Johnson
- * @author Sam Brannen
 * @see Pointcut
 * @see MethodMatcher
 */
@@ -49,7 +44,7 @@ public interface ClassFilter {


 	/**
-	 * Canonical instance of a {@code ClassFilter} that matches all classes.
+	 * Canonical instance of a ClassFilter that matches all classes.
 	 */
 	ClassFilter TRUE = TrueClassFilter.INSTANCE;

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2019 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,37 +21,31 @@ import java.lang.reflect.Method;
 /**
 * Part of a {@link Pointcut}: Checks whether the target method is eligible for advice.
 *
- * <p>A {@code MethodMatcher} may be evaluated <b>statically</b> or at <b>runtime</b>
- * (dynamically). Static matching involves a method and (possibly) method attributes.
- * Dynamic matching also makes arguments for a particular call available, and any
- * effects of running previous advice applying to the joinpoint.
+ * <p>A MethodMatcher may be evaluated <b>statically</b> or at <b>runtime</b> (dynamically).
+ * Static matching involves method and (possibly) method attributes. Dynamic matching
+ * also makes arguments for a particular call available, and any effects of running
+ * previous advice applying to the joinpoint.
 *
 * <p>If an implementation returns {@code false} from its {@link #isRuntime()}
 * method, evaluation can be performed statically, and the result will be the same
 * for all invocations of this method, whatever their arguments. This means that
 * if the {@link #isRuntime()} method returns {@code false}, the 3-arg
- * {@link #matches(Method, Class, Object[])} method will never be invoked.
+ * {@link #matches(java.lang.reflect.Method, Class, Object[])} method will never be invoked.
 *
 * <p>If an implementation returns {@code true} from its 2-arg
- * {@link #matches(Method, Class)} method and its {@link #isRuntime()} method
- * returns {@code true}, the 3-arg {@link #matches(Method, Class, Object[])}
- * method will be invoked <i>immediately before each potential execution of the
- * related advice</i> to decide whether the advice should run. All previous advice,
- * such as earlier interceptors in an interceptor chain, will have run, so any
- * state changes they have produced in parameters or {@code ThreadLocal} state will
- * be available at the time of evaluation.
+ * {@link #matches(java.lang.reflect.Method, Class)} method and its {@link #isRuntime()} method
+ * returns {@code true}, the 3-arg {@link #matches(java.lang.reflect.Method, Class, Object[])}
+ * method will be invoked <i>immediately before each potential execution of the related advice</i>,
+ * to decide whether the advice should run. All previous advice, such as earlier interceptors
+ * in an interceptor chain, will have run, so any state changes they have produced in
+ * parameters or ThreadLocal state will be available at the time of evaluation.
 *
- * <p><strong>WARNING</strong>: Concrete implementations of this interface must
- * provide proper implementations of {@link Object#equals(Object)},
- * {@link Object#hashCode()}, and {@link Object#toString()} in order to allow the
- * matcher to be used in caching scenarios &mdash; for example, in proxies generated
- * by CGLIB. As of Spring Framework 6.0.13, the {@code toString()} implementation
- * must generate a unique string representation that aligns with the logic used
- * to implement {@code equals()}. See concrete implementations of this interface
- * within the framework for examples.
+ * <p>Concrete implementations of this interface typically should provide proper
+ * implementations of {@link Object#equals(Object)} and {@link Object#hashCode()}
+ * in order to allow the matcher to be used in caching scenarios &mdash; for
+ * example, in proxies generated by CGLIB.
 *
 * @author Rod Johnson
- * @author Sam Brannen
 * @since 11.11.2003
 * @see Pointcut
 * @see ClassFilter
@@ -59,10 +53,11 @@ import java.lang.reflect.Method;
 public interface MethodMatcher {

 	/**
-	 * Perform static checking to determine whether the given method matches.
-	 * <p>If this method returns {@code false} or if {@link #isRuntime()}
-	 * returns {@code false}, no runtime check (i.e. no
-	 * {@link #matches(Method, Class, Object[])} call) will be made.
+	 * Perform static checking whether the given method matches.
+	 * <p>If this returns {@code false} or if the {@link #isRuntime()}
+	 * method returns {@code false}, no runtime check (i.e. no
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} call)
+	 * will be made.
 	 * @param method the candidate method
 	 * @param targetClass the target class
 	 * @return whether this method matches statically
@@ -70,35 +65,36 @@ public interface MethodMatcher {
 	boolean matches(Method method, Class<?> targetClass);

 	/**
-	 * Is this {@code MethodMatcher} dynamic, that is, must a final check be made
-	 * via the {@link #matches(Method, Class, Object[])} method at runtime even
-	 * if {@link #matches(Method, Class)} returns {@code true}?
+	 * Is this MethodMatcher dynamic, that is, must a final call be made on the
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method at
+	 * runtime even if the 2-arg matches method returns {@code true}?
 	 * <p>Can be invoked when an AOP proxy is created, and need not be invoked
-	 * again before each method invocation.
-	 * @return whether a runtime match via {@link #matches(Method, Class, Object[])}
+	 * again before each method invocation,
+	 * @return whether a runtime match via the 3-arg
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method
 	 * is required if static matching passed
 	 */
 	boolean isRuntime();

 	/**
-	 * Check whether there is a runtime (dynamic) match for this method, which
-	 * must have matched statically.
-	 * <p>This method is invoked only if {@link #matches(Method, Class)} returns
-	 * {@code true} for the given method and target class, and if
-	 * {@link #isRuntime()} returns {@code true}.
-	 * <p>Invoked immediately before potential running of the advice, after any
+	 * Check whether there a runtime (dynamic) match for this method,
+	 * which must have matched statically.
+	 * <p>This method is invoked only if the 2-arg matches method returns
+	 * {@code true} for the given method and target class, and if the
+	 * {@link #isRuntime()} method returns {@code true}. Invoked
+	 * immediately before potential running of the advice, after any
 	 * advice earlier in the advice chain has run.
 	 * @param method the candidate method
 	 * @param targetClass the target class
 	 * @param args arguments to the method
 	 * @return whether there's a runtime match
-	 * @see #matches(Method, Class)
+	 * @see MethodMatcher#matches(Method, Class)
 	 */
 	boolean matches(Method method, Class<?> targetClass, Object... args);


 	/**
-	 * Canonical instance of a {@code MethodMatcher} that matches all methods.
+	 * Canonical instance that matches all methods.
 	 */
 	MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -169,30 +169,25 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut

 	@Override
 	public ClassFilter getClassFilter() {
-		checkExpression();
+		obtainPointcutExpression();
 		return this;
 	}

 	@Override
 	public MethodMatcher getMethodMatcher() {
-		checkExpression();
+		obtainPointcutExpression();
 		return this;
 	}


 	/**
-	 * Check whether this pointcut is ready to match.
+	 * Check whether this pointcut is ready to match,
+	 * lazily building the underlying AspectJ pointcut expression.
 	 */
-	private void checkExpression() {
+	private PointcutExpression obtainPointcutExpression() {
 		if (getExpression() == null) {
 			throw new IllegalStateException("Must set property 'expression' before attempting to match");
 		}
-	}
-
-	/**
-	 * Lazily build the underlying AspectJ pointcut expression.
-	 */
-	private PointcutExpression obtainPointcutExpression() {
 		if (this.pointcutExpression == null) {
 			this.pointcutClassLoader = determinePointcutClassLoader();
 			this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
@@ -269,9 +264,10 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut

 	@Override
 	public boolean matches(Class<?> targetClass) {
+		PointcutExpression pointcutExpression = obtainPointcutExpression();
 		try {
 			try {
-				return obtainPointcutExpression().couldMatchJoinPointsInType(targetClass);
+				return pointcutExpression.couldMatchJoinPointsInType(targetClass);
 			}
 			catch (ReflectionWorldException ex) {
 				logger.debug("PointcutExpression matching rejected target class - trying fallback expression", ex);
@@ -282,9 +278,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 				}
 			}
 		}
-		catch (IllegalArgumentException | IllegalStateException ex) {
-			throw ex;
-		}
 		catch (Throwable ex) {
 			logger.debug("PointcutExpression matching rejected target class", ex);
 		}
@@ -293,6 +286,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut

 	@Override
 	public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
+		obtainPointcutExpression();
 		ShadowMatch shadowMatch = getTargetShadowMatch(method, targetClass);

 		// Special handling for this, target, @this, @target, @annotation
@@ -330,6 +324,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut

 	@Override
 	public boolean matches(Method method, Class<?> targetClass, Object... args) {
+		obtainPointcutExpression();
 		ShadowMatch shadowMatch = getTargetShadowMatch(method, targetClass);

 		// Bind Spring AOP proxy to AspectJ "this" and Spring AOP target to AspectJ target,
@@ -338,12 +333,12 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		Object targetObject = null;
 		Object thisObject = null;
 		try {
-			MethodInvocation curr = ExposeInvocationInterceptor.currentInvocation();
-			targetObject = curr.getThis();
-			if (!(curr instanceof ProxyMethodInvocation currPmi)) {
-				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + curr);
+			MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
+			targetObject = mi.getThis();
+			if (!(mi instanceof ProxyMethodInvocation _pmi)) {
+				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
 			}
-			pmi = currPmi;
+			pmi = _pmi;
 			thisObject = pmi.getProxy();
 		}
 		catch (IllegalStateException ex) {
@@ -25,7 +25,7 @@ import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;

 /**
- * AspectJ {@link PointcutAdvisor} that adapts an {@link AbstractAspectJAdvice}
+ * AspectJPointcutAdvisor that adapts an {@link AbstractAspectJAdvice}
 * to the {@link org.springframework.aop.PointcutAdvisor} interface.
 *
 * @author Adrian Colyer
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.annotation;

 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Map;
 import java.util.StringTokenizer;
@@ -55,6 +56,8 @@ import org.springframework.lang.Nullable;
 */
 public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFactory {

+	private static final String AJC_MAGIC = "ajc$";
+
 	private static final Class<?>[] ASPECTJ_ANNOTATION_CLASSES = new Class<?>[] {
 			Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class};

@@ -65,11 +68,37 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	protected final ParameterNameDiscoverer parameterNameDiscoverer = new AspectJAnnotationParameterNameDiscoverer();


+	/**
+	 * We consider something to be an AspectJ aspect suitable for use by the Spring AOP system
+	 * if it has the @Aspect annotation, and was not compiled by ajc. The reason for this latter test
+	 * is that aspects written in the code-style (AspectJ language) also have the annotation present
+	 * when compiled by ajc with the -1.5 flag, yet they cannot be consumed by Spring AOP.
+	 */
 	@Override
 	public boolean isAspect(Class<?> clazz) {
+		return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
+	}
+
+	private boolean hasAspectAnnotation(Class<?> clazz) {
 		return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
 	}

+	/**
+	 * We need to detect this as "code-style" AspectJ aspects should not be
+	 * interpreted by Spring AOP.
+	 */
+	private boolean compiledByAjc(Class<?> clazz) {
+		// The AJTypeSystem goes to great lengths to provide a uniform appearance between code-style and
+		// annotation-style aspects. Therefore there is no 'clean' way to tell them apart. Here we rely on
+		// an implementation detail of the AspectJ compiler.
+		for (Field field : clazz.getDeclaredFields()) {
+			if (field.getName().startsWith(AJC_MAGIC)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	@Override
 	public void validate(Class<?> aspectClass) throws AopConfigException {
 		AjType<?> ajType = AjTypeSystem.getAjType(aspectClass);
@@ -86,7 +115,6 @@ 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...).
@@ -40,12 +40,11 @@ import org.springframework.util.ClassUtils;
 */
 class AspectJBeanFactoryInitializationAotProcessor implements BeanFactoryInitializationAotProcessor {

-	private static final boolean aspectJPresent = ClassUtils.isPresent("org.aspectj.lang.annotation.Pointcut",
-			AspectJBeanFactoryInitializationAotProcessor.class.getClassLoader());
+	private static final boolean aspectJPresent = ClassUtils.isPresent(
+			"org.aspectj.lang.annotation.Pointcut", AspectJBeanFactoryInitializationAotProcessor.class.getClassLoader());

-
-	@Override
 	@Nullable
+	@Override
 	public BeanFactoryInitializationAotContribution processAheadOfTime(ConfigurableListableBeanFactory beanFactory) {
 		if (aspectJPresent) {
 			return AspectDelegate.processAheadOfTime(beanFactory);
@@ -53,7 +52,6 @@ class AspectJBeanFactoryInitializationAotProcessor implements BeanFactoryInitial
 		return null;
 	}

-
 	/**
 	 * Inner class to avoid a hard dependency on AspectJ at runtime.
 	 */
@@ -63,8 +61,9 @@ class AspectJBeanFactoryInitializationAotProcessor implements BeanFactoryInitial
 		private static AspectContribution processAheadOfTime(ConfigurableListableBeanFactory beanFactory) {
 			BeanFactoryAspectJAdvisorsBuilder builder = new BeanFactoryAspectJAdvisorsBuilder(beanFactory);
 			List<Advisor> advisors = builder.buildAspectJAdvisors();
-			return (advisors.isEmpty() ? null : new AspectContribution(advisors));
+			return advisors.isEmpty() ? null : new AspectContribution(advisors);
 		}
+
 	}


@@ -85,6 +84,7 @@ class AspectJBeanFactoryInitializationAotProcessor implements BeanFactoryInitial
 				}
 			}
 		}
+
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -124,16 +124,10 @@ public class AspectMetadata implements Serializable {
 	 * Extract contents from String of form {@code pertarget(contents)}.
 	 */
 	private String findPerClause(Class<?> aspectClass) {
-		Aspect ann = aspectClass.getAnnotation(Aspect.class);
-		if (ann == null) {
-			return "";
-		}
-		String value = ann.value();
-		int beginIndex = value.indexOf('(');
-		if (beginIndex < 0) {
-			return "";
-		}
-		return value.substring(beginIndex + 1, value.length() - 1);
+		String str = aspectClass.getAnnotation(Aspect.class).value();
+		int beginIndex = str.indexOf('(') + 1;
+		int endIndex = str.length() - 1;
+		return str.substring(beginIndex, endIndex);
 	}


@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -32,7 +32,6 @@ import org.springframework.aop.aspectj.annotation.AbstractAspectJAdvisorFactory.
 import org.springframework.aop.support.DynamicMethodMatcherPointcut;
 import org.springframework.aop.support.Pointcuts;
 import org.springframework.lang.Nullable;
-import org.springframework.util.ObjectUtils;

 /**
 * Internal implementation of AspectJPointcutAdvisor.
@@ -41,7 +40,6 @@ import org.springframework.util.ObjectUtils;
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
- * @author Sam Brannen
 * @since 2.0
 */
@SuppressWarnings("serial")
@@ -293,33 +291,12 @@ final class InstantiationModelAwarePointcutAdvisorImpl
 		@Override
 		public boolean matches(Method method, Class<?> targetClass, Object... args) {
 			// This can match only on declared pointcut.
-			return (isAspectMaterialized() && this.declaredPointcut.matches(method, targetClass, args));
+			return (isAspectMaterialized() && this.declaredPointcut.matches(method, targetClass));
 		}

 		private boolean isAspectMaterialized() {
 			return (this.aspectInstanceFactory == null || this.aspectInstanceFactory.isMaterialized());
 		}
-
-		@Override
-		public boolean equals(@Nullable Object other) {
-			// For equivalence, we only need to compare the preInstantiationPointcut fields since
-			// they include the declaredPointcut fields. In addition, we should not compare the
-			// aspectInstanceFactory fields since LazySingletonAspectInstanceFactoryDecorator does
-			// not implement equals().
-			return (this == other || (other instanceof PerTargetInstantiationModelPointcut that &&
-					ObjectUtils.nullSafeEquals(this.preInstantiationPointcut, that.preInstantiationPointcut)));
-		}
-
-		@Override
-		public int hashCode() {
-			return ObjectUtils.nullSafeHashCode(this.declaredPointcut.getExpression());
-		}
-
-		@Override
-		public String toString() {
-			return PerTargetInstantiationModelPointcut.class.getName() + ": " + this.declaredPointcut.getExpression();
-		}
-
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -48,8 +48,7 @@ import org.springframework.util.ObjectUtils;

 /**
 * Base class for AOP proxy configuration managers.
- *
- * <p>These are not themselves AOP proxies, but subclasses of this class are
+ * These are not themselves AOP proxies, but subclasses of this class are
 * normally factories from which AOP proxy instances are obtained directly.
 *
 * <p>This class frees subclasses of the housekeeping of Advices
@@ -57,12 +56,10 @@ import org.springframework.util.ObjectUtils;
 * methods, which are provided by subclasses.
 *
 * <p>This class is serializable; subclasses need not be.
- *
- * <p>This class is used to hold snapshots of proxies.
+ * This class is used to hold snapshots of proxies.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
- * @author Sam Brannen
 * @see org.springframework.aop.framework.AopProxy
 */
 public class AdvisedSupport extends ProxyConfig implements Advised {
@@ -102,12 +99,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 */
 	private List<Advisor> advisors = new ArrayList<>();

-	/**
-	 * List of minimal {@link AdvisorKeyEntry} instances,
-	 * to be assigned to the {@link #advisors} field on reduction.
-	 * @since 6.0.10
-	 * @see #reduceToAdvisorKey
-	 */
 	private List<Advisor> advisorKey = this.advisors;


@@ -120,7 +111,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}

 	/**
-	 * Create an {@code AdvisedSupport} instance with the given parameters.
+	 * Create a AdvisedSupport instance with the given parameters.
 	 * @param interfaces the proxied interfaces
 	 */
 	public AdvisedSupport(Class<?>... interfaces) {
@@ -140,7 +131,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {

 	/**
 	 * Set the given object as target.
-	 * <p>Will create a SingletonTargetSource for the object.
+	 * Will create a SingletonTargetSource for the object.
 	 * @see #setTargetSource
 	 * @see org.springframework.aop.target.SingletonTargetSource
 	 */
@@ -368,7 +359,8 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	private void validateIntroductionAdvisor(IntroductionAdvisor advisor) {
 		advisor.validateInterfaces();
 		// If the advisor passed validation, we can make the change.
-		for (Class<?> ifc : advisor.getInterfaces()) {
+		Class<?>[] ifcs = advisor.getInterfaces();
+		for (Class<?> ifc : ifcs) {
 			addInterface(ifc);
 		}
 	}
@@ -514,9 +506,9 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}

 	/**
-	 * Copy the AOP configuration from the given {@link AdvisedSupport} object,
-	 * but allow substitution of a fresh {@link TargetSource} and a given interceptor chain.
-	 * @param other the {@code AdvisedSupport} object to take proxy configuration from
+	 * Copy the AOP configuration from the given AdvisedSupport object,
+	 * but allow substitution of a fresh TargetSource and a given interceptor chain.
+	 * @param other the AdvisedSupport object to take proxy configuration from
 	 * @param targetSource the new TargetSource
 	 * @param advisors the Advisors for the chain
 	 */
@@ -536,8 +528,8 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}

 	/**
-	 * Build a configuration-only copy of this {@link AdvisedSupport},
-	 * replacing the {@link TargetSource}.
+	 * Build a configuration-only copy of this AdvisedSupport,
+	 * replacing the TargetSource.
 	 */
 	AdvisedSupport getConfigurationOnlyCopy() {
 		AdvisedSupport copy = new AdvisedSupport(this.advisorChainFactory, this.methodCache);
@@ -562,6 +554,18 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}


+	//---------------------------------------------------------------------
+	// 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.methodCache = new ConcurrentHashMap<>(32);
+	}
+
 	@Override
 	public String toProxyConfigString() {
 		return toString();
@@ -583,19 +587,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}


-	//---------------------------------------------------------------------
-	// 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.methodCache = new ConcurrentHashMap<>(32);
-	}
-
-
 	/**
 	 * Simple wrapper class around a Method. Used as the key when
 	 * caching methods, for efficient equals and hashCode comparisons.
@@ -613,7 +604,8 @@ public class AdvisedSupport extends ProxyConfig implements Advised {

 		@Override
 		public boolean equals(@Nullable Object other) {
-			return (this == other || (other instanceof MethodCacheKey that && this.method == that.method));
+			return (this == other || (other instanceof MethodCacheKey methodCacheKey &&
+					this.method == methodCacheKey.method));
 		}

 		@Override
@@ -638,33 +630,29 @@ public class AdvisedSupport extends ProxyConfig implements Advised {


 	/**
-	 * Stub for an {@link Advisor} instance that is just needed for key purposes,
+	 * Stub for an Advisor instance that is just needed for key purposes,
 	 * allowing for efficient equals and hashCode comparisons against the
 	 * advice class and the pointcut.
 	 * @since 6.0.10
 	 * @see #getConfigurationOnlyCopy()
 	 * @see #getAdvisorKey()
 	 */
-	private static final class AdvisorKeyEntry implements Advisor {
+	private static class AdvisorKeyEntry implements Advisor {

 		private final Class<?> adviceType;

 		@Nullable
-		private final String classFilterKey;
+		private String classFilterKey;

 		@Nullable
-		private final String methodMatcherKey;
+		private String methodMatcherKey;

 		public AdvisorKeyEntry(Advisor advisor) {
 			this.adviceType = advisor.getAdvice().getClass();
 			if (advisor instanceof PointcutAdvisor pointcutAdvisor) {
 				Pointcut pointcut = pointcutAdvisor.getPointcut();
-				this.classFilterKey = pointcut.getClassFilter().toString();
-				this.methodMatcherKey = pointcut.getMethodMatcher().toString();
-			}
-			else {
-				this.classFilterKey = null;
-				this.methodMatcherKey = null;
+				this.classFilterKey = ObjectUtils.identityToString(pointcut.getClassFilter());
+				this.methodMatcherKey = ObjectUtils.identityToString(pointcut.getMethodMatcher());
 			}
 		}

@@ -675,10 +663,10 @@ public class AdvisedSupport extends ProxyConfig implements Advised {

 		@Override
 		public boolean equals(Object other) {
-			return (this == other || (other instanceof AdvisorKeyEntry that &&
-					this.adviceType == that.adviceType &&
-					ObjectUtils.nullSafeEquals(this.classFilterKey, that.classFilterKey) &&
-					ObjectUtils.nullSafeEquals(this.methodMatcherKey, that.methodMatcherKey)));
+			return (this == other || (other instanceof AdvisorKeyEntry otherEntry &&
+					this.adviceType == otherEntry.adviceType &&
+					ObjectUtils.nullSafeEquals(this.classFilterKey, otherEntry.classFilterKey) &&
+					ObjectUtils.nullSafeEquals(this.methodMatcherKey, otherEntry.methodMatcherKey)));
 		}

 		@Override
@@ -265,32 +265,18 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * Return the type of the proxy. Will check the singleton instance if
 	 * already created, else fall back to the proxy interface (in case of just
 	 * a single one), the target bean type, or the TargetSource's target class.
-	 * @see org.springframework.aop.framework.AopProxy#getProxyClass
+	 * @see org.springframework.aop.TargetSource#getTargetClass
 	 */
 	@Override
-	@Nullable
 	public Class<?> getObjectType() {
 		synchronized (this) {
 			if (this.singletonInstance != null) {
 				return this.singletonInstance.getClass();
 			}
 		}
-		try {
-			// This might be incomplete since it potentially misses introduced interfaces
-			// from Advisors that will be lazily retrieved via setInterceptorNames.
-			return createAopProxy().getProxyClass(this.proxyClassLoader);
-		}
-		catch (AopConfigException ex) {
-			if (getTargetClass() == null) {
-				if (logger.isDebugEnabled()) {
-					logger.debug("Failed to determine early proxy class: " + ex.getMessage());
-				}
-				return null;
-			}
-			else {
-				throw ex;
-			}
-		}
+		// This might be incomplete since it potentially misses introduced interfaces
+		// from Advisors that will be lazily retrieved via setInterceptorNames.
+		return createAopProxy().getProxyClass(this.proxyClassLoader);
 	}

 	@Override
@@ -58,7 +58,6 @@ import org.springframework.util.function.SingletonSupplier;
 * @author Juergen Hoeller
 * @author Stephane Nicoll
 * @author He Bo
- * @author Sebastien Deleuze
 * @since 3.1.2
 */
 public abstract class AsyncExecutionAspectSupport implements BeanFactoryAware {
@@ -291,7 +290,7 @@ public abstract class AsyncExecutionAspectSupport implements BeanFactoryAware {
 		else if (Future.class.isAssignableFrom(returnType)) {
 			return executor.submit(task);
 		}
-		else if (void.class == returnType || "kotlin.Unit".equals(returnType.getName())) {
+		else if (void.class == returnType) {
 			executor.submit(task);
 			return null;
 		}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -186,10 +186,10 @@ public abstract class AopUtils {
 	 * this method resolves bridge methods in order to retrieve attributes from
 	 * the <i>original</i> method definition.
 	 * @param method the method to be invoked, which may come from an interface
-	 * @param targetClass the target class for the current invocation
-	 * (can be {@code null} or may not even implement the method)
+	 * @param targetClass the target class for the current invocation.
+	 * May be {@code null} or may not even implement the method.
 	 * @return the specific target method, or the original method if the
-	 * {@code targetClass} does not implement it
+	 * {@code targetClass} doesn't implement it or is {@code null}
 	 * @see org.springframework.util.ClassUtils#getMostSpecificMethod
 	 */
 	public static Method getMostSpecificMethod(Method method, @Nullable Class<?> targetClass) {
@@ -123,6 +123,7 @@ public abstract class ClassFilters {
 		public String toString() {
 			return getClass().getName() + ": " + Arrays.toString(this.filters);
 		}
+
 	}


@@ -163,6 +164,7 @@ public abstract class ClassFilters {
 		public String toString() {
 			return getClass().getName() + ": " + Arrays.toString(this.filters);
 		}
+
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 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,6 +23,9 @@ import java.util.Map;

 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;
+import org.aspectj.weaver.tools.PointcutExpression;
+import org.aspectj.weaver.tools.PointcutPrimitive;
+import org.aspectj.weaver.tools.UnsupportedPointcutPrimitiveException;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import test.annotation.EmptySpringAnnotation;
@@ -39,6 +42,7 @@ import org.springframework.beans.testfixture.beans.TestBean;
 import org.springframework.beans.testfixture.beans.subpkg.DeepBean;

 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;

@@ -61,7 +65,7 @@ public class AspectJExpressionPointcutTests {


 	@BeforeEach
-	public void setup() throws NoSuchMethodException {
+	public void setUp() throws NoSuchMethodException {
 		getAge = TestBean.class.getMethod("getAge");
 		setAge = TestBean.class.getMethod("setAge", int.class);
 		setSomeNumber = TestBean.class.getMethod("setSomeNumber", Number.class);
@@ -171,25 +175,25 @@ public class AspectJExpressionPointcutTests {
 	@Test
 	public void testFriendlyErrorOnNoLocationClassMatching() {
 		AspectJExpressionPointcut pc = new AspectJExpressionPointcut();
-		assertThatIllegalStateException()
-				.isThrownBy(() -> pc.getClassFilter().matches(ITestBean.class))
-				.withMessageContaining("expression");
+		assertThatIllegalStateException().isThrownBy(() ->
+				pc.matches(ITestBean.class))
+			.withMessageContaining("expression");
 	}

 	@Test
 	public void testFriendlyErrorOnNoLocation2ArgMatching() {
 		AspectJExpressionPointcut pc = new AspectJExpressionPointcut();
-		assertThatIllegalStateException()
-				.isThrownBy(() -> pc.getMethodMatcher().matches(getAge, ITestBean.class))
-				.withMessageContaining("expression");
+		assertThatIllegalStateException().isThrownBy(() ->
+				pc.matches(getAge, ITestBean.class))
+			.withMessageContaining("expression");
 	}

 	@Test
 	public void testFriendlyErrorOnNoLocation3ArgMatching() {
 		AspectJExpressionPointcut pc = new AspectJExpressionPointcut();
-		assertThatIllegalStateException()
-				.isThrownBy(() -> pc.getMethodMatcher().matches(getAge, ITestBean.class, (Object[]) null))
-				.withMessageContaining("expression");
+		assertThatIllegalStateException().isThrownBy(() ->
+				pc.matches(getAge, ITestBean.class, (Object[]) null))
+			.withMessageContaining("expression");
 	}


@@ -206,10 +210,8 @@ public class AspectJExpressionPointcutTests {
 		// not currently testable in a reliable fashion
 		//assertDoesNotMatchStringClass(classFilter);

-		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, 12D))
-				.as("Should match with setSomeNumber with Double input").isTrue();
-		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, 11))
-				.as("Should not match setSomeNumber with Integer input").isFalse();
+		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, 12D)).as("Should match with setSomeNumber with Double input").isTrue();
+		assertThat(methodMatcher.matches(setSomeNumber, TestBean.class, 11)).as("Should not match setSomeNumber with Integer input").isFalse();
 		assertThat(methodMatcher.matches(getAge, TestBean.class)).as("Should not match getAge").isFalse();
 		assertThat(methodMatcher.isRuntime()).as("Should be a runtime match").isTrue();
 	}
@@ -244,13 +246,14 @@ public class AspectJExpressionPointcutTests {
 	@Test
 	public void testInvalidExpression() {
 		String expression = "execution(void org.springframework.beans.testfixture.beans.TestBean.setSomeNumber(Number) && args(Double)";
-		assertThatIllegalArgumentException().isThrownBy(() -> getPointcut(expression).getClassFilter().matches(Object.class));
+		assertThatIllegalArgumentException().isThrownBy(
+				getPointcut(expression)::getClassFilter);  // call to getClassFilter forces resolution
 	}

 	private TestBean getAdvisedProxy(String pointcutExpression, CallCountingInterceptor interceptor) {
 		TestBean target = new TestBean();

-		AspectJExpressionPointcut pointcut = getPointcut(pointcutExpression);
+		Pointcut pointcut = getPointcut(pointcutExpression);

 		DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
 		advisor.setAdvice(interceptor);
@@ -274,29 +277,40 @@ public class AspectJExpressionPointcutTests {
 	@Test
 	public void testWithUnsupportedPointcutPrimitive() {
 		String expression = "call(int org.springframework.beans.testfixture.beans.TestBean.getAge())";
-		assertThat(getPointcut(expression).getClassFilter().matches(Object.class)).isFalse();
+		assertThatExceptionOfType(UnsupportedPointcutPrimitiveException.class).isThrownBy(() ->
+				getPointcut(expression).getClassFilter()) // call to getClassFilter forces resolution...
+			.satisfies(ex -> assertThat(ex.getUnsupportedPrimitive()).isEqualTo(PointcutPrimitive.CALL));
 	}

 	@Test
 	public void testAndSubstitution() {
-		AspectJExpressionPointcut pc = getPointcut("execution(* *(..)) and args(String)");
-		String expr = pc.getPointcutExpression().getPointcutExpression();
-		assertThat(expr).isEqualTo("execution(* *(..)) && args(String)");
+		Pointcut pc = getPointcut("execution(* *(..)) and args(String)");
+		PointcutExpression expr = ((AspectJExpressionPointcut) pc).getPointcutExpression();
+		assertThat(expr.getPointcutExpression()).isEqualTo("execution(* *(..)) && args(String)");
 	}

 	@Test
 	public void testMultipleAndSubstitutions() {
-		AspectJExpressionPointcut pc = getPointcut("execution(* *(..)) and args(String) and this(Object)");
-		String expr = pc.getPointcutExpression().getPointcutExpression();
-		assertThat(expr).isEqualTo("execution(* *(..)) && args(String) && this(Object)");
+		Pointcut pc = getPointcut("execution(* *(..)) and args(String) and this(Object)");
+		PointcutExpression expr = ((AspectJExpressionPointcut) pc).getPointcutExpression();
+		assertThat(expr.getPointcutExpression()).isEqualTo("execution(* *(..)) && args(String) && this(Object)");
 	}

-	private AspectJExpressionPointcut getPointcut(String expression) {
+	private Pointcut getPointcut(String expression) {
 		AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
 		pointcut.setExpression(expression);
 		return pointcut;
 	}

+
+	public static class OtherIOther implements IOther {
+
+		@Override
+		public void absquatulate() {
+			// Empty
+		}
+	}
+
 	@Test
 	public void testMatchGenericArgument() {
 		String expression = "execution(* set*(java.util.List<org.springframework.beans.testfixture.beans.TestBean>) )";
@@ -491,15 +505,6 @@ public class AspectJExpressionPointcutTests {
 	}


-	public static class OtherIOther implements IOther {
-
-		@Override
-		public void absquatulate() {
-			// Empty
-		}
-	}
-
-
 	public static class HasGeneric {

 		public void setFriends(List<TestBean> friends) {
@@ -40,6 +40,10 @@ import org.aspectj.lang.annotation.Pointcut;
 import org.aspectj.lang.reflect.MethodSignature;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import test.aop.DefaultLockable;
+import test.aop.Lockable;
+import test.aop.PerTargetAspect;
+import test.aop.TwoAdviceAspect;

 import org.springframework.aop.Advisor;
 import org.springframework.aop.framework.Advised;
@@ -47,10 +51,6 @@ import org.springframework.aop.framework.AopConfigException;
 import org.springframework.aop.framework.ProxyFactory;
 import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
 import org.springframework.aop.support.AopUtils;
-import org.springframework.aop.testfixture.aspectj.PerTargetAspect;
-import org.springframework.aop.testfixture.aspectj.TwoAdviceAspect;
-import org.springframework.aop.testfixture.mixin.DefaultLockable;
-import org.springframework.aop.testfixture.mixin.Lockable;
 import org.springframework.beans.testfixture.beans.ITestBean;
 import org.springframework.beans.testfixture.beans.TestBean;
 import org.springframework.core.OrderComparator;
@@ -459,10 +459,10 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 		assertThat(advisors).as("Two advice methods found").hasSize(2);
 		ITestBean itb = createProxy(target, ITestBean.class, advisors);
 		itb.setName("");
-		assertThat(itb.age()).isEqualTo(0);
+		assertThat(itb.getAge()).isEqualTo(0);
 		int newAge = 32;
 		itb.setAge(newAge);
-		assertThat(itb.age()).isEqualTo(1);
+		assertThat(itb.getAge()).isEqualTo(1);
 	}

 	@Test
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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,38 +42,26 @@ import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 */
 class ArgumentBindingTests {

-	@Test
-	void annotationArgumentNameBinding() {
-		AspectJProxyFactory proxyFactory = new AspectJProxyFactory(new TransactionalBean());
-		proxyFactory.addAspect(PointcutWithAnnotationArgument.class);
-		ITransactionalBean proxiedTestBean = proxyFactory.getProxy();
-
-		assertThatIllegalStateException()
-				.isThrownBy(proxiedTestBean::doInTransaction)
-				.withMessage("Invoked with @Transactional");
-	}
-
 	@Test
 	void bindingInPointcutUsedByAdvice() {
 		AspectJProxyFactory proxyFactory = new AspectJProxyFactory(new TestBean());
 		proxyFactory.addAspect(NamedPointcutWithArgs.class);
-		ITestBean proxiedTestBean = proxyFactory.getProxy();

+		ITestBean proxiedTestBean = proxyFactory.getProxy();
 		assertThatIllegalArgumentException()
-				.isThrownBy(() -> proxiedTestBean.setName("enigma"))
-				.withMessage("enigma");
+			.isThrownBy(() -> proxiedTestBean.setName("enigma"))
+			.withMessage("enigma");
 	}

 	@Test
-	void bindingWithDynamicAdvice() {
-		AspectJProxyFactory proxyFactory = new AspectJProxyFactory(new TestBean());
-		proxyFactory.addAspect(DynamicPointcutWithArgs.class);
-		ITestBean proxiedTestBean = proxyFactory.getProxy();
+	void annotationArgumentNameBinding() {
+		AspectJProxyFactory proxyFactory = new AspectJProxyFactory(new TransactionalBean());
+		proxyFactory.addAspect(PointcutWithAnnotationArgument.class);

-		proxiedTestBean.applyName(1);
-		assertThatIllegalArgumentException()
-				.isThrownBy(() -> proxiedTestBean.applyName("enigma"))
-				.withMessage("enigma");
+		ITransactionalBean proxiedTestBean = proxyFactory.getProxy();
+		assertThatIllegalStateException()
+			.isThrownBy(proxiedTestBean::doInTransaction)
+			.withMessage("Invoked with @Transactional");
 	}

 	@Test
@@ -106,7 +94,6 @@ class ArgumentBindingTests {
 		}
 	}

-
 	/**
 	 * Mimics Spring's @Transactional annotation without actually introducing the dependency.
 	 */
@@ -114,16 +101,15 @@ class ArgumentBindingTests {
 	@interface Transactional {
 	}

-
 	@Aspect
 	static class PointcutWithAnnotationArgument {

-		@Around("execution(* org.springframework..*.*(..)) && @annotation(transactional)")
+		@Around(value = "execution(* org.springframework..*.*(..)) && @annotation(transactional)")
 		public Object around(ProceedingJoinPoint pjp, Transactional transactional) throws Throwable {
 			throw new IllegalStateException("Invoked with @Transactional");
 		}
-	}

+	}

 	@Aspect
 	static class NamedPointcutWithArgs {
@@ -135,16 +121,7 @@ class ArgumentBindingTests {
 		public Object doAround(ProceedingJoinPoint pjp, String aString) throws Throwable {
 			throw new IllegalArgumentException(aString);
 		}
-	}

-
-	@Aspect("pertarget(execution(* *(..)))")
-	static class DynamicPointcutWithArgs {
-
-		@Around("execution(* *(..)) && args(java.lang.String)")
-		public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
-			throw new IllegalArgumentException(String.valueOf(pjp.getArgs()[0]));
-		}
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2020 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,13 +17,13 @@
 package org.springframework.aop.aspectj.annotation;

 import org.junit.jupiter.api.Test;
+import test.aop.PerTargetAspect;

 import org.springframework.aop.Pointcut;
 import org.springframework.aop.aspectj.AspectJExpressionPointcut;
 import org.springframework.aop.aspectj.AspectJExpressionPointcutTests;
 import org.springframework.aop.aspectj.annotation.AbstractAspectJAdvisorFactoryTests.ExceptionThrowingAspect;
 import org.springframework.aop.framework.AopConfigException;
-import org.springframework.aop.testfixture.aspectj.PerTargetAspect;
 import org.springframework.beans.testfixture.beans.TestBean;

 import static org.assertj.core.api.Assertions.assertThat;
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2022 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,11 +18,11 @@ package org.springframework.aop.aspectj.annotation;

 import org.aspectj.lang.reflect.PerClauseKind;
 import org.junit.jupiter.api.Test;
+import test.aop.PerTargetAspect;

 import org.springframework.aop.Pointcut;
 import org.springframework.aop.aspectj.AspectJExpressionPointcut;
 import org.springframework.aop.aspectj.annotation.AbstractAspectJAdvisorFactoryTests.ExceptionThrowingAspect;
-import org.springframework.aop.testfixture.aspectj.PerTargetAspect;

 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2020 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,8 +24,8 @@ import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
 import org.junit.jupiter.api.Test;
+import test.aop.PerThisAspect;

-import org.springframework.aop.testfixture.aspectj.PerThisAspect;
 import org.springframework.core.testfixture.io.SerializationTestUtils;

 import static org.assertj.core.api.Assertions.assertThat;
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 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,35 +17,29 @@
 package org.springframework.aop.support;

 import java.lang.reflect.Method;
-import java.util.List;

 import org.junit.jupiter.api.Test;

 import org.springframework.aop.ClassFilter;
 import org.springframework.aop.MethodMatcher;
 import org.springframework.aop.Pointcut;
-import org.springframework.aop.framework.ProxyFactory;
 import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
 import org.springframework.aop.target.EmptyTargetSource;
 import org.springframework.aop.testfixture.interceptor.NopInterceptor;
 import org.springframework.beans.testfixture.beans.TestBean;
-import org.springframework.core.ResolvableType;
 import org.springframework.core.testfixture.io.SerializationTestUtils;
 import org.springframework.lang.Nullable;
-import org.springframework.util.ReflectionUtils;

 import static org.assertj.core.api.Assertions.assertThat;

 /**
 * @author Rod Johnson
 * @author Chris Beams
- * @author Sebastien Deleuze
- * @author Juergen Hoeller
 */
-class AopUtilsTests {
+public class AopUtilsTests {

 	@Test
-	void testPointcutCanNeverApply() {
+	public void testPointcutCanNeverApply() {
 		class TestPointcut extends StaticMethodMatcherPointcut {
 			@Override
 			public boolean matches(Method method, @Nullable Class<?> clazzy) {
@@ -58,13 +52,13 @@ class AopUtilsTests {
 	}

 	@Test
-	void testPointcutAlwaysApplies() {
+	public void testPointcutAlwaysApplies() {
 		assertThat(AopUtils.canApply(new DefaultPointcutAdvisor(new NopInterceptor()), Object.class)).isTrue();
 		assertThat(AopUtils.canApply(new DefaultPointcutAdvisor(new NopInterceptor()), TestBean.class)).isTrue();
 	}

 	@Test
-	void testPointcutAppliesToOneMethodOnObject() {
+	public void testPointcutAppliesToOneMethodOnObject() {
 		class TestPointcut extends StaticMethodMatcherPointcut {
 			@Override
 			public boolean matches(Method method, @Nullable Class<?> clazz) {
@@ -84,7 +78,7 @@ class AopUtilsTests {
 	 * that's subverted the singleton construction limitation.
 	 */
 	@Test
-	void testCanonicalFrameworkClassesStillCanonicalOnDeserialization() throws Exception {
+	public void testCanonicalFrameworkClassesStillCanonicalOnDeserialization() throws Exception {
 		assertThat(SerializationTestUtils.serializeAndDeserialize(MethodMatcher.TRUE)).isSameAs(MethodMatcher.TRUE);
 		assertThat(SerializationTestUtils.serializeAndDeserialize(ClassFilter.TRUE)).isSameAs(ClassFilter.TRUE);
 		assertThat(SerializationTestUtils.serializeAndDeserialize(Pointcut.TRUE)).isSameAs(Pointcut.TRUE);
@@ -94,45 +88,4 @@ class AopUtilsTests {
 		assertThat(SerializationTestUtils.serializeAndDeserialize(ExposeInvocationInterceptor.INSTANCE)).isSameAs(ExposeInvocationInterceptor.INSTANCE);
 	}

-	@Test
-	void testInvokeJoinpointUsingReflection() throws Throwable {
-		String name = "foo";
-		TestBean testBean = new TestBean(name);
-		Method method = ReflectionUtils.findMethod(TestBean.class, "getName");
-		Object result = AopUtils.invokeJoinpointUsingReflection(testBean, method, new Object[0]);
-		assertThat(result).isEqualTo(name);
-	}
-
-	@Test  // gh-32365
-	void mostSpecificMethodBetweenJdkProxyAndTarget() throws Exception {
-		Class<?> proxyClass = new ProxyFactory(new WithInterface()).getProxyClass(getClass().getClassLoader());
-		Method specificMethod = AopUtils.getMostSpecificMethod(proxyClass.getMethod("handle", List.class), WithInterface.class);
-		assertThat(ResolvableType.forMethodParameter(specificMethod, 0).getGeneric().toClass()).isEqualTo(String.class);
-	}
-
-	@Test  // gh-32365
-	void mostSpecificMethodBetweenCglibProxyAndTarget() throws Exception {
-		Class<?> proxyClass = new ProxyFactory(new WithoutInterface()).getProxyClass(getClass().getClassLoader());
-		Method specificMethod = AopUtils.getMostSpecificMethod(proxyClass.getMethod("handle", List.class), WithoutInterface.class);
-		assertThat(ResolvableType.forMethodParameter(specificMethod, 0).getGeneric().toClass()).isEqualTo(String.class);
-	}
-
-
-	interface ProxyInterface {
-
-		void handle(List<String> list);
-	}
-
-	static class WithInterface implements ProxyInterface {
-
-		public void handle(List<String> list) {
-		}
-	}
-
-	static class WithoutInterface {
-
-		public void handle(List<String> list) {
-		}
-	}
-
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-package org.springframework.aop.testfixture.mixin;
+package test.aop;

 /**
 * Simple implementation of Lockable interface for use in mixins.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -14,12 +14,14 @@
 * limitations under the License.
 */

-package org.springframework.aop.testfixture.mixin;
+package test.aop;
+

 /**
- * Simple interface to use for mixins.
+ * Simple interface to use for mixins
 *
 * @author Rod Johnson
+ *
 */
 public interface Lockable {

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-package org.springframework.aop.testfixture.aspectj;
+package test.aop;

 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2005 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.
@@ -13,22 +13,25 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-package org.springframework.http

-import org.assertj.core.api.Assertions.assertThat
-import org.junit.jupiter.api.Test
+package test.aop;

-/**
- * Kotlin tests for [ProblemDetail].
- */
-class KotlinProblemDetailTests {
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;

-	@Test // gh-31430
-	fun propertiesSetter() {
-		val problemDetail = ProblemDetail()
-		val map = mapOf("foo" to "bar")
-		problemDetail.properties = map
-		assertThat(problemDetail.properties).isEqualTo(map)
+@Aspect("perthis(execution(* getAge()))")
+public class PerThisAspect {
+
+	private int invocations = 0;
+
+	public int getInvocations() {
+		return this.invocations;
+	}
+
+	@Around("execution(* getAge())")
+	public int changeAge(ProceedingJoinPoint pjp) throws Throwable {
+		return invocations++;
 	}

 }
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2002-2008 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
+ *
+ *      https://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 test.aop;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+
+@Aspect
+public class TwoAdviceAspect {
+	private int totalCalls;
+
+	@Around("execution(* getAge())")
+	public int returnCallCount(ProceedingJoinPoint pjp) throws Exception {
+		return totalCalls;
+	}
+
+	@Before("execution(* setAge(int)) && args(newAge)")
+	public void countSet(int newAge) throws Exception {
+		++totalCalls;
+	}
+}
@@ -1000,20 +1000,18 @@ public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyA
 	 */
 	protected abstract static class PropertyHandler {

-		@Nullable
 		private final Class<?> propertyType;

 		private final boolean readable;

 		private final boolean writable;

-		public PropertyHandler(@Nullable Class<?> propertyType, boolean readable, boolean writable) {
+		public PropertyHandler(Class<?> propertyType, boolean readable, boolean writable) {
 			this.propertyType = propertyType;
 			this.readable = readable;
 			this.writable = writable;
 		}

-		@Nullable
 		public Class<?> getPropertyType() {
 			return this.propertyType;
 		}
@@ -23,7 +23,6 @@ import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.lang.reflect.Type;
 import java.net.URI;
 import java.net.URL;
 import java.time.temporal.Temporal;
@@ -616,8 +615,8 @@ public abstract class BeanUtils {
 	 * @return a corresponding MethodParameter object
 	 */
 	public static MethodParameter getWriteMethodParameter(PropertyDescriptor pd) {
-		if (pd instanceof GenericTypeAwarePropertyDescriptor gpd) {
-			return new MethodParameter(gpd.getWriteMethodParameter());
+		if (pd instanceof GenericTypeAwarePropertyDescriptor typeAwarePd) {
+			return new MethodParameter(typeAwarePd.getWriteMethodParameter());
 		}
 		else {
 			Method writeMethod = pd.getWriteMethod();
@@ -788,28 +787,38 @@ public abstract class BeanUtils {
 		if (editable != null) {
 			if (!editable.isInstance(target)) {
 				throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
-						"] not assignable to editable class [" + editable.getName() + "]");
+						"] not assignable to Editable class [" + editable.getName() + "]");
 			}
 			actualEditable = editable;
 		}
 		PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
 		Set<String> ignoredProps = (ignoreProperties != null ? new HashSet<>(Arrays.asList(ignoreProperties)) : null);
-		CachedIntrospectionResults sourceResults = (actualEditable != source.getClass() ?
-				CachedIntrospectionResults.forClass(source.getClass()) : null);

 		for (PropertyDescriptor targetPd : targetPds) {
 			Method writeMethod = targetPd.getWriteMethod();
 			if (writeMethod != null && (ignoredProps == null || !ignoredProps.contains(targetPd.getName()))) {
-				PropertyDescriptor sourcePd = (sourceResults != null ?
-						sourceResults.getPropertyDescriptor(targetPd.getName()) : targetPd);
+				PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
 				if (sourcePd != null) {
 					Method readMethod = sourcePd.getReadMethod();
 					if (readMethod != null) {
-						if (isAssignable(writeMethod, readMethod)) {
+						ResolvableType sourceResolvableType = ResolvableType.forMethodReturnType(readMethod);
+						ResolvableType targetResolvableType = ResolvableType.forMethodParameter(writeMethod, 0);
+
+						// Ignore generic types in assignable check if either ResolvableType has unresolvable generics.
+						boolean isAssignable =
+								(sourceResolvableType.hasUnresolvableGenerics() || targetResolvableType.hasUnresolvableGenerics() ?
+										ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType()) :
+										targetResolvableType.isAssignableFrom(sourceResolvableType));
+
+						if (isAssignable) {
 							try {
-								ReflectionUtils.makeAccessible(readMethod);
+								if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
+									readMethod.setAccessible(true);
+								}
 								Object value = readMethod.invoke(source);
-								ReflectionUtils.makeAccessible(writeMethod);
+								if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
+									writeMethod.setAccessible(true);
+								}
 								writeMethod.invoke(target, value);
 							}
 							catch (Throwable ex) {
@@ -823,24 +832,6 @@ public abstract class BeanUtils {
 		}
 	}

-	private static boolean isAssignable(Method writeMethod, Method readMethod) {
-		Type paramType = writeMethod.getGenericParameterTypes()[0];
-		if (paramType instanceof Class<?> clazz) {
-			return ClassUtils.isAssignable(clazz, readMethod.getReturnType());
-		}
-		else if (paramType.equals(readMethod.getGenericReturnType())) {
-			return true;
-		}
-		else {
-			ResolvableType sourceType = ResolvableType.forMethodReturnType(readMethod);
-			ResolvableType targetType = ResolvableType.forMethodParameter(writeMethod, 0);
-			// Ignore generic types in assignable check if either ResolvableType has unresolvable generics.
-			return (sourceType.hasUnresolvableGenerics() || targetType.hasUnresolvableGenerics() ?
-					ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType()) :
-					targetType.isAssignableFrom(sourceType));
-		}
-	}
-

 	/**
 	 * Inner class to avoid a hard dependency on Kotlin at runtime.
@@ -905,6 +896,7 @@ public abstract class BeanUtils {
 			}
 			return kotlinConstructor.callBy(argParameters);
 		}
+
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -129,6 +129,7 @@ public class DirectFieldAccessor extends AbstractNestablePropertyAccessor {
 				ReflectionUtils.makeAccessible(this.field);
 				return this.field.get(getWrappedInstance());
 			}
+
 			catch (IllegalAccessException ex) {
 				throw new InvalidPropertyException(getWrappedClass(),
 						this.field.getName(), "Field is not accessible", ex);
@@ -159,9 +159,6 @@ import org.springframework.util.StringUtils;
 public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor,
 		MergedBeanDefinitionPostProcessor, BeanRegistrationAotProcessor, PriorityOrdered, BeanFactoryAware {

-	private static final Constructor<?>[] EMPTY_CONSTRUCTOR_ARRAY = new Constructor<?>[0];
-
-
 	protected final Log logger = LogFactory.getLog(getClass());

 	private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<>(4);
@@ -196,10 +193,9 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
 		this.autowiredAnnotationTypes.add(Autowired.class);
 		this.autowiredAnnotationTypes.add(Value.class);

-		ClassLoader classLoader = AutowiredAnnotationBeanPostProcessor.class.getClassLoader();
 		try {
 			this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
-					ClassUtils.forName("jakarta.inject.Inject", classLoader));
+					ClassUtils.forName("jakarta.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
 			logger.trace("'jakarta.inject.Inject' annotation found and supported for autowiring");
 		}
 		catch (ClassNotFoundException ex) {
@@ -208,7 +204,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA

 		try {
 			this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
-					ClassUtils.forName("javax.inject.Inject", classLoader));
+					ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
 			logger.trace("'javax.inject.Inject' annotation found and supported for autowiring");
 		}
 		catch (ClassNotFoundException ex) {
@@ -289,16 +285,9 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA

 	@Override
 	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
-		// Register externally managed config members on bean definition.
 		findInjectionMetadata(beanName, beanType, beanDefinition);
 	}

-	@Override
-	public void resetBeanDefinition(String beanName) {
-		this.lookupMethodsChecked.remove(beanName);
-		this.injectionMetadataCache.remove(beanName);
-	}
-
 	@Override
 	@Nullable
 	public BeanRegistrationAotContribution processAheadOfTime(RegisteredBean registeredBean) {
@@ -334,6 +323,12 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
 		return metadata;
 	}

+	@Override
+	public void resetBeanDefinition(String beanName) {
+		this.lookupMethodsChecked.remove(beanName);
+		this.injectionMetadataCache.remove(beanName);
+	}
+
 	@Override
 	public Class<?> determineBeanType(Class<?> beanClass, String beanName) throws BeanCreationException {
 		checkLookupMethods(beanClass, beanName);
@@ -433,7 +428,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
 										"default constructor to fall back to: " + candidates.get(0));
 							}
 						}
-						candidateConstructors = candidates.toArray(EMPTY_CONSTRUCTOR_ARRAY);
+						candidateConstructors = candidates.toArray(new Constructor<?>[0]);
 					}
 					else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
 						candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
@@ -446,7 +441,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
 						candidateConstructors = new Constructor<?>[] {primaryConstructor};
 					}
 					else {
-						candidateConstructors = EMPTY_CONSTRUCTOR_ARRAY;
+						candidateConstructors = new Constructor<?>[0];
 					}
 					this.candidateConstructorsCache.put(beanClass, candidateConstructors);
 				}
@@ -587,10 +582,6 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
 						return;
 					}
 					if (method.getParameterCount() == 0) {
-						if (method.getDeclaringClass().isRecord()) {
-							// Annotations on the compact constructor arguments made available on accessors, ignoring.
-							return;
-						}
 						if (logger.isInfoEnabled()) {
 							logger.info("Autowired annotation should only be used on methods with parameters: " +
 									method);
@@ -1016,7 +1007,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
 			hints.reflection().registerField(field);
 			CodeBlock resolver = CodeBlock.of("$T.$L($S)",
 					AutowiredFieldValueResolver.class,
-					(!required ? "forField" : "forRequiredField"), field.getName());
+					(!required) ? "forField" : "forRequiredField", field.getName());
 			AccessControl accessControl = AccessControl.forMember(field);
 			if (!accessControl.isAccessibleFrom(targetClassName)) {
 				return CodeBlock.of("$L.resolveAndSet($L, $L)", resolver,
@@ -1031,7 +1022,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA

 			CodeBlock.Builder code = CodeBlock.builder();
 			code.add("$T.$L", AutowiredMethodArgumentsResolver.class,
-					(!required ? "forMethod" : "forRequiredMethod"));
+					(!required) ? "forMethod" : "forRequiredMethod");
 			code.add("($S", method.getName());
 			if (method.getParameterCount() > 0) {
 				code.add(", $L", generateParameterTypesCode(method.getParameterTypes()));
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -292,7 +292,7 @@ public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwa
 			if (actualValue != null) {
 				actualValue = typeConverter.convertIfNecessary(actualValue, expectedValue.getClass());
 			}
-			if (!ObjectUtils.nullSafeEquals(expectedValue, actualValue)) {
+			if (!expectedValue.equals(actualValue)) {
 				return false;
 			}
 		}
@@ -191,14 +191,16 @@ public final class AutowiredFieldValueResolver extends AutowiredElementResolver
 			return value;
 		}
 		catch (BeansException ex) {
-			throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
+			throw new UnsatisfiedDependencyException(null, beanName,
+					new InjectionPoint(field), ex);
 		}
 	}

 	private Field getField(RegisteredBean registeredBean) {
-		Field field = ReflectionUtils.findField(registeredBean.getBeanClass(), this.fieldName);
-		Assert.notNull(field, () -> "No field '" + this.fieldName + "' found on " +
-				registeredBean.getBeanClass().getName());
+		Field field = ReflectionUtils.findField(registeredBean.getBeanClass(),
+				this.fieldName);
+		Assert.notNull(field, () -> "No field '" + this.fieldName + "' found on "
+				+ registeredBean.getBeanClass().getName());
 		return field;
 	}

@@ -69,7 +69,6 @@ class BeanDefinitionPropertyValueCodeGenerator {

 	BeanDefinitionPropertyValueCodeGenerator(GeneratedMethods generatedMethods,
 			@Nullable BiFunction<Object, ResolvableType, CodeBlock> customValueGenerator) {
-
 		this.generatedMethods = generatedMethods;
 		this.delegates = new ArrayList<>();
 		if (customValueGenerator != null) {
@@ -144,6 +143,7 @@ class BeanDefinitionPropertyValueCodeGenerator {

 		@Nullable
 		CodeBlock generateCode(Object value, ResolvableType type);
+
 	}


@@ -163,6 +163,7 @@ class BeanDefinitionPropertyValueCodeGenerator {
 				'\\', "\\\\"
 		);

+
 		@Override
 		@Nullable
 		public CodeBlock generateCode(Object value, ResolvableType type) {
@@ -230,6 +231,7 @@ class BeanDefinitionPropertyValueCodeGenerator {
 			}
 			return null;
 		}
+
 	}


@@ -319,8 +321,8 @@ class BeanDefinitionPropertyValueCodeGenerator {
 			this.emptyResult = emptyResult;
 		}

-		@SuppressWarnings("unchecked")
 		@Override
+		@SuppressWarnings("unchecked")
 		@Nullable
 		public CodeBlock generateCode(Object value, ResolvableType type) {
 			if (this.collectionType.isInstance(value)) {
@@ -117,8 +117,7 @@ class DefaultBeanRegistrationCodeFragments implements BeanRegistrationCodeFragme
 		Class<?> beanClass = (mergedBeanDefinition.hasBeanClass()
 				? ClassUtils.getUserClass(mergedBeanDefinition.getBeanClass()) : null);
 		CodeBlock beanClassCode = generateBeanClassCode(
-				beanRegistrationCode.getClassName().packageName(),
-				(beanClass != null ? beanClass : beanType.toClass()));
+				beanRegistrationCode.getClassName().packageName(), beanClass);
 		code.addStatement("$T $L = new $T($L)", RootBeanDefinition.class,
 				BEAN_DEFINITION_VARIABLE, RootBeanDefinition.class, beanClassCode);
 		if (targetTypeNecessary(beanType, beanClass)) {
@@ -128,13 +127,16 @@ class DefaultBeanRegistrationCodeFragments implements BeanRegistrationCodeFragme
 		return code.build();
 	}

-	private CodeBlock generateBeanClassCode(String targetPackage, Class<?> beanClass) {
-		if (Modifier.isPublic(beanClass.getModifiers()) || targetPackage.equals(beanClass.getPackageName())) {
-			return CodeBlock.of("$T.class", beanClass);
-		}
-		else {
-			return CodeBlock.of("$S", beanClass.getName());
+	private CodeBlock generateBeanClassCode(String targetPackage, @Nullable Class<?> beanClass) {
+		if (beanClass != null) {
+			if (Modifier.isPublic(beanClass.getModifiers()) || targetPackage.equals(beanClass.getPackageName())) {
+				return CodeBlock.of("$T.class", beanClass);
+			}
+			else {
+				return CodeBlock.of("$S", beanClass.getName());
+			}
 		}
+		return CodeBlock.of("");
 	}

 	private CodeBlock generateBeanTypeCode(ResolvableType beanType) {
@@ -145,14 +147,11 @@ class DefaultBeanRegistrationCodeFragments implements BeanRegistrationCodeFragme
 	}

 	private boolean targetTypeNecessary(ResolvableType beanType, @Nullable Class<?> beanClass) {
-		if (beanType.hasGenerics()) {
+		if (beanType.hasGenerics() || beanClass == null) {
 			return true;
 		}
-		if (beanClass != null
-				&& this.registeredBean.getMergedBeanDefinition().getFactoryMethodName() != null) {
-			return true;
-		}
-		return (beanClass != null && !beanType.toClass().equals(beanClass));
+		return (!beanType.toClass().equals(beanClass)
+				|| this.registeredBean.getMergedBeanDefinition().getFactoryMethodName() != null);
 	}

 	@Override
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -92,10 +92,10 @@ import org.springframework.util.function.ThrowingSupplier;
 * Supports autowiring constructors, properties by name, and properties by type.
 *
 * <p>The main template method to be implemented by subclasses is
- * {@link #resolveDependency(DependencyDescriptor, String, Set, TypeConverter)}, used for
- * autowiring. In case of a {@link org.springframework.beans.factory.ListableBeanFactory}
- * which is capable of searching its bean definitions, matching beans will typically be
- * implemented through such a search. Otherwise, simplified matching can be implemented.
+ * {@link #resolveDependency(DependencyDescriptor, String, Set, TypeConverter)},
+ * used for autowiring by type. In case of a factory which is capable of searching
+ * its bean definitions, matching beans will typically be implemented through such
+ * a search. For other factory styles, simplified matching algorithms can be implemented.
 *
 * <p>Note that this class does <i>not</i> assume or implement bean definition
 * registry capabilities. See {@link DefaultListableBeanFactory} for an implementation
@@ -493,13 +493,15 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
 			mbdToUse = new RootBeanDefinition(mbd);
 			mbdToUse.setBeanClass(resolvedClass);
-			try {
-				mbdToUse.prepareMethodOverrides();
-			}
-			catch (BeanDefinitionValidationException ex) {
-				throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
-						beanName, "Validation of method overrides failed", ex);
-			}
+		}
+
+		// Prepare method overrides.
+		try {
+			mbdToUse.prepareMethodOverrides();
+		}
+		catch (BeanDefinitionValidationException ex) {
+			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
+					beanName, "Validation of method overrides failed", ex);
 		}

 		try {
@@ -650,7 +652,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 		// Apply SmartInstantiationAwareBeanPostProcessors to predict the
 		// eventual type after a before-instantiation shortcut.
 		if (targetType != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
-			boolean matchingOnlyFactoryBean = (typesToMatch.length == 1 && typesToMatch[0] == FactoryBean.class);
+			boolean matchingOnlyFactoryBean = typesToMatch.length == 1 && typesToMatch[0] == FactoryBean.class;
 			for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
 				Class<?> predicted = bp.predictBeanType(targetType, beanName);
 				if (predicted != null &&
@@ -818,11 +820,11 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 	/**
 	 * This implementation attempts to query the FactoryBean's generic parameter metadata
 	 * if present to determine the object type. If not present, i.e. the FactoryBean is
-	 * declared as a raw type, it checks the FactoryBean's {@code getObjectType} method
+	 * declared as a raw type, checks the FactoryBean's {@code getObjectType} method
 	 * on a plain instance of the FactoryBean, without bean properties applied yet.
-	 * If this doesn't return a type yet and {@code allowInit} is {@code true}, full
-	 * creation of the FactoryBean is attempted as fallback (through delegation to the
-	 * superclass implementation).
+	 * If this doesn't return a type yet, and {@code allowInit} is {@code true} a
+	 * full creation of the FactoryBean is used as fallback (through delegation to the
+	 * superclass's implementation).
 	 * <p>The shortcut check for a FactoryBean is only applied in case of a singleton
 	 * FactoryBean. If the FactoryBean instance itself is not kept as singleton,
 	 * it will be fully created to check the type of its exposed object.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -161,9 +161,6 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 	/** Map from scope identifier String to corresponding Scope. */
 	private final Map<String, Scope> scopes = new LinkedHashMap<>(8);

-	/** Application startup metrics. **/
-	private ApplicationStartup applicationStartup = ApplicationStartup.DEFAULT;
-
 	/** Map from bean name to merged RootBeanDefinition. */
 	private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);

@@ -174,6 +171,8 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 	private final ThreadLocal<Object> prototypesCurrentlyInCreation =
 			new NamedThreadLocal<>("Prototype beans currently in creation");

+	/** Application startup metrics. **/
+	private ApplicationStartup applicationStartup = ApplicationStartup.DEFAULT;

 	/**
 	 * Create a new AbstractBeanFactory.
@@ -732,7 +731,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 			aliases.add(fullBeanName);
 		}
 		String[] retrievedAliases = super.getAliases(beanName);
-		String prefix = (factoryPrefix ? FACTORY_BEAN_PREFIX : "");
+		String prefix = factoryPrefix ? FACTORY_BEAN_PREFIX : "";
 		for (String retrievedAlias : retrievedAliases) {
 			String alias = prefix + retrievedAlias;
 			if (!alias.equals(name)) {
@@ -1053,7 +1052,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp

 	@Override
 	public void setApplicationStartup(ApplicationStartup applicationStartup) {
-		Assert.notNull(applicationStartup, "ApplicationStartup must not be null");
+		Assert.notNull(applicationStartup, "applicationStartup must not be null");
 		this.applicationStartup = applicationStartup;
 	}

@@ -1498,11 +1497,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 			if (mbd.hasBeanClass()) {
 				return mbd.getBeanClass();
 			}
-			Class<?> beanClass = doResolveBeanClass(mbd, typesToMatch);
-			if (mbd.hasBeanClass()) {
-				mbd.prepareMethodOverrides();
-			}
-			return beanClass;
+			return doResolveBeanClass(mbd, typesToMatch);
 		}
 		catch (ClassNotFoundException ex) {
 			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
@@ -1510,10 +1505,6 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 		catch (LinkageError err) {
 			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
 		}
-		catch (BeanDefinitionValidationException ex) {
-			throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
-					beanName, "Validation of method overrides failed", ex);
-		}
 	}

 	@Nullable
@@ -1649,7 +1640,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 	 * already. The implementation is allowed to instantiate the target factory bean if
 	 * {@code allowInit} is {@code true} and the type cannot be determined another way;
 	 * otherwise it is restricted to introspecting signatures and related metadata.
-	 * <p>If no {@link FactoryBean#OBJECT_TYPE_ATTRIBUTE} is set on the bean definition
+	 * <p>If no {@link FactoryBean#OBJECT_TYPE_ATTRIBUTE} if set on the bean definition
 	 * and {@code allowInit} is {@code true}, the default implementation will create
 	 * the FactoryBean via {@code getBean} to call its {@code getObjectType} method.
 	 * Subclasses are encouraged to optimize this, typically by inspecting the generic
--- a/Show More
+++ b/Show More