Release v5.3.31

.github/actions/await-http-resource/action.yml

@@ -1,20 +0,0 @@
-name: Await HTTP Resource
-description: Waits for an HTTP resource to be available (a HEAD request succeeds)
-inputs:
-  url:
-    description: 'The URL of the resource to await'
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Await HTTP resource
-      shell: bash
-      run: |
-        url=${{ inputs.url }}
-        echo "Waiting for $url"
-        until curl --fail --head --silent ${{ inputs.url }} > /dev/null
-        do
-          echo "."
-          sleep 60
-        done
-        echo "$url is available"

.github/actions/build/action.yml

@@ -1,56 +0,0 @@
-name: 'Build'
-description: 'Builds the project, optionally publishing it to a local deployment repository'
-inputs:
-  java-version:
-    required: false
-    default: '8'
-    description: 'The Java version to compile and test with'
-  java-early-access:
-    required: false
-    default: 'false'
-    description: 'Whether the Java version is in early access'
-  java-toolchain:
-    required: false
-    default: 'false'
-    description: 'Whether a Java toolchain should be used'
-  publish:
-    required: false
-    default: 'false'
-    description: 'Whether to publish artifacts ready for deployment to Artifactory'
-  develocity-access-key:
-    required: false
-    description: 'The access key for authentication with ge.spring.io'
-outputs:
-  build-scan-url:
-    description: 'The URL, if any, of the build scan produced by the build'
-    value: ${{ (inputs.publish == 'true' && steps.publish.outputs.build-scan-url) || steps.build.outputs.build-scan-url }}
-  version:
-    description: 'The version that was built'
-    value: ${{ steps.read-version.outputs.version }}
-runs:
-  using: composite
-  steps:
-    - name: Prepare Gradle Build
-      uses: ./.github/actions/prepare-gradle-build
-      with:
-        develocity-access-key: ${{ inputs.develocity-access-key }}
-        java-version: ${{ inputs.java-version }}
-        java-early-access: ${{ inputs.java-early-access }}
-        java-toolchain: ${{ inputs.java-toolchain }}
-    - name: Build
-      id: build
-      if: ${{ inputs.publish == 'false' }}
-      shell: bash
-      run: ./gradlew check
-    - name: Publish
-      id: publish
-      if: ${{ inputs.publish == 'true' }}
-      shell: bash
-      run: ./gradlew -PdeploymentRepository=$(pwd)/deployment-repository build publishAllPublicationsToDeploymentRepository
-    - name: Read Version From gradle.properties
-      id: read-version
-      shell: bash
-      run: |
-        version=$(sed -n 's/version=\(.*\)/\1/p' gradle.properties)
-        echo "Version is $version"
-        echo "version=$version" >> $GITHUB_OUTPUT

.github/actions/create-github-release/action.yml

@@ -1,23 +0,0 @@
-name: Create GitHub Release
-description: Create the release on GitHub with a changelog
-inputs:
-  milestone:
-    description: Name of the GitHub milestone for which a release will be created
-    required: true
-  token:
-    description: Token to use for authentication with GitHub
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Generate Changelog
-      uses: spring-io/github-changelog-generator@185319ad7eaa75b0e8e72e4b6db19c8b2cb8c4c1 #v0.0.11
-      with:
-        milestone: ${{ inputs.milestone }}
-        token: ${{ inputs.token }}
-        config-file: .github/actions/create-github-release/changelog-generator.yml
-    - name: Create GitHub Release
-      env:
-        GITHUB_TOKEN: ${{ inputs.token }}
-      shell: bash
-      run: gh release create ${{ format('v{0}', inputs.milestone) }} --notes-file changelog.md

.github/actions/prepare-gradle-build/action.yml

@@ -1,49 +0,0 @@
-name: 'Prepare Gradle Build'
-description: 'Prepares a Gradle build. Sets up Java and Gradle and configures Gradle properties'
-inputs:
-  java-version:
-    required: false
-    default: '8'
-    description: 'The Java version to use for the build'
-  java-early-access:
-    required: false
-    default: 'false'
-    description: 'Whether the Java version is in early access'
-  java-toolchain:
-    required: false
-    default: 'false'
-    description: 'Whether a Java toolchain should be used'
-  develocity-access-key:
-    required: false
-    description: 'The access key for authentication with ge.spring.io'
-runs:
-  using: composite
-  steps:
-    - name: Set Up Java
-      uses: actions/setup-java@v4
-      with:
-        distribution: ${{ inputs.java-early-access == 'true' && 'temurin' || 'liberica' }}
-        java-version: |
-          ${{ inputs.java-early-access == 'true' && format('{0}-ea', inputs.java-version) || inputs.java-version }}
-          ${{ inputs.java-toolchain == 'true' && '8' || '' }}
-    - name: Set Up Gradle
-      uses: gradle/actions/setup-gradle@d9c87d481d55275bb5441eef3fe0e46805f9ef70 # v3.5.0
-      with:
-        cache-read-only: false
-        develocity-access-key: ${{ inputs.develocity-access-key }}
-    - 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: ${{ inputs.java-toolchain == 'true' }}
-      shell: bash
-      run: |
-        echo toolchainVersion=${{ inputs.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', inputs.java-version) }} >> $HOME/.gradle/gradle.properties

.github/actions/send-notification/action.yml

@@ -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

.github/actions/sync-to-maven-central/action.yml

@@ -1,43 +0,0 @@
-name: Sync to Maven Central
-description: Syncs a release to Maven Central and waits for it to be available for use
-inputs:
-  jfrog-cli-config-token:
-    description: 'Config token for the JFrog CLI'
-    required: true
-  spring-framework-version:
-    description: 'The version of Spring Framework that is being synced to Central'
-    required: true
-  ossrh-s01-token-username:
-    description: 'Username for authentication with s01.oss.sonatype.org'
-    required: true
-  ossrh-s01-token-password:
-    description: 'Password for authentication with s01.oss.sonatype.org'
-    required: true
-  ossrh-s01-staging-profile:
-    description: 'Staging profile to use when syncing to Central'
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Set Up JFrog CLI
-      uses: jfrog/setup-jfrog-cli@105617d23456a69a92485207c4f28ae12297581d # v4.2.1
-      env:
-        JF_ENV_SPRING: ${{ inputs.jfrog-cli-config-token }}
-    - name: Download Release Artifacts
-      shell: bash
-      run: jf rt download --spec ${{ format('{0}/artifacts.spec', github.action_path) }} --spec-vars 'buildName=${{ format('spring-framework-{0}', inputs.spring-framework-version) }};buildNumber=${{ github.run_number }}'
-    - name: Sync
-      uses: spring-io/nexus-sync-action@42477a2230a2f694f9eaa4643fa9e76b99b7ab84 # v0.0.1
-      with:
-        username: ${{ inputs.ossrh-s01-token-username }}
-        password: ${{ inputs.ossrh-s01-token-password }}
-        staging-profile-name: ${{ inputs.ossrh-s01-staging-profile }}
-        create: true
-        upload: true
-        close: true
-        release: true
-        generate-checksums: true
-    - name: Await
-      uses: ./.github/actions/await-http-resource
-      with:
-        url: ${{ format('https://repo.maven.apache.org/maven2/org/springframework/spring-context/{0}/spring-context-{0}.jar', inputs.spring-framework-version) }}

.github/actions/sync-to-maven-central/artifacts.spec

@@ -1,20 +0,0 @@
-{
-  "files": [
-    {
-      "aql": {
-        "items.find": {
-          "$and": [
-            {
-              "@build.name": "${buildName}",
-              "@build.number": "${buildNumber}",
-              "path": {
-                "$nmatch": "org/springframework/spring-*.zip"
-              }
-            }
-          ]
-        }
-      },
-      "target": "nexus/"
-    }
-  ]
-}

.github/workflows/backport-bot.yml

@@ -1,34 +0,0 @@
-name: Backport Bot
-
-on:
-  issues:
-    types: [labeled]
-  pull_request:
-    types: [labeled]
-  push:
-    branches:
-      - '*.x'
-permissions:
-  contents: read
-jobs:
-  build:
-    permissions:
-      contents: read
-      issues: write
-      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
-        with:
-          distribution: 'liberica'
-          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
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GITHUB_EVENT: ${{ toJSON(github.event) }}
-        run: java -jar backport-bot-0.0.1-SNAPSHOT.jar --github.accessToken="$GITHUB_TOKEN" --github.event_name "$GITHUB_EVENT_NAME" --github.event "$GITHUB_EVENT"

.github/workflows/build-and-deploy-snapshot.yml

@@ -1,59 +0,0 @@
-name: Build and Deploy Snapshot
-on:
-  push:
-    branches:
-      - 5.3.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  build-and-deploy-snapshot:
-    name: Build and Deploy Snapshot
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    steps:
-      - name: Check Out Code
-        uses: actions/checkout@v4
-      - name: Build and Publish
-        id: build-and-publish
-        uses: ./.github/actions/build
-        with:
-          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-          publish: true
-      - name: Deploy
-        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
-        with:
-          uri: 'https://repo.spring.io'
-          username: ${{ secrets.ARTIFACTORY_USERNAME }}
-          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-          build-name: 'spring-framework-5.3.x'
-          repository: 'libs-snapshot-local'
-          folder: 'deployment-repository'
-          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
-          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          artifact-properties: |
-            /**/spring-*.zip::zip.name=spring-framework,zip.deployed=false
-            /**/spring-*-docs.zip::zip.type=docs
-            /**/spring-*-dist.zip::zip.type=dist
-            /**/spring-*-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-and-publish.outputs.build-scan-url }}
-          run-name: ${{ format('{0} | Linux | Java 8', github.ref_name) }}
-    outputs:
-      version: ${{ steps.build-and-publish.outputs.version }}
-  verify:
-    name: Verify
-    needs: build-and-deploy-snapshot
-    uses: ./.github/workflows/verify.yml
-    secrets:
-      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
-      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
-    with:
-      version: ${{ needs.build-and-deploy-snapshot.outputs.version }}

.github/workflows/ci.yml

@@ -1,55 +0,0 @@
-name: CI
-on:
-  push:
-    branches:
-      - 5.3.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  ci:
-    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
-    runs-on: ${{ matrix.os.id }}
-    timeout-minutes: 60
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    strategy:
-      matrix:
-        os:
-          - id: ubuntu-latest
-            name: Linux
-        java:
-          - version: 8
-            toolchain: false
-          - version: 17
-            toolchain: true
-          - version: 21
-            toolchain: true
-        exclude:
-          - os:
-              name: Linux
-            java:
-              version: 8
-    steps:
-      - 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: Build
-        id: build
-        uses: ./.github/actions/build
-        with:
-          java-version: ${{ matrix.java.version }}
-          java-early-access: ${{ matrix.java.early-access || 'false' }}
-          java-toolchain: ${{ matrix.java.toolchain }}
-          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-      - 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) }}

.github/workflows/gradle-wrapper-validation.yml

@@ -0,0 +1,13 @@
+name: "Validate Gradle Wrapper"
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  validation:
+    name: "Validation"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: gradle/wrapper-validation-action@v1

.github/workflows/release.yml

@@ -1,95 +0,0 @@
-name: Release
-on:
-  push:
-    tags:
-      - v5.3.[0-9]+
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  build-and-stage-release:
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    name: Build and Stage Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check Out Code
-        uses: actions/checkout@v4
-      - name: Build and Publish
-        id: build-and-publish
-        uses: ./.github/actions/build
-        with:
-          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-          publish: true
-      - name: Stage Release
-        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
-        with:
-          uri: 'https://repo.spring.io'
-          username: ${{ secrets.ARTIFACTORY_USERNAME }}
-          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-          build-name: ${{ format('spring-framework-{0}', steps.build-and-publish.outputs.version)}}
-          repository: 'libs-staging-local'
-          folder: 'deployment-repository'
-          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
-          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          artifact-properties: |
-            /**/spring-*.zip::zip.name=spring-framework,zip.deployed=false
-            /**/spring-*-docs.zip::zip.type=docs
-            /**/spring-*-dist.zip::zip.type=dist
-            /**/spring-*-schema.zip::zip.type=schema
-    outputs:
-      version: ${{ steps.build-and-publish.outputs.version }}
-  verify:
-    name: Verify
-    needs: build-and-stage-release
-    uses: ./.github/workflows/verify.yml
-    with:
-      staging: true
-      version: ${{ needs.build-and-stage-release.outputs.version }}
-    secrets:
-      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
-      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
-  sync-to-maven-central:
-    name: Sync to Maven Central
-    needs:
-      - build-and-stage-release
-      - verify
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check Out Code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - name: Sync to Maven Central
-        uses: ./.github/actions/sync-to-maven-central
-        with:
-          jfrog-cli-config-token: ${{ secrets.JF_ARTIFACTORY_SPRING }}
-          ossrh-s01-staging-profile: ${{ secrets.OSSRH_S01_STAGING_PROFILE }}
-          ossrh-s01-token-password: ${{ secrets.OSSRH_S01_TOKEN_PASSWORD }}
-          ossrh-s01-token-username: ${{ secrets.OSSRH_S01_TOKEN_USERNAME }}
-          spring-framework-version: ${{ needs.build-and-stage-release.outputs.version }}
-  promote-release:
-    name: Promote Release
-    needs:
-      - build-and-stage-release
-      - sync-to-maven-central
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up JFrog CLI
-        uses: jfrog/setup-jfrog-cli@105617d23456a69a92485207c4f28ae12297581d # v4.2.1
-        env:
-          JF_ENV_SPRING: ${{ secrets.JF_ARTIFACTORY_SPRING }}
-      - name: Promote build
-        run: jfrog rt build-promote ${{ format('spring-framework-{0}', needs.build-and-stage-release.outputs.version)}} ${{ github.run_number }} libs-release-local
-  create-github-release:
-    name: Create GitHub Release
-    needs:
-      - build-and-stage-release
-      - promote-release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check Out Code
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-      - name: Create GitHub Release
-        uses: ./.github/actions/create-github-release
-        with:
-          milestone: ${{ needs.build-and-stage-release.outputs.version }}
-          token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}

.github/workflows/validate-gradle-wrapper.yml

@@ -1,11 +0,0 @@
-name: "Validate Gradle Wrapper"
-on: [push, pull_request]
-permissions:
-  contents: read
-jobs:
-  validation:
-    name: "Validate Gradle Wrapper"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: gradle/actions/wrapper-validation@d9c87d481d55275bb5441eef3fe0e46805f9ef70 # v3.5.0

.github/workflows/verify.yml

@@ -1,71 +0,0 @@
-name: Verify
-on:
-  workflow_call:
-    inputs:
-      version:
-        required: true
-        type: string
-      staging:
-        required: false
-        default: false
-        type: boolean
-    secrets:
-      repository-username:
-        required: false
-      repository-password:
-        required: false
-      google-chat-webhook-url:
-        required: true
-      token:
-        required: true
-jobs:
-  verify:
-    name: Verify
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check Out Release Verification Tests
-        uses: actions/checkout@v4
-        with:
-          repository: spring-projects/spring-framework-release-verification
-          ref: 'v0.0.2'
-          token: ${{ secrets.token }}
-      - name: Check Out Send Notification Action
-        uses: actions/checkout@v4
-        with:
-          path: spring-framework
-          sparse-checkout: .github/actions/send-notification
-      - name: Set Up Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: 8
-      - name: Set Up Gradle
-        uses: gradle/actions/setup-gradle@dbbdc275be76ac10734476cc723d82dfe7ec6eda # v3.4.2
-        with:
-          cache-read-only: false
-      - name: Configure Gradle Properties
-        shell: bash
-        run: |
-          mkdir -p $HOME/.gradle
-          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
-      - name: Run Release Verification Tests
-        env:
-          RVT_VERSION: ${{ inputs.version }}
-          RVT_RELEASE_TYPE: oss
-          RVT_STAGING: ${{ inputs.staging }}
-          RVT_OSS_REPOSITORY_USERNAME: ${{ secrets.repository-username }}
-          RVT_OSS_REPOSITORY_PASSWORD: ${{ secrets.repository-password }}
-        run: ./gradlew spring-framework-release-verification-tests:test
-      - name: Upload Build Reports on Failure
-        uses: actions/upload-artifact@v4
-        if: failure()
-        with:
-          name: build-reports
-          path: '**/build/reports/'
-      - name: Send Notification
-        uses: ./spring-framework/.github/actions/send-notification
-        if: failure()
-        with:
-          webhook-url: ${{ secrets.google-chat-webhook-url }}
-          status: ${{ job.status }}
-          run-name: ${{ format('{0} | Verification | {1}', github.ref_name, inputs.version) }}

README.md

@@ -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=5.3.x)](https://github.com/spring-projects/spring-framework/actions/workflows/build-and-deploy-snapshot.yml?query=branch%3A5.3.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="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-5.3.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-5.3.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". 
 

build.gradle

@@ -28,11 +28,11 @@ configure(allprojects) { project ->
 	dependencyManagement {
 		imports {
 			mavenBom "com.fasterxml.jackson:jackson-bom:2.12.7"
-			mavenBom "io.netty:netty-bom:4.1.112.Final"
-			mavenBom "io.projectreactor:reactor-bom:2020.0.47"
+			mavenBom "io.netty:netty-bom:4.1.101.Final"
+			mavenBom "io.projectreactor:reactor-bom:2020.0.38"
 			mavenBom "io.r2dbc:r2dbc-bom:Arabba-SR13"
 			mavenBom "io.rsocket:rsocket-bom:1.1.3"
-			mavenBom "org.eclipse.jetty:jetty-bom:9.4.54.v20240208"
+			mavenBom "org.eclipse.jetty:jetty-bom:9.4.53.v20231009"
 			mavenBom "org.jetbrains.kotlin:kotlin-bom:1.5.32"
 			mavenBom "org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.5.2"
 			mavenBom "org.jetbrains.kotlinx:kotlinx-serialization-bom:1.2.2"
@@ -139,7 +139,7 @@ configure(allprojects) { project ->
 				entry 'tomcat-embed-core'
 				entry 'tomcat-embed-websocket'
 			}
-			dependencySet(group: 'io.undertow', version: '2.2.29.Final') {
+			dependencySet(group: 'io.undertow', version: '2.2.28.Final') {
 				entry 'undertow-core'
 				entry('undertow-servlet') {
 					exclude group: "org.jboss.spec.javax.servlet", name: "jboss-servlet-api_4.0_spec"
@@ -340,7 +340,7 @@ configure([rootProject] + javaProjects) { project ->
 	}
 
 	checkstyle {
-		toolVersion = "10.12.7"
+		toolVersion = "10.12.5"
 		configDirectory.set(rootProject.file("src/checkstyle"))
 	}
 
@@ -362,7 +362,7 @@ 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.42")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.31")
 	}
 
 	ext.javadocLinks = [
@@ -375,9 +375,8 @@ configure([rootProject] + javaProjects) { project ->
 			"https://tiles.apache.org/tiles-request/apidocs/",
 			"https://tiles.apache.org/framework/apidocs/",
 			"https://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
-			// Temporarily commenting out Ehcache and Quartz since javadoc on JDK 8 cannot access them.
-			// "https://www.ehcache.org/apidocs/2.10.4/",
-			// "https://www.quartz-scheduler.org/api/2.3.0/",
+			"https://www.ehcache.org/apidocs/2.10.4/",
+			"https://www.quartz-scheduler.org/api/2.3.0/",
 			"https://www.javadoc.io/doc/com.fasterxml.jackson.core/jackson-core/2.12.7/",
 			"https://www.javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.12.7/",
 			"https://www.javadoc.io/doc/com.fasterxml.jackson.dataformat/jackson-dataformat-xml/2.12.7/",
@@ -389,8 +388,7 @@ configure([rootProject] + javaProjects) { project ->
 			// "https://junit.org/junit5/docs/5.8.2/api/",
 			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
-			// Temporarily commenting out R2DBC since javadoc on JDK 8 cannot access it.
-			// "https://r2dbc.io/spec/0.8.5.RELEASE/api/",
+			"https://r2dbc.io/spec/0.8.5.RELEASE/api/",
 			// The external Javadoc link for JSR 305 must come last to ensure that types from
 			// JSR 250 (such as @PostConstruct) are still supported. This is due to the fact
 			// that JSR 250 and JSR 305 both define types in javax.annotation, which results

ci/README.adoc

@@ -0,0 +1,57 @@
+== Spring Framework Concourse pipeline
+
+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-5.3.x[Spring Framework 5.3.x].
+
+=== Setting up your development environment
+
+If you're part of the Spring Framework project on GitHub, you can get access to CI management features.
+First, you need to go to https://ci.spring.io and install the client CLI for your platform (see bottom right of the screen).
+
+You can then login with the instance using:
+
+[source]
+----
+$ fly -t spring login -n spring-framework -c https://ci.spring.io
+----
+
+Once logged in, you should get something like:
+
+[source]
+----
+$ fly ts
+name                  url                   team                  expiry
+spring                https://ci.spring.io  spring-framework      Wed, 25 Mar 2020 17:45:26 UTC
+----
+
+=== Pipeline configuration and structure
+
+The build pipelines are described in `pipeline.yml` file.
+
+This file is listing Concourse resources, i.e. build inputs and outputs such as container images, artifact repositories, source repositories, notification services, etc.
+
+It also describes jobs (a job is a sequence of inputs, tasks and outputs); jobs are organized by groups.
+
+The `pipeline.yml` definition contains `((parameters))` which are loaded from the `parameters.yml` file or from our https://docs.cloudfoundry.org/credhub/[credhub instance].
+
+You'll find in this folder the following resources:
+
+* `pipeline.yml` the build pipeline
+* `parameters.yml` the build parameters used for the pipeline
+* `images/` holds the container images definitions used in this pipeline
+* `scripts/` holds the build scripts that ship within the CI container images
+* `tasks` contains the task definitions used in the main `pipeline.yml`
+
+=== Updating the build pipeline
+
+Updating files on the repository is not enough to update the build pipeline, as changes need to be applied.
+
+The pipeline can be deployed using the following command:
+
+[source]
+----
+$ fly -t spring set-pipeline -p spring-framework-5.3.x -c ci/pipeline.yml -l ci/parameters.yml
+----
+
+NOTE: This assumes that you have credhub integration configured with the appropriate secrets.

ci/config/changelog-generator.yml

@@ -17,12 +17,4 @@ changelog:
         - "type: dependency-upgrade"
   contributors:
     exclude:
-      names:
-        - "bclozel"
-        - "jhoeller"
-        - "poutsma"
-        - "rstoyanchev"
-        - "sbrannen"
-        - "sdeleuze"
-        - "simonbasle"
-        - "snicoll"
+      names: ["bclozel", "jhoeller", "poutsma", "rstoyanchev", "sbrannen", "sdeleuze", "snicoll"]

ci/config/release-scripts.yml

@@ -0,0 +1,10 @@
+logging:
+  level:
+    io.spring.concourse: DEBUG
+spring:
+  main:
+    banner-mode: off
+sonatype:
+  exclude:
+    - 'build-info\.json'
+    - '.*\.zip'

ci/images/README.adoc

@@ -0,0 +1,21 @@
+== CI Images
+
+These images are used by CI to run the actual builds.
+
+To build the image locally run the following from this directory:
+
+----
+$ docker build --no-cache -f <image-folder>/Dockerfile .
+----
+
+For example
+
+----
+$ docker build --no-cache -f spring-framework-ci-image/Dockerfile .
+----
+
+To test run:
+
+----
+$ docker run -it --entrypoint /bin/bash <SHA>
+----

ci/images/ci-image/Dockerfile

@@ -0,0 +1,10 @@
+FROM ubuntu:jammy-20230624
+
+ADD setup.sh /setup.sh
+ADD get-jdk-url.sh /get-jdk-url.sh
+RUN ./setup.sh java8
+
+ENV JAVA_HOME /opt/openjdk/java8
+ENV JDK17 /opt/openjdk/java17
+
+ENV PATH $JAVA_HOME/bin:$PATH

ci/images/get-jdk-url.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+set -e
+
+case "$1" in
+	java8)
+		 echo "https://github.com/bell-sw/Liberica/releases/download/8u372+7/bellsoft-jdk8u372+7-linux-amd64.tar.gz"
+	;;
+	java17)
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.7+7/bellsoft-jdk17.0.7+7-linux-amd64.tar.gz"
+	;;
+	*)
+		echo $"Unknown java version"
+		exit 1
+esac

ci/images/setup.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+set -ex
+
+###########################################################
+# UTILS
+###########################################################
+
+export DEBIAN_FRONTEND=noninteractive
+apt-get update
+apt-get install --no-install-recommends -y tzdata ca-certificates net-tools libxml2-utils git curl libudev1 libxml2-utils iptables iproute2 jq fontconfig
+ln -fs /usr/share/zoneinfo/UTC /etc/localtime
+dpkg-reconfigure --frontend noninteractive tzdata
+rm -rf /var/lib/apt/lists/*
+
+curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/concourse-java.sh > /opt/concourse-java.sh
+
+###########################################################
+# JAVA
+###########################################################
+
+mkdir -p /opt/openjdk
+pushd /opt/openjdk > /dev/null
+for jdk in java8 java17
+do
+  JDK_URL=$( /get-jdk-url.sh $jdk )
+  mkdir $jdk
+  pushd $jdk > /dev/null
+  curl -L ${JDK_URL} | tar zx --strip-components=1
+  test -f bin/java
+  test -f bin/javac
+  popd > /dev/null
+done
+popd
+
+###########################################################
+# GRADLE ENTERPRISE
+###########################################################
+cd /
+mkdir ~/.gradle
+echo 'systemProp.user.name=concourse' > ~/.gradle/gradle.properties

ci/parameters.yml

@@ -0,0 +1,11 @@
+github-repo: "https://github.com/spring-projects/spring-framework.git"
+github-repo-name: "spring-projects/spring-framework"
+sonatype-staging-profile: "org.springframework"
+docker-hub-organization: "springci"
+artifactory-server: "https://repo.spring.io"
+branch: "5.3.x"
+milestone: "5.3.x"
+build-name: "spring-framework"
+pipeline-name: "spring-framework"
+concourse-url: "https://ci.spring.io"
+task-timeout: 1h00m

ci/pipeline.yml

@@ -0,0 +1,399 @@
+anchors:
+  git-repo-resource-source: &git-repo-resource-source
+    uri: ((github-repo))
+    username: ((github-username))
+    password: ((github-ci-release-token))
+    branch: ((branch))
+  gradle-enterprise-task-params: &gradle-enterprise-task-params
+    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))
+    SONATYPE_URL: ((sonatype-url))
+    SONATYPE_STAGING_PROFILE: ((sonatype-staging-profile))
+  artifactory-task-params: &artifactory-task-params
+    ARTIFACTORY_SERVER: ((artifactory-server))
+    ARTIFACTORY_USERNAME: ((artifactory-username))
+    ARTIFACTORY_PASSWORD: ((artifactory-password))
+  build-project-task-params: &build-project-task-params
+      BRANCH: ((branch))
+      <<: *gradle-enterprise-task-params
+  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
+    body: generated-changelog/changelog.md
+  github-task-params: &github-task-params
+    GITHUB_USERNAME: ((github-username))
+    GITHUB_TOKEN: ((github-ci-release-token))
+
+resource_types:
+- name: registry-image
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: concourse/registry-image-resource
+    tag: 1.7.1
+- name: artifactory-resource
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: springio/artifactory-resource
+    tag: 0.0.18
+- name: github-release
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: concourse/github-release-resource
+    tag: 1.8.0
+- 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
+  icon: github
+  source:
+    <<: *git-repo-resource-source
+- name: every-morning
+  type: time
+  icon: alarm
+  source:
+    start: 8:00 AM
+    stop: 9:00 AM
+    location: Europe/Vienna
+- name: ci-images-git-repo
+  type: git
+  icon: github
+  source:
+    uri: ((github-repo))
+    branch: ((branch))
+    paths: ["ci/images/*"]
+- name: ci-image
+  type: registry-image
+  icon: docker
+  source:
+    <<: *docker-resource-source
+    repository: ((docker-hub-organization))/spring-framework-ci
+    tag: ((milestone))
+- name: artifactory-repo
+  type: artifactory-resource
+  icon: package-variant
+  source:
+    uri: ((artifactory-server))
+    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-jdk17-build
+  type: github-status-resource
+  icon: eye-check-outline
+  source:
+    repository: ((github-repo-name))
+    access_token: ((github-ci-status-token))
+    branch: ((branch))
+    context: jdk17-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
+  source:
+    owner: spring-projects
+    repository: spring-framework
+    access_token: ((github-ci-release-token))
+    pre_release: true
+    release: false
+- name: github-release
+  type: github-release
+  icon: briefcase-download
+  source:
+    owner: spring-projects
+    repository: spring-framework
+    access_token: ((github-ci-release-token))
+    pre_release: false
+jobs:
+- name: build-ci-images
+  plan:
+    - get: git-repo
+    - get: ci-images-git-repo
+      trigger: true
+    - task: build-ci-image
+      privileged: true
+      file: git-repo/ci/tasks/build-ci-image.yml
+      output_mapping:
+        image: ci-image
+      vars:
+        ci-image-name: ci-image
+        <<: *docker-resource-source
+    - put: ci-image
+      params:
+        image: ci-image/image.tar
+- name: build
+  serial: true
+  public: true
+  plan:
+  - get: ci-image
+  - get: git-repo
+    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-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}"
+      disable_checksum_uploads: true
+      threads: 8
+      artifact_set:
+      - include:
+        - "/**/spring-*.zip"
+        properties:
+          "zip.name": "spring-framework"
+          "zip.displayname": "Spring Framework"
+          "zip.deployed": "false"
+      - include:
+        - "/**/spring-*-docs.zip"
+        properties:
+          "zip.type": "docs"
+      - include:
+        - "/**/spring-*-dist.zip"
+        properties:
+          "zip.type": "dist"
+      - include:
+        - "/**/spring-*-schema.zip"
+        properties:
+          "zip.type": "schema"
+    get_params:
+      threads: 8
+- name: jdk17-build
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: every-morning
+      trigger: true
+    - put: repo-status-jdk17-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: 17
+          <<: *build-project-task-params
+      on_failure:
+        do:
+          - put: repo-status-jdk17-build
+            params: { state: "failure", commit: "git-repo" }
+          - put: slack-alert
+            params:
+              <<: *slack-fail-params
+    - put: repo-status-jdk17-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:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - get: artifactory-repo
+      trigger: false
+      passed: [stage-milestone]
+      params:
+        download_artifacts: false
+        save_build_info: true
+    - task: promote
+      file: git-repo/ci/tasks/promote-version.yml
+      params:
+        RELEASE_TYPE: M
+        <<: *artifactory-task-params
+    - task: generate-changelog
+      file: git-repo/ci/tasks/generate-changelog.yml
+      params:
+        RELEASE_TYPE: M
+        <<: *github-task-params
+    - put: github-pre-release
+      params:
+        <<: *changelog-task-params
+- name: stage-rc
+  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: RC
+        <<: *gradle-enterprise-task-params
+    - put: artifactory-repo
+      params:
+        <<: *artifactory-params
+        repo: libs-staging-local
+    - put: git-repo
+      params:
+        repository: stage-git-repo
+- name: promote-rc
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - get: artifactory-repo
+      trigger: false
+      passed: [stage-rc]
+      params:
+        download_artifacts: false
+        save_build_info: true
+    - task: promote
+      file: git-repo/ci/tasks/promote-version.yml
+      params:
+        RELEASE_TYPE: RC
+        <<: *artifactory-task-params
+    - task: generate-changelog
+      file: git-repo/ci/tasks/generate-changelog.yml
+      params:
+        RELEASE_TYPE: RC
+        <<: *github-task-params
+    - put: github-pre-release
+      params:
+        <<: *changelog-task-params
+- name: stage-release
+  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: RELEASE
+        <<: *gradle-enterprise-task-params
+    - put: artifactory-repo
+      params:
+        <<: *artifactory-params
+        repo: libs-staging-local
+    - put: git-repo
+      params:
+        repository: stage-git-repo
+- name: promote-release
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - get: artifactory-repo
+      trigger: false
+      passed: [stage-release]
+      params:
+        download_artifacts: true
+        save_build_info: true
+    - task: promote
+      file: git-repo/ci/tasks/promote-version.yml
+      params:
+        RELEASE_TYPE: RELEASE
+        <<: *artifactory-task-params
+        <<: *sonatype-task-params
+- name: create-github-release
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: artifactory-repo
+      trigger: true
+      passed: [promote-release]
+      params:
+        download_artifacts: false
+        save_build_info: true
+    - task: generate-changelog
+      file: git-repo/ci/tasks/generate-changelog.yml
+      params:
+        RELEASE_TYPE: RELEASE
+        <<: *github-task-params
+    - put: github-release
+      params:
+        <<: *changelog-task-params
+
+groups:
+- name: "builds"
+  jobs: ["build", "jdk17-build"]
+- name: "releases"
+  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
+- name: "ci-images"
+  jobs: ["build-ci-images"]

ci/scripts/build-pr.sh

@@ -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

ci/scripts/build-project.sh

@@ -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

ci/scripts/check-project.sh

@@ -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 \
+  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check
+popd > /dev/null

ci/scripts/common.sh

@@ -0,0 +1,2 @@
+source /opt/concourse-java.sh
+setup_symlinks

ci/scripts/generate-changelog.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+CONFIG_DIR=git-repo/ci/config
+version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
+
+java -jar /github-changelog-generator.jar \
+  --spring.config.location=${CONFIG_DIR}/changelog-generator.yml \
+  ${version} generated-changelog/changelog.md
+
+echo ${version} > generated-changelog/version
+echo v${version} > generated-changelog/tag

ci/scripts/promote-version.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+source $(dirname $0)/common.sh
+CONFIG_DIR=git-repo/ci/config
+
+version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
+export BUILD_INFO_LOCATION=$(pwd)/artifactory-repo/build-info.json
+
+java -jar /concourse-release-scripts.jar \
+  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
+  publishToCentral $RELEASE_TYPE $BUILD_INFO_LOCATION artifactory-repo || { exit 1; }
+
+java -jar /concourse-release-scripts.jar \
+  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
+  promote $RELEASE_TYPE $BUILD_INFO_LOCATION || { exit 1; }
+
+echo "Promotion complete"
+echo $version > version/version

ci/scripts/stage-version.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+repository=$(pwd)/distribution-repository
+
+pushd git-repo > /dev/null
+git fetch --tags --all > /dev/null
+popd > /dev/null
+
+git clone git-repo stage-git-repo > /dev/null
+
+pushd stage-git-repo > /dev/null
+
+snapshotVersion=$( awk -F '=' '$1 == "version" { print $2 }' gradle.properties )
+if [[ $RELEASE_TYPE = "M" ]]; then
+	stageVersion=$( get_next_milestone_release $snapshotVersion)
+	nextVersion=$snapshotVersion
+elif [[ $RELEASE_TYPE = "RC" ]]; then
+	stageVersion=$( get_next_rc_release $snapshotVersion)
+	nextVersion=$snapshotVersion
+elif [[ $RELEASE_TYPE = "RELEASE" ]]; then
+	stageVersion=$( get_next_release $snapshotVersion)
+	nextVersion=$( bump_version_number $snapshotVersion)
+else
+	echo "Unknown release type $RELEASE_TYPE" >&2; exit 1;
+fi
+
+echo "Staging $stageVersion (next version will be $nextVersion)"
+sed -i "s/version=$snapshotVersion/version=$stageVersion/" gradle.properties
+
+git config user.name "Spring Builds" > /dev/null
+git config user.email "spring-builds@users.noreply.github.com" > /dev/null
+git add gradle.properties > /dev/null
+git commit -m"Release v$stageVersion" > /dev/null
+git tag -a "v$stageVersion" -m"Release v$stageVersion" > /dev/null
+
+./gradlew --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
+
+git reset --hard HEAD^ > /dev/null
+if [[ $nextVersion != $snapshotVersion ]]; then
+	echo "Setting next development version (v$nextVersion)"
+	sed -i "s/version=$snapshotVersion/version=$nextVersion/" gradle.properties
+	git add gradle.properties > /dev/null
+	git commit -m"Next development version (v$nextVersion)" > /dev/null
+fi;
+
+echo "Staging Complete"
+
+popd > /dev/null

ci/tasks/build-ci-image.yml

@@ -0,0 +1,29 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: concourse/oci-build-task
+    tag: 0.10.0
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+inputs:
+  - name: ci-images-git-repo
+outputs:
+  - name: image
+caches:
+  - path: ci-image-cache
+params:
+  CONTEXT: ci-images-git-repo/ci/images
+  DOCKERFILE: ci-images-git-repo/ci/images/ci-image/Dockerfile
+  DOCKER_HUB_AUTH: ((docker-hub-auth))
+run:
+  path: /bin/sh
+  args:
+    - "-c"
+    - |
+      mkdir -p /root/.docker
+      cat > /root/.docker/config.json <<EOF
+      { "auths": { "https://index.docker.io/v1/": { "auth": "$DOCKER_HUB_AUTH" }}}
+      EOF
+      build

ci/tasks/build-pr.yml

@@ -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

ci/tasks/build-project.yml

@@ -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

ci/tasks/check-project.yml

@@ -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

ci/tasks/generate-changelog.yml

@@ -0,0 +1,22 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: springio/github-changelog-generator
+    tag: '0.0.7'
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+inputs:
+- name: git-repo
+- name: artifactory-repo
+outputs:
+- name: generated-changelog
+params:
+  GITHUB_ORGANIZATION:
+  GITHUB_REPO:
+  GITHUB_USERNAME:
+  GITHUB_TOKEN:
+  RELEASE_TYPE:
+run:
+  path: git-repo/ci/scripts/generate-changelog.sh

ci/tasks/promote-version.yml

@@ -0,0 +1,25 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: springio/concourse-release-scripts
+    tag: '0.3.4'
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+inputs:
+- name: git-repo
+- name: artifactory-repo
+outputs:
+- name: version
+params:
+  RELEASE_TYPE:
+  ARTIFACTORY_SERVER:
+  ARTIFACTORY_USERNAME:
+  ARTIFACTORY_PASSWORD:
+  SONATYPE_USER:
+  SONATYPE_PASSWORD:
+  SONATYPE_URL:
+  SONATYPE_STAGING_PROFILE:
+run:
+  path: git-repo/ci/scripts/promote-version.sh

ci/tasks/stage-version.yml

@@ -0,0 +1,17 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+outputs:
+- name: stage-git-repo
+- name: distribution-repository
+params:
+  RELEASE_TYPE:
+  CI: true
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+caches:
+- path: gradle
+run:
+  path: git-repo/ci/scripts/stage-version.sh

gradle.properties

@@ -1,4 +1,4 @@
-version=5.3.39
+version=5.3.31
 org.gradle.jvmargs=-Xmx2048m
 org.gradle.caching=true
 org.gradle.parallel=true

gradle/docs-dokka.gradle

@@ -5,7 +5,7 @@ tasks.findByName("dokkaHtmlPartial")?.configure {
 			sourceRoots.setFrom(file("src/main/kotlin"))
 			classpath.from(sourceSets["main"].runtimeClasspath)
 			externalDocumentationLink {
-				url.set(new URL("https://docs.spring.io/spring-framework/docs/5.3.x/javadoc-api/"))
+				url.set(new URL("https://docs.spring.io/spring-framework/docs/current/javadoc-api/"))
 			}
 			externalDocumentationLink {
 				url.set(new URL("https://projectreactor.io/docs/core/release/api/"))

integration-tests/src/test/java/org/springframework/cache/annotation/EnableCachingIntegrationTests.java

@@ -63,7 +63,7 @@ class EnableCachingIntegrationTests {
 		// attempt was made to look up the AJ aspect. It's due to classpath issues
 		// in .integration-tests that it's not found.
 		assertThatException().isThrownBy(ctx::refresh)
-				.withMessageContaining("AspectJCachingConfiguration");
+			.withMessageContaining("AspectJCachingConfiguration");
 	}
 
 

integration-tests/src/test/java/org/springframework/core/env/EnvironmentSystemIntegrationTests.java

@@ -561,7 +561,8 @@ public class EnvironmentSystemIntegrationTests {
 		{
 			ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
 			ctx.getEnvironment().setRequiredProperties("foo", "bar");
-			assertThatExceptionOfType(MissingRequiredPropertiesException.class).isThrownBy(ctx::refresh);
+			assertThatExceptionOfType(MissingRequiredPropertiesException.class).isThrownBy(
+					ctx::refresh);
 		}
 
 		{

integration-tests/src/test/java/org/springframework/transaction/annotation/EnableTransactionManagementIntegrationTests.java

@@ -97,7 +97,7 @@ class EnableTransactionManagementIntegrationTests {
 		ctx.register(Config.class, AspectJTxConfig.class);
 		// this test is a bit fragile, but gets the job done, proving that an
 		// attempt was made to look up the AJ aspect. It's due to classpath issues
-		// in integration-tests that it's not found.
+		// in .integration-tests that it's not found.
 		assertThatException()
 			.isThrownBy(ctx::refresh)
 			.withMessageContaining("AspectJJtaTransactionManagementConfiguration");

settings.gradle

@@ -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.1"
+	id "io.spring.ge.conventions" version "0.0.13"
 }
 
 include "spring-aop"
@@ -42,7 +42,7 @@ rootProject.children.each {project ->
 }
 
 settings.gradle.projectsLoaded {
-	develocity {
+	gradleEnterprise {
 		buildScan {
 			File buildDir = settings.gradle.rootProject.getBuildDir()
 			buildDir.mkdirs()

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

@@ -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,7 +18,6 @@ package org.springframework.aop.aspectj;
 
 import java.io.IOException;
 import java.io.ObjectInputStream;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.Arrays;
@@ -43,7 +42,6 @@ import org.aspectj.weaver.tools.PointcutParameter;
 import org.aspectj.weaver.tools.PointcutParser;
 import org.aspectj.weaver.tools.PointcutPrimitive;
 import org.aspectj.weaver.tools.ShadowMatch;
-import org.aspectj.weaver.tools.UnsupportedPointcutPrimitiveException;
 
 import org.springframework.aop.ClassFilter;
 import org.springframework.aop.IntroductionAwareMethodMatcher;
@@ -87,8 +85,6 @@ import org.springframework.util.StringUtils;
 public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {
 
-	private static final String AJC_MAGIC = "ajc$";
-
 	private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<>();
 
 	static {
@@ -110,8 +106,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	@Nullable
 	private Class<?> pointcutDeclarationScope;
 
-	private boolean aspectCompiledByAjc;
-
 	private String[] pointcutParameterNames = new String[0];
 
 	private Class<?>[] pointcutParameterTypes = new Class<?>[0];
@@ -125,8 +119,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	@Nullable
 	private transient PointcutExpression pointcutExpression;
 
-	private transient boolean pointcutParsingFailed = false;
-
 	private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap<>(32);
 
 
@@ -143,7 +135,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * @param paramTypes the parameter types for the pointcut
 	 */
 	public AspectJExpressionPointcut(Class<?> declarationScope, String[] paramNames, Class<?>[] paramTypes) {
-		setPointcutDeclarationScope(declarationScope);
+		this.pointcutDeclarationScope = declarationScope;
 		if (paramNames.length != paramTypes.length) {
 			throw new IllegalStateException(
 					"Number of pointcut parameter names must match number of pointcut parameter types");
@@ -158,7 +150,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 */
 	public void setPointcutDeclarationScope(Class<?> pointcutDeclarationScope) {
 		this.pointcutDeclarationScope = pointcutDeclarationScope;
-		this.aspectCompiledByAjc = compiledByAjc(pointcutDeclarationScope);
 	}
 
 	/**
@@ -183,30 +174,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);
@@ -283,18 +269,10 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 	@Override
 	public boolean matches(Class<?> targetClass) {
-		if (this.pointcutParsingFailed) {
-			// Pointcut parsing failed before below -> avoid trying again.
-			return false;
-		}
-		if (this.aspectCompiledByAjc && compiledByAjc(targetClass)) {
-			// ajc-compiled aspect class for ajc-compiled target class -> already weaved.
-			return false;
-		}
-
+		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);
@@ -305,12 +283,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 				}
 			}
 		}
-		catch (IllegalArgumentException | IllegalStateException | UnsupportedPointcutPrimitiveException ex) {
-			this.pointcutParsingFailed = true;
-			if (logger.isDebugEnabled()) {
-				logger.debug("Pointcut parser rejected expression [" + getExpression() + "]: " + ex);
-			}
-		}
 		catch (Throwable ex) {
 			logger.debug("PointcutExpression matching rejected target class", ex);
 		}
@@ -319,6 +291,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
@@ -356,6 +329,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,
@@ -543,16 +517,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		return shadowMatch;
 	}
 
-	private static boolean compiledByAjc(Class<?> clazz) {
-		for (Field field : clazz.getDeclaredFields()) {
-			if (field.getName().startsWith(AJC_MAGIC)) {
-				return true;
-			}
-		}
-		Class<?> superclass = clazz.getSuperclass();
-		return (superclass != null && compiledByAjc(superclass));
-	}
-
 
 	@Override
 	public boolean equals(@Nullable Object other) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 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.lang.reflect.Modifier;
 import java.util.HashMap;
@@ -56,6 +57,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};
 
@@ -66,11 +69,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 {
 		// If the parent has the annotation and isn't abstract it's an error
@@ -95,7 +124,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...).
@@ -135,7 +163,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 
 
 	/**
-	 * Class modeling an AspectJ annotation, exposing its type enumeration and
+	 * Class modelling an AspectJ annotation, exposing its type enumeration and
 	 * pointcut String.
 	 * @param <A> the annotation type
 	 */

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

@@ -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.
@@ -126,16 +126,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);
 	}
 
 

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/BeanFactoryAspectJAdvisorsBuilder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -22,12 +22,9 @@ import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 import org.aspectj.lang.reflect.PerClauseKind;
 
 import org.springframework.aop.Advisor;
-import org.springframework.aop.framework.AopConfigException;
 import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.beans.factory.ListableBeanFactory;
 import org.springframework.lang.Nullable;
@@ -43,8 +40,6 @@ import org.springframework.util.Assert;
  */
 public class BeanFactoryAspectJAdvisorsBuilder {
 
-	private static final Log logger = LogFactory.getLog(BeanFactoryAspectJAdvisorsBuilder.class);
-
 	private final ListableBeanFactory beanFactory;
 
 	private final AspectJAdvisorFactory advisorFactory;
@@ -107,37 +102,30 @@ public class BeanFactoryAspectJAdvisorsBuilder {
 							continue;
 						}
 						if (this.advisorFactory.isAspect(beanType)) {
-							try {
-								AspectMetadata amd = new AspectMetadata(beanType, beanName);
-								if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
-									MetadataAwareAspectInstanceFactory factory =
-											new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
-									List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
-									if (this.beanFactory.isSingleton(beanName)) {
-										this.advisorsCache.put(beanName, classAdvisors);
-									}
-									else {
-										this.aspectFactoryCache.put(beanName, factory);
-									}
-									advisors.addAll(classAdvisors);
+							aspectNames.add(beanName);
+							AspectMetadata amd = new AspectMetadata(beanType, beanName);
+							if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
+								MetadataAwareAspectInstanceFactory factory =
+										new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
+								List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
+								if (this.beanFactory.isSingleton(beanName)) {
+									this.advisorsCache.put(beanName, classAdvisors);
 								}
 								else {
-									// Per target or per this.
-									if (this.beanFactory.isSingleton(beanName)) {
-										throw new IllegalArgumentException("Bean with name '" + beanName +
-												"' is a singleton, but aspect instantiation model is not singleton");
-									}
-									MetadataAwareAspectInstanceFactory factory =
-											new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
 									this.aspectFactoryCache.put(beanName, factory);
-									advisors.addAll(this.advisorFactory.getAdvisors(factory));
 								}
-								aspectNames.add(beanName);
+								advisors.addAll(classAdvisors);
 							}
-							catch (IllegalArgumentException | IllegalStateException | AopConfigException ex) {
-								if (logger.isDebugEnabled()) {
-									logger.debug("Ignoring incompatible aspect [" + beanType.getName() + "]: " + ex);
+							else {
+								// Per target or per this.
+								if (this.beanFactory.isSingleton(beanName)) {
+									throw new IllegalArgumentException("Bean with name '" + beanName +
+											"' is a singleton, but aspect instantiation model is not singleton");
 								}
+								MetadataAwareAspectInstanceFactory factory =
+										new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
+								this.aspectFactoryCache.put(beanName, factory);
+								advisors.addAll(this.advisorFactory.getAdvisors(factory));
 							}
 						}
 					}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2018 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.
@@ -35,8 +35,7 @@ import org.springframework.lang.Nullable;
 
 /**
  * Internal implementation of AspectJPointcutAdvisor.
- *
- * <p>Note that there will be one instance of this advisor for each target method.
+ * Note that there will be one instance of this advisor for each target method.
  *
  * @author Rod Johnson
  * @author Juergen Hoeller
@@ -294,7 +293,7 @@ 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() {

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/ReflectiveAspectJAdvisorFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -50,7 +50,6 @@ import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.convert.converter.ConvertingComparator;
 import org.springframework.lang.Nullable;
-import org.springframework.util.ClassUtils;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.util.ReflectionUtils.MethodFilter;
 import org.springframework.util.StringUtils;
@@ -134,19 +133,17 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 
 		List<Advisor> advisors = new ArrayList<>();
 		for (Method method : getAdvisorMethods(aspectClass)) {
-			if (method.equals(ClassUtils.getMostSpecificMethod(method, aspectClass))) {
-				// Prior to Spring Framework 5.2.7, advisors.size() was supplied as the declarationOrderInAspect
-				// to getAdvisor(...) to represent the "current position" in the declared methods list.
-				// However, since Java 7 the "current position" is not valid since the JDK no longer
-				// returns declared methods in the order in which they are declared in the source code.
-				// Thus, we now hard code the declarationOrderInAspect to 0 for all advice methods
-				// discovered via reflection in order to support reliable advice ordering across JVM launches.
-				// Specifically, a value of 0 aligns with the default value used in
-				// AspectJPrecedenceComparator.getAspectDeclarationOrder(Advisor).
-				Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
-				if (advisor != null) {
-					advisors.add(advisor);
-				}
+			// Prior to Spring Framework 5.2.7, advisors.size() was supplied as the declarationOrderInAspect
+			// to getAdvisor(...) to represent the "current position" in the declared methods list.
+			// However, since Java 7 the "current position" is not valid since the JDK no longer
+			// returns declared methods in the order in which they are declared in the source code.
+			// Thus, we now hard code the declarationOrderInAspect to 0 for all advice methods
+			// discovered via reflection in order to support reliable advice ordering across JVM launches.
+			// Specifically, a value of 0 aligns with the default value used in
+			// AspectJPrecedenceComparator.getAspectDeclarationOrder(Advisor).
+			Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
+			if (advisor != null) {
+				advisors.add(advisor);
 			}
 		}
 
@@ -213,16 +210,8 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 			return null;
 		}
 
-		try {
-			return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
-					this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
-		}
-		catch (IllegalArgumentException | IllegalStateException ex) {
-			if (logger.isDebugEnabled()) {
-				logger.debug("Ignoring incompatible advice method: " + candidateAdviceMethod, ex);
-			}
-			return null;
-		}
+		return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
+				this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
 	}
 
 	@Nullable

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

@@ -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.
@@ -44,8 +44,7 @@ import org.springframework.util.CollectionUtils;
 
 /**
  * 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
@@ -53,8 +52,7 @@ import org.springframework.util.CollectionUtils;
  * 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
@@ -106,7 +104,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) {
@@ -117,7 +115,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
 	 */
@@ -346,7 +344,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);
 		}
 	}
@@ -492,9 +491,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
 	 */
@@ -514,8 +513,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();

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

@@ -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) {

spring-aop/src/test/java/org/springframework/aop/aspectj/AspectJExpressionPointcutTests.java

@@ -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,13 +42,14 @@ 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;
 
 /**
  * @author Rob Harrop
  * @author Rod Johnson
  * @author Chris Beams
- * @author Juergen Hoeller
  */
 public class AspectJExpressionPointcutTests {
 
@@ -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)";
-		assertThat(getPointcut(expression).getClassFilter().matches(Object.class)).isFalse();
+		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) {

spring-aop/src/test/java/org/springframework/aop/aspectj/annotation/AbstractAspectJAdvisorFactoryTests.java

@@ -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.
@@ -37,6 +37,7 @@ import org.aspectj.lang.annotation.DeclareParents;
 import org.aspectj.lang.annotation.DeclarePrecedence;
 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;
@@ -75,24 +76,25 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 
 	/**
 	 * To be overridden by concrete test subclasses.
+	 * @return the fixture
 	 */
 	protected abstract AspectJAdvisorFactory getFixture();
 
 
 	@Test
 	void rejectsPerCflowAspect() {
-		assertThatExceptionOfType(AopConfigException.class)
-				.isThrownBy(() -> getFixture().getAdvisors(
+		assertThatExceptionOfType(AopConfigException.class).isThrownBy(() ->
+				getFixture().getAdvisors(
 						new SingletonMetadataAwareAspectInstanceFactory(new PerCflowAspect(), "someBean")))
-				.withMessageContaining("PERCFLOW");
+			.withMessageContaining("PERCFLOW");
 	}
 
 	@Test
 	void rejectsPerCflowBelowAspect() {
-		assertThatExceptionOfType(AopConfigException.class)
-				.isThrownBy(() -> getFixture().getAdvisors(
-						new SingletonMetadataAwareAspectInstanceFactory(new PerCflowBelowAspect(), "someBean")))
-				.withMessageContaining("PERCFLOWBELOW");
+		assertThatExceptionOfType(AopConfigException.class).isThrownBy(() ->
+					getFixture().getAdvisors(
+							new SingletonMetadataAwareAspectInstanceFactory(new PerCflowBelowAspect(), "someBean")))
+			.withMessageContaining("PERCFLOWBELOW");
 	}
 
 	@Test
@@ -383,7 +385,8 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 		assertThat(lockable.locked()).as("Already locked").isTrue();
 		lockable.lock();
 		assertThat(lockable.locked()).as("Real target ignores locking").isTrue();
-		assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(lockable::unlock);
+		assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() ->
+				lockable.unlock());
 	}
 
 	@Test
@@ -410,7 +413,9 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 		lockable.locked();
 	}
 
+	// TODO: Why does this test fail? It hasn't been run before, so it maybe never actually passed...
 	@Test
+	@Disabled
 	void introductionWithArgumentBinding() {
 		TestBean target = new TestBean();
 
@@ -518,16 +523,6 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 		assertThat(aspect.invocations).containsExactly("around - start", "before", "after throwing", "after", "around - end");
 	}
 
-	@Test
-	void parentAspect() {
-		TestBean target = new TestBean("Jane", 42);
-		MetadataAwareAspectInstanceFactory aspectInstanceFactory = new SingletonMetadataAwareAspectInstanceFactory(
-				new IncrementingAspect(), "incrementingAspect");
-		ITestBean proxy = (ITestBean) createProxy(target,
-				getFixture().getAdvisors(aspectInstanceFactory), ITestBean.class);
-		assertThat(proxy.getAge()).isEqualTo(86); // (42 + 1) * 2
-	}
-
 	@Test
 	void failureWithoutExplicitDeclarePrecedence() {
 		TestBean target = new TestBean();
@@ -652,7 +647,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 	static class NamedPointcutAspectWithFQN {
 
 		@SuppressWarnings("unused")
-		private final ITestBean fieldThatShouldBeIgnoredBySpringAtAspectJProcessing = new TestBean();
+		private ITestBean fieldThatShouldBeIgnoredBySpringAtAspectJProcessing = new TestBean();
 
 		@Pointcut("execution(* getAge())")
 		void getAge() {
@@ -772,31 +767,6 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 	}
 
 
-	@Aspect
-	abstract static class DoublingAspect {
-
-		@Around("execution(* getAge())")
-		public Object doubleAge(ProceedingJoinPoint pjp) throws Throwable {
-			return ((int) pjp.proceed()) * 2;
-		}
-	}
-
-
-	@Aspect
-	static class IncrementingAspect extends DoublingAspect {
-
-		@Override
-		public Object doubleAge(ProceedingJoinPoint pjp) throws Throwable {
-			return ((int) pjp.proceed()) * 2;
-		}
-
-		@Around("execution(* getAge())")
-		public int incrementAge(ProceedingJoinPoint pjp) throws Throwable {
-			return ((int) pjp.proceed()) + 1;
-		}
-	}
-
-
 	@Aspect
 	private static class InvocationTrackingAspect {
 
@@ -854,7 +824,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 
 		@Around("getAge()")
 		int preventExecution(ProceedingJoinPoint pjp) {
-			return 42;
+			return 666;
 		}
 	}
 
@@ -874,7 +844,7 @@ abstract class AbstractAspectJAdvisorFactoryTests {
 
 		@Around("getAge()")
 		int preventExecution(ProceedingJoinPoint pjp) {
-			return 42;
+			return 666;
 		}
 	}
 
@@ -1096,7 +1066,7 @@ class PerThisAspect {
 
 	// Just to check that this doesn't cause problems with introduction processing
 	@SuppressWarnings("unused")
-	private final ITestBean fieldThatShouldBeIgnoredBySpringAtAspectJProcessing = new TestBean();
+	private ITestBean fieldThatShouldBeIgnoredBySpringAtAspectJProcessing = new TestBean();
 
 	@Around("execution(int *.getAge())")
 	int returnCountAsAge() {

spring-aop/src/test/java/org/springframework/aop/aspectj/annotation/ArgumentBindingTests.java

@@ -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.
@@ -38,67 +38,56 @@ import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
  * @author Adrian Colyer
  * @author Juergen Hoeller
  * @author Chris Beams
- * @author Sam Brannen
  */
-class ArgumentBindingTests {
+public 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());
+	public void testBindingInPointcutUsedByAdvice() {
+		TestBean tb = new TestBean();
+		AspectJProxyFactory proxyFactory = new AspectJProxyFactory(tb);
 		proxyFactory.addAspect(NamedPointcutWithArgs.class);
-		ITestBean proxiedTestBean = proxyFactory.getProxy();
 
-		assertThatIllegalArgumentException()
-				.isThrownBy(() -> proxiedTestBean.setName("enigma"))
-				.withMessage("enigma");
+		ITestBean proxiedTestBean = proxyFactory.getProxy();
+		assertThatIllegalArgumentException().isThrownBy(() ->
+				proxiedTestBean.setName("Supercalifragalisticexpialidocious"));
 	}
 
 	@Test
-	void bindingWithDynamicAdvice() {
-		AspectJProxyFactory proxyFactory = new AspectJProxyFactory(new TestBean());
-		proxyFactory.addAspect(DynamicPointcutWithArgs.class);
-		ITestBean proxiedTestBean = proxyFactory.getProxy();
+	public void testAnnotationArgumentNameBinding() {
+		TransactionalBean tb = new TransactionalBean();
+		AspectJProxyFactory proxyFactory = new AspectJProxyFactory(tb);
+		proxyFactory.addAspect(PointcutWithAnnotationArgument.class);
 
-		proxiedTestBean.applyName(1);
-		assertThatIllegalArgumentException()
-				.isThrownBy(() -> proxiedTestBean.applyName("enigma"))
-				.withMessage("enigma");
+		ITransactionalBean proxiedTestBean = proxyFactory.getProxy();
+		assertThatIllegalStateException().isThrownBy(
+				proxiedTestBean::doInTransaction);
 	}
 
 	@Test
-	void parameterNameDiscoverWithReferencePointcut() throws Exception {
+	public void testParameterNameDiscoverWithReferencePointcut() throws Exception {
 		AspectJAdviceParameterNameDiscoverer discoverer =
 				new AspectJAdviceParameterNameDiscoverer("somepc(formal) && set(* *)");
 		discoverer.setRaiseExceptions(true);
-		Method method = getClass().getDeclaredMethod("methodWithOneParam", String.class);
-		assertThat(discoverer.getParameterNames(method)).containsExactly("formal");
+		Method methodUsedForParameterTypeDiscovery =
+				getClass().getMethod("methodWithOneParam", String.class);
+		String[] pnames = discoverer.getParameterNames(methodUsedForParameterTypeDiscovery);
+		assertThat(pnames.length).as("one parameter name").isEqualTo(1);
+		assertThat(pnames[0]).isEqualTo("formal");
 	}
 
 
-	@SuppressWarnings("unused")
-	private void methodWithOneParam(String aParam) {
+	public void methodWithOneParam(String aParam) {
 	}
 
 
-	interface ITransactionalBean {
+	public interface ITransactionalBean {
 
 		@Transactional
 		void doInTransaction();
 	}
 
 
-	static class TransactionalBean implements ITransactionalBean {
+	public static class TransactionalBean implements ITransactionalBean {
 
 		@Override
 		@Transactional
@@ -106,46 +95,38 @@ class ArgumentBindingTests {
 		}
 	}
 
+}
 
-	/**
-	 * Mimics Spring's @Transactional annotation without actually introducing the dependency.
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@interface Transactional {
-	}
+/**
+ * Represents Spring's Transactional annotation without actually introducing the dependency
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@interface Transactional {
+}
 
 
-	@Aspect
-	static class PointcutWithAnnotationArgument {
+@Aspect
+class PointcutWithAnnotationArgument {
 
-		@Around("execution(* org.springframework..*.*(..)) && @annotation(transactional)")
-		public Object around(ProceedingJoinPoint pjp, Transactional transactional) throws Throwable {
-			throw new IllegalStateException("Invoked with @Transactional");
-		}
-	}
-
-
-	@Aspect
-	static class NamedPointcutWithArgs {
-
-		@Pointcut("execution(* *(..)) && args(s,..)")
-		public void pointcutWithArgs(String s) {}
-
-		@Around("pointcutWithArgs(aString)")
-		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]));
-		}
+	@Around(value = "execution(* org.springframework..*.*(..)) && @annotation(transaction)")
+	public Object around(ProceedingJoinPoint pjp, Transactional transaction) throws Throwable {
+		System.out.println("Invoked with transaction " + transaction);
+		throw new IllegalStateException();
 	}
 
 }
 
+
+@Aspect
+class NamedPointcutWithArgs {
+
+	@Pointcut("execution(* *(..)) && args(s,..)")
+	public void pointcutWithArgs(String s) {}
+
+	@Around("pointcutWithArgs(aString)")
+	public Object doAround(ProceedingJoinPoint pjp, String aString) throws Throwable {
+		System.out.println("got '" + aString + "' at '" + pjp + "'");
+		throw new IllegalArgumentException(aString);
+	}
+
+}

spring-aop/src/test/java/org/springframework/aop/support/AopUtilsTests.java

@@ -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()).getProxy(getClass().getClassLoader()).getClass();
-		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()).getProxy(getClass().getClassLoader()).getClass();
-		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) {
-		}
-	}
-
 }

spring-aspects/src/test/java/org/springframework/aop/aspectj/autoproxy/AutoProxyWithCodeStyleAspectsTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -22,13 +22,12 @@ import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 /**
  * @author Adrian Colyer
- * @author Juergen Hoeller
  */
 public class AutoProxyWithCodeStyleAspectsTests {
 
 	@Test
 	@SuppressWarnings("resource")
-	public void noAutoProxyingOfAjcCompiledAspects() {
+	public void noAutoproxyingOfAjcCompiledAspects() {
 		new ClassPathXmlApplicationContext("org/springframework/aop/aspectj/autoproxy/ajcAutoproxyTests.xml");
 	}
 

spring-aspects/src/test/java/org/springframework/beans/factory/aspectj/SpringConfiguredWithAutoProxyingTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2015 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,10 +20,6 @@ import org.junit.jupiter.api.Test;
 
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 
-/**
- * @author Ramnivas Laddad
- * @author Juergen Hoeller
- */
 public class SpringConfiguredWithAutoProxyingTests {
 
 	@Test

spring-aspects/src/test/resources/org/springframework/aop/aspectj/autoproxy/ajcAutoproxyTests.xml

@@ -2,29 +2,16 @@
 <beans xmlns="http://www.springframework.org/schema/beans"
 		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 		xmlns:aop="http://www.springframework.org/schema/aop"
-	    xmlns:cache="http://www.springframework.org/schema/cache"
-		xmlns:context="http://www.springframework.org/schema/context"
 		xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans-2.0.xsd
-				http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop-2.0.xsd
-				http://www.springframework.org/schema/cache https://www.springframework.org/schema/cache/spring-cache-3.1.xsd
-	   			http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context-2.5.xsd">
+				http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
 
 	<aop:aspectj-autoproxy/>
 
-	<context:spring-configured/>
-
-	<cache:annotation-driven mode="aspectj"/>
-
-	<bean id="cacheManager" class="org.springframework.cache.support.NoOpCacheManager"/>
-
-	<bean id="myAspect" class="org.springframework.aop.aspectj.autoproxy.CodeStyleAspect" factory-method="aspectOf">
+	<bean id="myAspect" class="org.springframework.aop.aspectj.autoproxy.CodeStyleAspect"
+			factory-method="aspectOf">
 		<property name="foo" value="bar"/>
 	</bean>
 
-	<bean id="otherBean" class="org.springframework.beans.factory.aspectj.ShouldBeConfiguredBySpring"/>
-
-	<bean id="yetAnotherBean" class="org.springframework.beans.factory.aspectj.ShouldBeConfiguredBySpring"/>
-
-	<bean id="configuredBean" class="org.springframework.beans.factory.aspectj.ShouldBeConfiguredBySpring" lazy-init="true"/>
+	<bean id="otherBean" class="java.lang.Object"/>
 
 </beans>

spring-aspects/src/test/resources/org/springframework/cache/config/annotation-jcache-aspectj.xml

@@ -24,7 +24,8 @@
 		</property>
 	</bean>
 
-	<bean id="defaultCache" class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+	<bean id="defaultCache"
+		  class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
 		<property name="name" value="default"/>
 	</bean>
 

spring-aspects/src/test/resources/org/springframework/scheduling/aspectj/annotationDrivenContext.xml

@@ -7,10 +7,12 @@
 				http://www.springframework.org/schema/task
 				https://www.springframework.org/schema/task/spring-task.xsd">
 
-	<task:annotation-driven mode="aspectj" executor="testExecutor" exception-handler="testExceptionHandler"/>
+	<task:annotation-driven mode="aspectj" executor="testExecutor"
+							exception-handler="testExceptionHandler"/>
 
 	<task:executor id="testExecutor"/>
 
-	<bean id="testExceptionHandler" class="org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler"/>
+	<bean id="testExceptionHandler"
+		  class="org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler"/>
 
 </beans>

spring-beans/src/main/java/org/springframework/beans/factory/BeanFactory.java

@@ -239,7 +239,7 @@ public interface BeanFactory {
 	 * specific type, specify the actual bean type as an argument here and subsequently
 	 * use {@link ObjectProvider#orderedStream()} or its lazy streaming/iteration options.
 	 * <p>Also, generics matching is strict here, as per the Java assignment rules.
-	 * For lenient fallback matching with unchecked semantics (similar to the 'unchecked'
+	 * For lenient fallback matching with unchecked semantics (similar to the ´unchecked´
 	 * Java compiler warning), consider calling {@link #getBeanProvider(Class)} with the
 	 * raw type as a second step if no full generic match is
 	 * {@link ObjectProvider#getIfAvailable() available} with this variant.

spring-beans/src/main/java/org/springframework/beans/factory/annotation/QualifierAnnotationAutowireCandidateResolver.java

@@ -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;
 			}
 		}

spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java

@@ -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.
@@ -97,10 +97,10 @@ import org.springframework.util.StringUtils;
  * 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
@@ -675,7 +675,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 &&
@@ -835,11 +835,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.

spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java

@@ -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.
@@ -166,9 +166,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;
-
 	/** Security context used when running with a SecurityManager. */
 	@Nullable
 	private SecurityContextProvider securityContextProvider;
@@ -183,6 +180,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.
@@ -750,7 +749,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)) {
@@ -1080,7 +1079,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 should not be null");
 		this.applicationStartup = applicationStartup;
 	}
 
@@ -1695,7 +1694,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

spring-beans/src/main/java/org/springframework/beans/factory/support/ConstructorResolver.java

@@ -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.
@@ -107,7 +107,11 @@ class ConstructorResolver {
 
 	/**
 	 * "autowire constructor" (with constructor arguments by type) behavior.
-	 * Also applied if explicit constructor argument values are specified.
+	 * Also applied if explicit constructor argument values are specified,
+	 * matching all remaining arguments with beans from the bean factory.
+	 * <p>This corresponds to constructor injection: In this mode, a Spring
+	 * bean factory is able to host components that expect constructor-based
+	 * dependency resolution.
 	 * @param beanName the name of the bean
 	 * @param mbd the merged bean definition for the bean
 	 * @param chosenCtors chosen candidate constructors (or {@code null} if none)
@@ -600,10 +604,13 @@ class ConstructorResolver {
 				String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
 				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 						"No matching factory method found on class [" + factoryClass.getName() + "]: " +
-						(mbd.getFactoryBeanName() != null ? "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
+						(mbd.getFactoryBeanName() != null ?
+							"factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
 						"factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
-						"Check that a method with the specified name " + (minNrOfArgs > 0 ? "and arguments " : "") +
-						"exists and that it is " + (isStatic ? "static" : "non-static") + ".");
+						"Check that a method with the specified name " +
+						(minNrOfArgs > 0 ? "and arguments " : "") +
+						"exists and that it is " +
+						(isStatic ? "static" : "non-static") + ".");
 			}
 			else if (void.class == factoryMethodToUse.getReturnType()) {
 				throw new BeanCreationException(mbd.getResourceDescription(), beanName,

spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java

@@ -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.
@@ -567,16 +567,16 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 	 */
 	protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
 		// Trigger destruction of dependent beans first...
-		Set<String> dependentBeanNames;
+		Set<String> dependencies;
 		synchronized (this.dependentBeanMap) {
 			// Within full synchronization in order to guarantee a disconnected Set
-			dependentBeanNames = this.dependentBeanMap.remove(beanName);
+			dependencies = this.dependentBeanMap.remove(beanName);
 		}
-		if (dependentBeanNames != null) {
+		if (dependencies != null) {
 			if (logger.isTraceEnabled()) {
-				logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependentBeanNames);
+				logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
 			}
-			for (String dependentBeanName : dependentBeanNames) {
+			for (String dependentBeanName : dependencies) {
 				destroySingleton(dependentBeanName);
 			}
 		}

spring-beans/src/main/java/org/springframework/beans/propertyeditors/PathEditor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 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.
@@ -78,10 +78,8 @@ public class PathEditor extends PropertyEditorSupport {
 		if (nioPathCandidate && !text.startsWith("/")) {
 			try {
 				URI uri = new URI(text);
-				String scheme = uri.getScheme();
-				if (scheme != null) {
-					// No NIO candidate except for "C:" style drive letters
-					nioPathCandidate = (scheme.length() == 1);
+				if (uri.getScheme() != null) {
+					nioPathCandidate = false;
 					// Let's try NIO file system providers via Paths.get(URI)
 					setValue(Paths.get(uri).normalize());
 					return;
@@ -92,9 +90,9 @@ public class PathEditor extends PropertyEditorSupport {
 				// a file prefix (let's try as Spring resource location)
 				nioPathCandidate = !text.startsWith(ResourceUtils.FILE_URL_PREFIX);
 			}
-			catch (FileSystemNotFoundException | IllegalArgumentException ex) {
-				// URI scheme not registered for NIO or not meeting Paths requirements:
-				// let's try URL protocol handlers via Spring's resource mechanism.
+			catch (FileSystemNotFoundException ex) {
+				// URI scheme not registered for NIO (let's try URL
+				// protocol handlers via Spring's resource mechanism).
 			}
 		}
 
@@ -111,13 +109,7 @@ public class PathEditor extends PropertyEditorSupport {
 				setValue(resource.getFile().toPath());
 			}
 			catch (IOException ex) {
-				String msg = "Could not resolve \"" + text + "\" to 'java.nio.file.Path' for " + resource + ": " +
-						ex.getMessage();
-				if (nioPathCandidate) {
-					msg += " - In case of ambiguity, consider adding the 'file:' prefix for an explicit reference " +
-							"to a file system resource of the same name: \"file:" + text + "\"";
-				}
-				throw new IllegalArgumentException(msg);
+				throw new IllegalArgumentException("Failed to retrieve file for " + resource, ex);
 			}
 		}
 	}

spring-beans/src/test/java/org/springframework/beans/BeanUtilsTests.java

@@ -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.
@@ -42,8 +42,6 @@ import org.springframework.beans.propertyeditors.CustomDateEditor;
 import org.springframework.beans.testfixture.beans.DerivedTestBean;
 import org.springframework.beans.testfixture.beans.ITestBean;
 import org.springframework.beans.testfixture.beans.TestBean;
-import org.springframework.cglib.proxy.Enhancer;
-import org.springframework.cglib.proxy.MethodInterceptor;
 import org.springframework.core.io.Resource;
 import org.springframework.core.io.ResourceEditor;
 import org.springframework.lang.Nullable;
@@ -54,7 +52,7 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
 import static org.assertj.core.api.SoftAssertions.assertSoftly;
 
 /**
- * Tests for {@link BeanUtils}.
+ * Unit tests for {@link BeanUtils}.
  *
  * @author Juergen Hoeller
  * @author Rob Harrop
@@ -138,7 +136,7 @@ class BeanUtilsTests {
 		PropertyDescriptor[] actual = Introspector.getBeanInfo(TestBean.class).getPropertyDescriptors();
 		PropertyDescriptor[] descriptors = BeanUtils.getPropertyDescriptors(TestBean.class);
 		assertThat(descriptors).as("Descriptors should not be null").isNotNull();
-		assertThat(descriptors).as("Invalid number of descriptors returned").hasSameSizeAs(actual);
+		assertThat(descriptors.length).as("Invalid number of descriptors returned").isEqualTo(actual.length);
 	}
 
 	@Test
@@ -164,13 +162,13 @@ class BeanUtilsTests {
 		tb.setAge(32);
 		tb.setTouchy("touchy");
 		TestBean tb2 = new TestBean();
-		assertThat(tb2.getName()).as("Name empty").isNull();
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getName() == null).as("Name empty").isTrue();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 		BeanUtils.copyProperties(tb, tb2);
-		assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
-		assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
-		assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
+		assertThat(tb2.getName().equals(tb.getName())).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == tb.getAge()).as("Age copied").isTrue();
+		assertThat(tb2.getTouchy().equals(tb.getTouchy())).as("Touchy copied").isTrue();
 	}
 
 	@Test
@@ -180,13 +178,13 @@ class BeanUtilsTests {
 		tb.setAge(32);
 		tb.setTouchy("touchy");
 		TestBean tb2 = new TestBean();
-		assertThat(tb2.getName()).as("Name empty").isNull();
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getName() == null).as("Name empty").isTrue();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 		BeanUtils.copyProperties(tb, tb2);
-		assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
-		assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
-		assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
+		assertThat(tb2.getName().equals(tb.getName())).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == tb.getAge()).as("Age copied").isTrue();
+		assertThat(tb2.getTouchy().equals(tb.getTouchy())).as("Touchy copied").isTrue();
 	}
 
 	@Test
@@ -196,13 +194,13 @@ class BeanUtilsTests {
 		tb.setAge(32);
 		tb.setTouchy("touchy");
 		DerivedTestBean tb2 = new DerivedTestBean();
-		assertThat(tb2.getName()).as("Name empty").isNull();
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getName() == null).as("Name empty").isTrue();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 		BeanUtils.copyProperties(tb, tb2);
-		assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
-		assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
-		assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
+		assertThat(tb2.getName().equals(tb.getName())).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == tb.getAge()).as("Age copied").isTrue();
+		assertThat(tb2.getTouchy().equals(tb.getTouchy())).as("Touchy copied").isTrue();
 	}
 
 	/**
@@ -229,8 +227,8 @@ class BeanUtilsTests {
 		IntegerListHolder2 integerListHolder2 = new IntegerListHolder2();
 
 		BeanUtils.copyProperties(integerListHolder1, integerListHolder2);
-		assertThat(integerListHolder1.getList()).containsExactly(42);
-		assertThat(integerListHolder2.getList()).containsExactly(42);
+		assertThat(integerListHolder1.getList()).containsOnly(42);
+		assertThat(integerListHolder2.getList()).containsOnly(42);
 	}
 
 	/**
@@ -259,7 +257,7 @@ class BeanUtilsTests {
 		WildcardListHolder2 wildcardListHolder2 = new WildcardListHolder2();
 
 		BeanUtils.copyProperties(integerListHolder1, wildcardListHolder2);
-		assertThat(integerListHolder1.getList()).containsExactly(42);
+		assertThat(integerListHolder1.getList()).containsOnly(42);
 		assertThat(wildcardListHolder2.getList()).isEqualTo(Arrays.asList(42));
 	}
 
@@ -273,8 +271,9 @@ class BeanUtilsTests {
 		NumberUpperBoundedWildcardListHolder numberListHolder = new NumberUpperBoundedWildcardListHolder();
 
 		BeanUtils.copyProperties(integerListHolder1, numberListHolder);
-		assertThat(integerListHolder1.getList()).containsExactly(42);
-		assertThat(numberListHolder.getList()).isEqualTo(Arrays.asList(42));
+		assertThat(integerListHolder1.getList()).containsOnly(42);
+		assertThat(numberListHolder.getList()).hasSize(1);
+		assertThat(numberListHolder.getList().contains(Integer.valueOf(42))).isTrue();
 	}
 
 	/**
@@ -283,7 +282,7 @@ class BeanUtilsTests {
 	@Test
 	void copyPropertiesDoesNotCopyFromSuperTypeToSubType() {
 		NumberHolder numberHolder = new NumberHolder();
-		numberHolder.setNumber(42);
+		numberHolder.setNumber(Integer.valueOf(42));
 		IntegerHolder integerHolder = new IntegerHolder();
 
 		BeanUtils.copyProperties(numberHolder, integerHolder);
@@ -301,7 +300,7 @@ class BeanUtilsTests {
 		LongListHolder longListHolder = new LongListHolder();
 
 		BeanUtils.copyProperties(integerListHolder, longListHolder);
-		assertThat(integerListHolder.getList()).containsExactly(42);
+		assertThat(integerListHolder.getList()).containsOnly(42);
 		assertThat(longListHolder.getList()).isEmpty();
 	}
 
@@ -315,7 +314,7 @@ class BeanUtilsTests {
 		NumberListHolder numberListHolder = new NumberListHolder();
 
 		BeanUtils.copyProperties(integerListHolder, numberListHolder);
-		assertThat(integerListHolder.getList()).containsExactly(42);
+		assertThat(integerListHolder.getList()).containsOnly(42);
 		assertThat(numberListHolder.getList()).isEmpty();
 	}
 
@@ -324,13 +323,12 @@ class BeanUtilsTests {
 		Order original = new Order("test", Arrays.asList("foo", "bar"));
 
 		// Create a Proxy that loses the generic type information for the getLineItems() method.
-		OrderSummary proxy = (OrderSummary) Proxy.newProxyInstance(getClass().getClassLoader(),
-				new Class<?>[] {OrderSummary.class}, new OrderInvocationHandler(original));
+		OrderSummary proxy = proxyOrder(original);
 		assertThat(OrderSummary.class.getDeclaredMethod("getLineItems").toGenericString())
-				.contains("java.util.List<java.lang.String>");
+			.contains("java.util.List<java.lang.String>");
 		assertThat(proxy.getClass().getDeclaredMethod("getLineItems").toGenericString())
-				.contains("java.util.List")
-				.doesNotContain("<java.lang.String>");
+			.contains("java.util.List")
+			.doesNotContain("<java.lang.String>");
 
 		// Ensure that our custom Proxy works as expected.
 		assertThat(proxy.getId()).isEqualTo("test");
@@ -343,57 +341,40 @@ class BeanUtilsTests {
 		assertThat(target.getLineItems()).containsExactly("foo", "bar");
 	}
 
-	@Test  // gh-32888
-	public void copyPropertiesWithGenericCglibClass() {
-		Enhancer enhancer = new Enhancer();
-		enhancer.setSuperclass(User.class);
-		enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> proxy.invokeSuper(obj, args));
-		User user = (User) enhancer.create();
-		user.setId(1);
-		user.setName("proxy");
-		user.setAddress("addr");
-
-		User target = new User();
-		BeanUtils.copyProperties(user, target);
-		assertThat(target.getId()).isEqualTo(user.getId());
-		assertThat(target.getName()).isEqualTo(user.getName());
-		assertThat(target.getAddress()).isEqualTo(user.getAddress());
-	}
-
 	@Test
 	void copyPropertiesWithEditable() throws Exception {
 		TestBean tb = new TestBean();
-		assertThat(tb.getName()).as("Name empty").isNull();
+		assertThat(tb.getName() == null).as("Name empty").isTrue();
 		tb.setAge(32);
 		tb.setTouchy("bla");
 		TestBean tb2 = new TestBean();
 		tb2.setName("rod");
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 
 		// "touchy" should not be copied: it's not defined in ITestBean
 		BeanUtils.copyProperties(tb, tb2, ITestBean.class);
-		assertThat(tb2.getName()).as("Name copied").isNull();
-		assertThat(tb2.getAge()).as("Age copied").isEqualTo(32);
-		assertThat(tb2.getTouchy()).as("Touchy still empty").isNull();
+		assertThat(tb2.getName() == null).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == 32).as("Age copied").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy still empty").isTrue();
 	}
 
 	@Test
 	void copyPropertiesWithIgnore() throws Exception {
 		TestBean tb = new TestBean();
-		assertThat(tb.getName()).as("Name empty").isNull();
+		assertThat(tb.getName() == null).as("Name empty").isTrue();
 		tb.setAge(32);
 		tb.setTouchy("bla");
 		TestBean tb2 = new TestBean();
 		tb2.setName("rod");
-		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		assertThat(tb2.getAge() == 0).as("Age empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy empty").isTrue();
 
 		// "spouse", "touchy", "age" should not be copied
 		BeanUtils.copyProperties(tb, tb2, "spouse", "touchy", "age");
-		assertThat(tb2.getName()).as("Name copied").isNull();
-		assertThat(tb2.getAge()).as("Age still empty").isEqualTo(0);
-		assertThat(tb2.getTouchy()).as("Touchy still empty").isNull();
+		assertThat(tb2.getName() == null).as("Name copied").isTrue();
+		assertThat(tb2.getAge() == 0).as("Age still empty").isTrue();
+		assertThat(tb2.getTouchy() == null).as("Touchy still empty").isTrue();
 	}
 
 	@Test
@@ -402,7 +383,7 @@ class BeanUtilsTests {
 		source.setName("name");
 		TestBean target = new TestBean();
 		BeanUtils.copyProperties(source, target, "specialProperty");
-		assertThat(target.getName()).isEqualTo("name");
+		assertThat("name").isEqualTo(target.getName());
 	}
 
 	@Test
@@ -539,7 +520,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class IntegerHolder {
 
@@ -554,7 +534,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class WildcardListHolder1 {
 
@@ -569,7 +548,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class WildcardListHolder2 {
 
@@ -584,7 +562,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class NumberUpperBoundedWildcardListHolder {
 
@@ -599,7 +576,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class NumberListHolder {
 
@@ -614,7 +590,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class IntegerListHolder1 {
 
@@ -629,7 +604,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class IntegerListHolder2 {
 
@@ -644,7 +618,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class LongListHolder {
 
@@ -825,7 +798,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	private static class BeanWithNullableTypes {
 
 		private Integer counter;
@@ -856,7 +828,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	private static class BeanWithPrimitiveTypes {
 
 		private boolean flag;
@@ -869,6 +840,7 @@ class BeanUtilsTests {
 		private char character;
 		private String text;
 
+
 		@SuppressWarnings("unused")
 		public BeanWithPrimitiveTypes(boolean flag, byte byteCount, short shortCount, int intCount, long longCount,
 				float floatCount, double doubleCount, char character, String text) {
@@ -919,8 +891,8 @@ class BeanUtilsTests {
 		public String getText() {
 			return text;
 		}
-	}
 
+	}
 
 	private static class PrivateBeanWithPrivateConstructor {
 
@@ -928,14 +900,13 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	@SuppressWarnings("unused")
 	private static class Order {
 
 		private String id;
-
 		private List<String> lineItems;
 
+
 		Order() {
 		}
 
@@ -966,7 +937,6 @@ class BeanUtilsTests {
 		}
 	}
 
-
 	private interface OrderSummary {
 
 		String getId();
@@ -975,10 +945,17 @@ class BeanUtilsTests {
 	}
 
 
+	private OrderSummary proxyOrder(Order order) {
+		return (OrderSummary) Proxy.newProxyInstance(getClass().getClassLoader(),
+			new Class<?>[] { OrderSummary.class }, new OrderInvocationHandler(order));
+	}
+
+
 	private static class OrderInvocationHandler implements InvocationHandler {
 
 		private final Order order;
 
+
 		OrderInvocationHandler(Order order) {
 			this.order = order;
 		}
@@ -996,46 +973,4 @@ class BeanUtilsTests {
 		}
 	}
 
-
-	private static class GenericBaseModel<T> {
-
-		private T id;
-
-		private String name;
-
-		public T getId() {
-			return id;
-		}
-
-		public void setId(T id) {
-			this.id = id;
-		}
-
-		public String getName() {
-			return name;
-		}
-
-		public void setName(String name) {
-			this.name = name;
-		}
-	}
-
-
-	private static class User extends GenericBaseModel<Integer> {
-
-		private String address;
-
-		public User() {
-			super();
-		}
-
-		public String getAddress() {
-			return address;
-		}
-
-		public void setAddress(String address) {
-			this.address = address;
-		}
-	}
-
 }

spring-beans/src/test/java/org/springframework/beans/propertyeditors/FileEditorTests.java

@@ -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.
@@ -31,82 +31,79 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
  * @author Chris Beams
  * @author Juergen Hoeller
  */
-class FileEditorTests {
+public class FileEditorTests {
 
 	@Test
-	void testClasspathFileName() {
+	public void testClasspathFileName() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		fileEditor.setAsText("classpath:" + ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".class");
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition = value instanceof File;
+		assertThat(condition).isTrue();
 		File file = (File) value;
-		assertThat(file).exists();
+		assertThat(file.exists()).isTrue();
 	}
 
 	@Test
-	void testWithNonExistentResource() {
-		PropertyEditor fileEditor = new FileEditor();
+	public void testWithNonExistentResource() throws Exception {
+		PropertyEditor propertyEditor = new FileEditor();
 		assertThatIllegalArgumentException().isThrownBy(() ->
-				fileEditor.setAsText("classpath:no_way_this_file_is_found.doc"));
+				propertyEditor.setAsText("classpath:no_way_this_file_is_found.doc"));
 	}
 
 	@Test
-	void testWithNonExistentFile() {
+	public void testWithNonExistentFile() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		fileEditor.setAsText("file:no_way_this_file_is_found.doc");
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition1 = value instanceof File;
+		assertThat(condition1).isTrue();
 		File file = (File) value;
-		assertThat(file).doesNotExist();
+		boolean condition = !file.exists();
+		assertThat(condition).isTrue();
 	}
 
 	@Test
-	void testAbsoluteFileName() {
+	public void testAbsoluteFileName() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		fileEditor.setAsText("/no_way_this_file_is_found.doc");
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition1 = value instanceof File;
+		assertThat(condition1).isTrue();
 		File file = (File) value;
-		assertThat(file).doesNotExist();
+		boolean condition = !file.exists();
+		assertThat(condition).isTrue();
 	}
 
 	@Test
-	void testCurrentDirectory() {
-		PropertyEditor fileEditor = new FileEditor();
-		fileEditor.setAsText("file:.");
-		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
-		File file = (File) value;
-		assertThat(file).isEqualTo(new File("."));
-	}
-
-	@Test
-	void testUnqualifiedFileNameFound() {
+	public void testUnqualifiedFileNameFound() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		String fileName = ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".class";
 		fileEditor.setAsText(fileName);
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition = value instanceof File;
+		assertThat(condition).isTrue();
 		File file = (File) value;
-		assertThat(file).exists();
+		assertThat(file.exists()).isTrue();
 		String absolutePath = file.getAbsolutePath().replace('\\', '/');
-		assertThat(absolutePath).endsWith(fileName);
+		assertThat(absolutePath.endsWith(fileName)).isTrue();
 	}
 
 	@Test
-	void testUnqualifiedFileNameNotFound() {
+	public void testUnqualifiedFileNameNotFound() throws Exception {
 		PropertyEditor fileEditor = new FileEditor();
 		String fileName = ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".clazz";
 		fileEditor.setAsText(fileName);
 		Object value = fileEditor.getValue();
-		assertThat(value).isInstanceOf(File.class);
+		boolean condition = value instanceof File;
+		assertThat(condition).isTrue();
 		File file = (File) value;
-		assertThat(file).doesNotExist();
+		assertThat(file.exists()).isFalse();
 		String absolutePath = file.getAbsolutePath().replace('\\', '/');
-		assertThat(absolutePath).endsWith(fileName);
+		assertThat(absolutePath.endsWith(fileName)).isTrue();
 	}
 
 }

spring-beans/src/test/java/org/springframework/beans/propertyeditors/PathEditorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,7 +19,6 @@ package org.springframework.beans.propertyeditors;
 import java.beans.PropertyEditor;
 import java.io.File;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 
 import org.junit.jupiter.api.Test;
 
@@ -32,65 +31,65 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
  * @author Juergen Hoeller
  * @since 4.3.2
  */
-class PathEditorTests {
+public class PathEditorTests {
 
 	@Test
-	void testClasspathPathName() {
+	public void testClasspathPathName() {
 		PropertyEditor pathEditor = new PathEditor();
 		pathEditor.setAsText("classpath:" + ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".class");
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
-		assertThat(path.toFile()).exists();
+		assertThat(path.toFile().exists()).isTrue();
 	}
 
 	@Test
-	void testWithNonExistentResource() {
-		PropertyEditor pathEditor = new PathEditor();
+	public void testWithNonExistentResource() {
+		PropertyEditor propertyEditor = new PathEditor();
 		assertThatIllegalArgumentException().isThrownBy(() ->
-				pathEditor.setAsText("classpath:/no_way_this_file_is_found.doc"));
+				propertyEditor.setAsText("classpath:/no_way_this_file_is_found.doc"));
 	}
 
 	@Test
-	void testWithNonExistentPath() {
+	public void testWithNonExistentPath() {
 		PropertyEditor pathEditor = new PathEditor();
 		pathEditor.setAsText("file:/no_way_this_file_is_found.doc");
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
-		assertThat(path.toFile()).doesNotExist();
+		assertThat(!path.toFile().exists()).isTrue();
 	}
 
 	@Test
-	void testAbsolutePath() {
+	public void testAbsolutePath() {
 		PropertyEditor pathEditor = new PathEditor();
 		pathEditor.setAsText("/no_way_this_file_is_found.doc");
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
-		assertThat(path.toFile()).doesNotExist();
+		assertThat(!path.toFile().exists()).isTrue();
 	}
 
 	@Test
-	void testWindowsAbsolutePath() {
+	public void testWindowsAbsolutePath() {
 		PropertyEditor pathEditor = new PathEditor();
 		pathEditor.setAsText("C:\\no_way_this_file_is_found.doc");
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
-		assertThat(path.toFile()).doesNotExist();
+		assertThat(!path.toFile().exists()).isTrue();
 	}
 
 	@Test
-	void testWindowsAbsoluteFilePath() {
+	public void testWindowsAbsoluteFilePath() {
 		PropertyEditor pathEditor = new PathEditor();
 		try {
 			pathEditor.setAsText("file://C:\\no_way_this_file_is_found.doc");
 			Object value = pathEditor.getValue();
-			assertThat(value).isInstanceOf(Path.class);
+			assertThat(value instanceof Path).isTrue();
 			Path path = (Path) value;
-			assertThat(path.toFile()).doesNotExist();
+			assertThat(!path.toFile().exists()).isTrue();
 		}
 		catch (IllegalArgumentException ex) {
 			if (File.separatorChar == '\\') {  // on Windows, otherwise silently ignore
@@ -100,49 +99,39 @@ class PathEditorTests {
 	}
 
 	@Test
-	void testCurrentDirectory() {
-		PropertyEditor pathEditor = new PathEditor();
-		pathEditor.setAsText("file:.");
-		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
-		Path path = (Path) value;
-		assertThat(path).isEqualTo(Paths.get("."));
-	}
-
-	@Test
-	void testUnqualifiedPathNameFound() {
+	public void testUnqualifiedPathNameFound() {
 		PropertyEditor pathEditor = new PathEditor();
 		String fileName = ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".class";
 		pathEditor.setAsText(fileName);
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
 		File file = path.toFile();
-		assertThat(file).exists();
+		assertThat(file.exists()).isTrue();
 		String absolutePath = file.getAbsolutePath();
 		if (File.separatorChar == '\\') {
 			absolutePath = absolutePath.replace('\\', '/');
 		}
-		assertThat(absolutePath).endsWith(fileName);
+		assertThat(absolutePath.endsWith(fileName)).isTrue();
 	}
 
 	@Test
-	void testUnqualifiedPathNameNotFound() {
+	public void testUnqualifiedPathNameNotFound() {
 		PropertyEditor pathEditor = new PathEditor();
 		String fileName = ClassUtils.classPackageAsResourcePath(getClass()) + "/" +
 				ClassUtils.getShortName(getClass()) + ".clazz";
 		pathEditor.setAsText(fileName);
 		Object value = pathEditor.getValue();
-		assertThat(value).isInstanceOf(Path.class);
+		assertThat(value instanceof Path).isTrue();
 		Path path = (Path) value;
 		File file = path.toFile();
-		assertThat(file).doesNotExist();
+		assertThat(file.exists()).isFalse();
 		String absolutePath = file.getAbsolutePath();
 		if (File.separatorChar == '\\') {
 			absolutePath = absolutePath.replace('\\', '/');
 		}
-		assertThat(absolutePath).endsWith(fileName);
+		assertThat(absolutePath.endsWith(fileName)).isTrue();
 	}
 
 }

spring-beans/src/testFixtures/java/org/springframework/beans/testfixture/beans/ITestBean.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2018 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.
@@ -33,10 +33,6 @@ public interface ITestBean extends AgeHolder {
 
 	void setName(String name);
 
-	default void applyName(Object name) {
-		setName(String.valueOf(name));
-	}
-
 	ITestBean getSpouse();
 
 	void setSpouse(ITestBean spouse);

spring-context-support/src/main/java/org/springframework/cache/caffeine/CaffeineCacheManager.java

@@ -236,7 +236,7 @@ public class CaffeineCacheManager implements CacheManager {
 	 * Build a common {@link CaffeineCache} instance for the specified cache name,
 	 * using the common Caffeine configuration specified on this cache manager.
 	 * <p>Delegates to {@link #adaptCaffeineCache} as the adaptation method to
-	 * Spring's cache abstraction (allowing for centralized decoration etc.),
+	 * Spring's cache abstraction (allowing for centralized decoration etc),
 	 * passing in a freshly built native Caffeine Cache instance.
 	 * @param name the name of the cache
 	 * @return the Spring CaffeineCache adapter (or a decorator thereof)

spring-context/src/main/java/org/springframework/cache/annotation/CacheConfig.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2015 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 java.lang.annotation.Target;
  * @author Stephane Nicoll
  * @author Sam Brannen
  * @since 4.1
- * @see Cacheable
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
@@ -43,10 +42,8 @@ public @interface CacheConfig {
 	 * Names of the default caches to consider for caching operations defined
 	 * in the annotated class.
 	 * <p>If none is set at the operation level, these are used instead of the default.
-	 * <p>Names may be used to determine the target cache(s), to be resolved via the
-	 * configured {@link #cacheResolver()} which typically delegates to
-	 * {@link org.springframework.cache.CacheManager#getCache}.
-	 * For further details see {@link Cacheable#cacheNames()}.
+	 * <p>May be used to determine the target cache (or caches), matching the
+	 * qualifier value or the bean names of a specific bean definition.
 	 */
 	String[] cacheNames() default {};
 

spring-context/src/main/java/org/springframework/cache/annotation/Cacheable.java

@@ -68,12 +68,8 @@ public @interface Cacheable {
 
 	/**
 	 * Names of the caches in which method invocation results are stored.
-	 * <p>Names may be used to determine the target cache(s), to be resolved via the
-	 * configured {@link #cacheResolver()} which typically delegates to
-	 * {@link org.springframework.cache.CacheManager#getCache}.
-	 * <p>This will usually be a single cache name. If multiple names are specified,
-	 * they will be consulted for a cache hit in the order of definition, and they
-	 * will all receive a put/evict request for the same newly cached value.
+	 * <p>Names may be used to determine the target cache (or caches), matching
+	 * the qualifier value or bean name of a specific bean definition.
 	 * @since 4.2
 	 * @see #value
 	 * @see CacheConfig#cacheNames

spring-context/src/main/java/org/springframework/cache/interceptor/CacheAspectSupport.java

@@ -547,10 +547,10 @@ public abstract class CacheAspectSupport extends AbstractCacheInvoker
 	}
 
 	/**
-	 * Collect a {@link CachePutRequest} for every {@link CacheOperation}
-	 * using the specified result value.
+	 * Collect the {@link CachePutRequest} for all {@link CacheOperation} using
+	 * the specified result value.
 	 * @param contexts the contexts to handle
-	 * @param result the result value
+	 * @param result the result value (never {@code null})
 	 * @param putRequests the collection to update
 	 */
 	private void collectPutRequests(Collection<CacheOperationContext> contexts,

spring-context/src/main/java/org/springframework/cache/interceptor/CacheOperationInvoker.java

@@ -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.
@@ -22,7 +22,7 @@ import org.springframework.lang.Nullable;
  * Abstract the invocation of a cache operation.
  *
  * <p>Does not provide a way to transmit checked exceptions but
- * provides a special exception that should be used to wrap any
+ * provide a special exception that should be used to wrap any
  * exception that was thrown by the underlying invocation.
  * Callers are expected to handle this issue type specifically.
  *

spring-context/src/main/java/org/springframework/context/SmartLifecycle.java

@@ -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.
@@ -121,7 +121,7 @@ public interface SmartLifecycle extends Lifecycle, Phased {
 	/**
 	 * Return the phase that this lifecycle object is supposed to run in.
 	 * <p>The default implementation returns {@link #DEFAULT_PHASE} in order to
-	 * let {@code stop()} callbacks execute before regular {@code Lifecycle}
+	 * let {@code stop()} callbacks execute after regular {@code Lifecycle}
 	 * implementations.
 	 * @see #isAutoStartup()
 	 * @see #start()

spring-context/src/main/java/org/springframework/context/annotation/ClassPathScanningCandidateComponentProvider.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2021 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.
@@ -62,13 +62,11 @@ import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
 /**
- * A component provider that scans for candidate components starting from a
- * specified base package. Can use the {@linkplain CandidateComponentsIndex component
- * index}, if it is available, and scans the classpath otherwise.
- *
- * <p>Candidate components are identified by applying exclude and include filters.
- * {@link AnnotationTypeFilter} and {@link AssignableTypeFilter} include filters
- * for an annotation/target-type that is annotated with {@link Indexed} are
+ * A component provider that provides candidate components from a base package. Can
+ * use {@link CandidateComponentsIndex the index} if it is available of scans the
+ * classpath otherwise. Candidate components are identified by applying exclude and
+ * include filters. {@link AnnotationTypeFilter}, {@link AssignableTypeFilter} include
+ * filters on an annotation/superclass that are annotated with {@link Indexed} are
  * supported: if any other include filter is specified, the index is ignored and
  * classpath scanning is used instead.
  *
@@ -306,7 +304,7 @@ public class ClassPathScanningCandidateComponentProvider implements EnvironmentC
 
 
 	/**
-	 * Scan the component index or class path for candidate components.
+	 * Scan the class path for candidate components.
 	 * @param basePackage the package to check for annotated classes
 	 * @return a corresponding Set of autodetected bean definitions
 	 */
@@ -320,7 +318,7 @@ public class ClassPathScanningCandidateComponentProvider implements EnvironmentC
 	}
 
 	/**
-	 * Determine if the component index can be used by this instance.
+	 * Determine if the index can be used by this instance.
 	 * @return {@code true} if the index is available and the configuration of this
 	 * instance is supported by it, {@code false} otherwise
 	 * @since 5.0
@@ -456,7 +454,8 @@ public class ClassPathScanningCandidateComponentProvider implements EnvironmentC
 					}
 				}
 				catch (Throwable ex) {
-					throw new BeanDefinitionStoreException("Failed to read candidate component class: " + resource, ex);
+					throw new BeanDefinitionStoreException(
+							"Failed to read candidate component class: " + resource, ex);
 				}
 			}
 		}

spring-context/src/main/java/org/springframework/context/annotation/CommonAnnotationBeanPostProcessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 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.
@@ -402,8 +402,8 @@ public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBean
 				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
 					return;
 				}
-				if (webServiceRefClass != null && bridgedMethod.isAnnotationPresent(webServiceRefClass)) {
-					if (method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
+				if (method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
+					if (webServiceRefClass != null && bridgedMethod.isAnnotationPresent(webServiceRefClass)) {
 						if (Modifier.isStatic(method.getModifiers())) {
 							throw new IllegalStateException("@WebServiceRef annotation is not supported on static methods");
 						}
@@ -413,9 +413,7 @@ public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBean
 						PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
 						currElements.add(new WebServiceRefElement(method, bridgedMethod, pd));
 					}
-				}
-				else if (ejbClass != null && bridgedMethod.isAnnotationPresent(ejbClass)) {
-					if (method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
+					else if (ejbClass != null && bridgedMethod.isAnnotationPresent(ejbClass)) {
 						if (Modifier.isStatic(method.getModifiers())) {
 							throw new IllegalStateException("@EJB annotation is not supported on static methods");
 						}
@@ -425,9 +423,7 @@ public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBean
 						PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
 						currElements.add(new EjbRefElement(method, bridgedMethod, pd));
 					}
-				}
-				else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
-					if (method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
+					else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
 						if (Modifier.isStatic(method.getModifiers())) {
 							throw new IllegalStateException("@Resource annotation is not supported on static methods");
 						}

spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClass.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 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.
@@ -72,6 +72,7 @@ final class ConfigurationClass {
 	 * Create a new {@link ConfigurationClass} with the given name.
 	 * @param metadataReader reader used to parse the underlying {@link Class}
 	 * @param beanName must not be {@code null}
+	 * @see ConfigurationClass#ConfigurationClass(Class, ConfigurationClass)
 	 */
 	ConfigurationClass(MetadataReader metadataReader, String beanName) {
 		Assert.notNull(beanName, "Bean name must not be null");
@@ -85,10 +86,10 @@ final class ConfigurationClass {
 	 * using the {@link Import} annotation or automatically processed as a nested
 	 * configuration class (if importedBy is not {@code null}).
 	 * @param metadataReader reader used to parse the underlying {@link Class}
-	 * @param importedBy the configuration class importing this one
+	 * @param importedBy the configuration class importing this one or {@code null}
 	 * @since 3.1.1
 	 */
-	ConfigurationClass(MetadataReader metadataReader, ConfigurationClass importedBy) {
+	ConfigurationClass(MetadataReader metadataReader, @Nullable ConfigurationClass importedBy) {
 		this.metadata = metadataReader.getAnnotationMetadata();
 		this.resource = metadataReader.getResource();
 		this.importedBy.add(importedBy);
@@ -98,6 +99,7 @@ final class ConfigurationClass {
 	 * Create a new {@link ConfigurationClass} with the given name.
 	 * @param clazz the underlying {@link Class} to represent
 	 * @param beanName name of the {@code @Configuration} class bean
+	 * @see ConfigurationClass#ConfigurationClass(Class, ConfigurationClass)
 	 */
 	ConfigurationClass(Class<?> clazz, String beanName) {
 		Assert.notNull(beanName, "Bean name must not be null");
@@ -111,10 +113,10 @@ final class ConfigurationClass {
 	 * using the {@link Import} annotation or automatically processed as a nested
 	 * configuration class (if imported is {@code true}).
 	 * @param clazz the underlying {@link Class} to represent
-	 * @param importedBy the configuration class importing this one
+	 * @param importedBy the configuration class importing this one (or {@code null})
 	 * @since 3.1.1
 	 */
-	ConfigurationClass(Class<?> clazz, ConfigurationClass importedBy) {
+	ConfigurationClass(Class<?> clazz, @Nullable ConfigurationClass importedBy) {
 		this.metadata = AnnotationMetadata.introspect(clazz);
 		this.resource = new DescriptiveResource(clazz.getName());
 		this.importedBy.add(importedBy);
@@ -124,6 +126,7 @@ final class ConfigurationClass {
 	 * Create a new {@link ConfigurationClass} with the given name.
 	 * @param metadata the metadata for the underlying class to represent
 	 * @param beanName name of the {@code @Configuration} class bean
+	 * @see ConfigurationClass#ConfigurationClass(Class, ConfigurationClass)
 	 */
 	ConfigurationClass(AnnotationMetadata metadata, String beanName) {
 		Assert.notNull(beanName, "Bean name must not be null");
@@ -145,12 +148,12 @@ final class ConfigurationClass {
 		return ClassUtils.getShortName(getMetadata().getClassName());
 	}
 
-	void setBeanName(@Nullable String beanName) {
+	void setBeanName(String beanName) {
 		this.beanName = beanName;
 	}
 
 	@Nullable
-	String getBeanName() {
+	public String getBeanName() {
 		return this.beanName;
 	}
 
@@ -160,7 +163,7 @@ final class ConfigurationClass {
 	 * @since 3.1.1
 	 * @see #getImportedBy()
 	 */
-	boolean isImported() {
+	public boolean isImported() {
 		return !this.importedBy.isEmpty();
 	}
 
@@ -194,10 +197,6 @@ final class ConfigurationClass {
 		this.importedResources.put(importedResource, readerClass);
 	}
 
-	Map<String, Class<? extends BeanDefinitionReader>> getImportedResources() {
-		return this.importedResources;
-	}
-
 	void addImportBeanDefinitionRegistrar(ImportBeanDefinitionRegistrar registrar, AnnotationMetadata importingClassMetadata) {
 		this.importBeanDefinitionRegistrars.put(registrar, importingClassMetadata);
 	}
@@ -206,6 +205,10 @@ final class ConfigurationClass {
 		return this.importBeanDefinitionRegistrars;
 	}
 
+	Map<String, Class<? extends BeanDefinitionReader>> getImportedResources() {
+		return this.importedResources;
+	}
+
 	void validate(ProblemReporter problemReporter) {
 		// A configuration class may not be final (CGLIB limitation) unless it declares proxyBeanMethods=false
 		Map<String, Object> attributes = this.metadata.getAnnotationAttributes(Configuration.class.getName());

spring-context/src/main/java/org/springframework/context/event/ApplicationContextEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -29,7 +29,7 @@ import org.springframework.context.ApplicationEvent;
 public abstract class ApplicationContextEvent extends ApplicationEvent {
 
 	/**
-	 * Create a new {@code ApplicationContextEvent}.
+	 * Create a new ContextStartedEvent.
 	 * @param source the {@code ApplicationContext} that the event is raised for
 	 * (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/event/ContextClosedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -29,7 +29,7 @@ import org.springframework.context.ApplicationContext;
 public class ContextClosedEvent extends ApplicationContextEvent {
 
 	/**
-	 * Create a new {@code ContextClosedEvent}.
+	 * Creates a new ContextClosedEvent.
 	 * @param source the {@code ApplicationContext} that has been closed
 	 * (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/event/ContextRefreshedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -29,7 +29,7 @@ import org.springframework.context.ApplicationContext;
 public class ContextRefreshedEvent extends ApplicationContextEvent {
 
 	/**
-	 * Create a new {@code ContextRefreshedEvent}.
+	 * Create a new ContextRefreshedEvent.
 	 * @param source the {@code ApplicationContext} that has been initialized
 	 * or refreshed (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/event/ContextStartedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -30,7 +30,7 @@ import org.springframework.context.ApplicationContext;
 public class ContextStartedEvent extends ApplicationContextEvent {
 
 	/**
-	 * Create a new {@code ContextStartedEvent}.
+	 * Create a new ContextStartedEvent.
 	 * @param source the {@code ApplicationContext} that has been started
 	 * (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/event/ContextStoppedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -30,7 +30,7 @@ import org.springframework.context.ApplicationContext;
 public class ContextStoppedEvent extends ApplicationContextEvent {
 
 	/**
-	 * Create a new {@code ContextStoppedEvent}.
+	 * Create a new ContextStoppedEvent.
 	 * @param source the {@code ApplicationContext} that has been stopped
 	 * (must not be {@code null})
 	 */

spring-context/src/main/java/org/springframework/context/support/AbstractApplicationContext.java

@@ -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.
@@ -136,6 +136,17 @@ import org.springframework.util.ReflectionUtils;
 public abstract class AbstractApplicationContext extends DefaultResourceLoader
 		implements ConfigurableApplicationContext {
 
+	/**
+	 * The name of the {@link LifecycleProcessor} bean in the context.
+	 * If none is supplied, a {@link DefaultLifecycleProcessor} is used.
+	 * @since 3.0
+	 * @see org.springframework.context.LifecycleProcessor
+	 * @see org.springframework.context.support.DefaultLifecycleProcessor
+	 * @see #start()
+	 * @see #stop()
+	 */
+	public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
+
 	/**
 	 * The name of the {@link MessageSource} bean in the context.
 	 * If none is supplied, message resolution is delegated to the parent.
@@ -156,18 +167,6 @@ public abstract class AbstractApplicationContext extends DefaultResourceLoader
 	 */
 	public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
 
-	/**
-	 * The name of the {@link LifecycleProcessor} bean in the context.
-	 * If none is supplied, a {@link DefaultLifecycleProcessor} is used.
-	 * @since 3.0
-	 * @see org.springframework.context.LifecycleProcessor
-	 * @see org.springframework.context.support.DefaultLifecycleProcessor
-	 * @see #start()
-	 * @see #stop()
-	 */
-	public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
-
-
 	/**
 	 * Boolean flag controlled by a {@code spring.spel.ignore} system property that
 	 * instructs Spring to ignore SpEL, i.e. to not initialize the SpEL infrastructure.
@@ -212,7 +211,7 @@ public abstract class AbstractApplicationContext extends DefaultResourceLoader
 	/** Flag that indicates whether this context has been closed already. */
 	private final AtomicBoolean closed = new AtomicBoolean();
 
-	/** Synchronization monitor for "refresh" and "close". */
+	/** Synchronization monitor for the "refresh" and "destroy". */
 	private final Object startupShutdownMonitor = new Object();
 
 	/** Reference to the JVM shutdown hook, if registered. */
@@ -571,6 +570,7 @@ public abstract class AbstractApplicationContext extends DefaultResourceLoader
 				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
 				// Invoke factory processors registered as beans in the context.
 				invokeBeanFactoryPostProcessors(beanFactory);
+
 				// Register bean processors that intercept bean creation.
 				registerBeanPostProcessors(beanFactory);
 				beanPostProcess.end();
@@ -774,9 +774,8 @@ public abstract class AbstractApplicationContext extends DefaultResourceLoader
 	}
 
 	/**
-	 * Initialize the {@link MessageSource}.
-	 * <p>Uses parent's {@code MessageSource} if none defined in this context.
-	 * @see #MESSAGE_SOURCE_BEAN_NAME
+	 * Initialize the MessageSource.
+	 * Use parent's if none defined in this context.
 	 */
 	protected void initMessageSource() {
 		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
@@ -808,9 +807,8 @@ public abstract class AbstractApplicationContext extends DefaultResourceLoader
 	}
 
 	/**
-	 * Initialize the {@link ApplicationEventMulticaster}.
-	 * <p>Uses {@link SimpleApplicationEventMulticaster} if none defined in the context.
-	 * @see #APPLICATION_EVENT_MULTICASTER_BEAN_NAME
+	 * Initialize the ApplicationEventMulticaster.
+	 * Uses SimpleApplicationEventMulticaster if none defined in the context.
 	 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
 	 */
 	protected void initApplicationEventMulticaster() {
@@ -833,16 +831,15 @@ public abstract class AbstractApplicationContext extends DefaultResourceLoader
 	}
 
 	/**
-	 * Initialize the {@link LifecycleProcessor}.
-	 * <p>Uses {@link DefaultLifecycleProcessor} if none defined in the context.
-	 * @since 3.0
-	 * @see #LIFECYCLE_PROCESSOR_BEAN_NAME
+	 * Initialize the LifecycleProcessor.
+	 * Uses DefaultLifecycleProcessor if none defined in the context.
 	 * @see org.springframework.context.support.DefaultLifecycleProcessor
 	 */
 	protected void initLifecycleProcessor() {
 		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
 		if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
-			this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
+			this.lifecycleProcessor =
+					beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
 			if (logger.isTraceEnabled()) {
 				logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
 			}

spring-context/src/main/java/org/springframework/context/support/AbstractRefreshableApplicationContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -126,7 +126,6 @@ public abstract class AbstractRefreshableApplicationContext extends AbstractAppl
 		try {
 			DefaultListableBeanFactory beanFactory = createBeanFactory();
 			beanFactory.setSerializationId(getId());
-			beanFactory.setApplicationStartup(getApplicationStartup());
 			customizeBeanFactory(beanFactory);
 			loadBeanDefinitions(beanFactory);
 			this.beanFactory = beanFactory;

spring-context/src/main/java/org/springframework/context/support/DefaultLifecycleProcessor.java

@@ -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.
@@ -45,11 +45,7 @@ import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
- * Spring's default implementation of the {@link LifecycleProcessor} strategy.
- *
- * <p>Provides interaction with {@link Lifecycle} and {@link SmartLifecycle} beans in
- * groups for specific phases, on startup/shutdown as well as for explicit start/stop
- * interactions on a {@link org.springframework.context.ConfigurableApplicationContext}.
+ * Default implementation of the {@link LifecycleProcessor} strategy.
  *
  * @author Mark Fisher
  * @author Juergen Hoeller
@@ -149,13 +145,13 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor
 
 		lifecycleBeans.forEach((beanName, bean) -> {
 			if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
-				int startupPhase = getPhase(bean);
-				phases.computeIfAbsent(startupPhase,
-						phase -> new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly)
+				int phase = getPhase(bean);
+				phases.computeIfAbsent(
+						phase,
+						p -> new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly)
 				).add(beanName, bean);
 			}
 		});
-
 		if (!phases.isEmpty()) {
 			phases.values().forEach(LifecycleGroup::start);
 		}
@@ -195,7 +191,6 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor
 	private void stopBeans() {
 		Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
 		Map<Integer, LifecycleGroup> phases = new HashMap<>();
-
 		lifecycleBeans.forEach((beanName, bean) -> {
 			int shutdownPhase = getPhase(bean);
 			LifecycleGroup group = phases.get(shutdownPhase);
@@ -205,7 +200,6 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor
 			}
 			group.add(beanName, bean);
 		});
-
 		if (!phases.isEmpty()) {
 			List<Integer> keys = new ArrayList<>(phases.keySet());
 			keys.sort(Collections.reverseOrder());
@@ -320,8 +314,6 @@ public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactor
 	/**
 	 * Helper class for maintaining a group of Lifecycle beans that should be started
 	 * and stopped together based on their 'phase' value (or the default value of 0).
-	 * The group is expected to be created in an ad-hoc fashion and group members are
-	 * expected to always have the same 'phase' value.
 	 */
 	private class LifecycleGroup {
 

spring-context/src/main/java/org/springframework/context/support/ReloadableResourceBundleMessageSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,7 +27,6 @@ import java.util.Map;
 import java.util.Properties;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
 import org.springframework.context.ResourceLoaderAware;
@@ -144,7 +143,7 @@ public class ReloadableResourceBundleMessageSource extends AbstractResourceBased
 
 	/**
 	 * Set the PropertiesPersister to use for parsing properties files.
-	 * <p>The default is {@code ResourcePropertiesPersister}.
+	 * <p>The default is ResourcePropertiesPersister.
 	 * @see ResourcePropertiesPersister#INSTANCE
 	 */
 	public void setPropertiesPersister(@Nullable PropertiesPersister propertiesPersister) {
@@ -402,7 +401,7 @@ public class ReloadableResourceBundleMessageSource extends AbstractResourceBased
 
 	/**
 	 * Refresh the PropertiesHolder for the given bundle filename.
-	 * <p>The holder can be {@code null} if not cached before, or a timed-out cache entry
+	 * The holder can be {@code null} if not cached before, or a timed-out cache entry
 	 * (potentially getting re-validated against the current last-modified timestamp).
 	 * @param filename the bundle filename (basename + Locale)
 	 * @param propHolder the current PropertiesHolder for the bundle
@@ -563,7 +562,7 @@ public class ReloadableResourceBundleMessageSource extends AbstractResourceBased
 
 		private volatile long refreshTimestamp = -2;
 
-		private final Lock refreshLock = new ReentrantLock();
+		private final ReentrantLock refreshLock = new ReentrantLock();
 
 		/** Cache to hold already generated MessageFormats per message code. */
 		private final ConcurrentMap<String, Map<Locale, MessageFormat>> cachedMessageFormats =

spring-context/src/main/java/org/springframework/format/datetime/DateFormatter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 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.
@@ -22,10 +22,8 @@ import java.text.SimpleDateFormat;
 import java.util.Collections;
 import java.util.Date;
 import java.util.EnumMap;
-import java.util.LinkedHashSet;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Set;
 import java.util.TimeZone;
 
 import org.springframework.format.Formatter;
@@ -37,14 +35,9 @@ import org.springframework.util.StringUtils;
 
 /**
  * A formatter for {@link java.util.Date} types.
- *
  * <p>Supports the configuration of an explicit date time pattern, timezone,
  * locale, and fallback date time patterns for lenient parsing.
  *
- * <p>Common ISO patterns for UTC instants are applied at millisecond precision.
- * Note that {@link org.springframework.format.datetime.standard.InstantFormatter}
- * is recommended for flexible UTC parsing into a {@link java.time.Instant} instead.
- *
  * @author Keith Donald
  * @author Juergen Hoeller
  * @author Phillip Webb
@@ -58,21 +51,12 @@ public class DateFormatter implements Formatter<Date> {
 
 	private static final Map<ISO, String> ISO_PATTERNS;
 
-	private static final Map<ISO, String> ISO_FALLBACK_PATTERNS;
-
 	static {
-		// We use an EnumMap instead of Map.of(...) since the former provides better performance.
 		Map<ISO, String> formats = new EnumMap<>(ISO.class);
 		formats.put(ISO.DATE, "yyyy-MM-dd");
 		formats.put(ISO.TIME, "HH:mm:ss.SSSXXX");
 		formats.put(ISO.DATE_TIME, "yyyy-MM-dd'T'HH:mm:ss.SSSXXX");
 		ISO_PATTERNS = Collections.unmodifiableMap(formats);
-
-		// Fallback format for the time part without milliseconds.
-		Map<ISO, String> fallbackFormats = new EnumMap<>(ISO.class);
-		fallbackFormats.put(ISO.TIME, "HH:mm:ssXXX");
-		fallbackFormats.put(ISO.DATE_TIME, "yyyy-MM-dd'T'HH:mm:ssXXX");
-		ISO_FALLBACK_PATTERNS = Collections.unmodifiableMap(fallbackFormats);
 	}
 
 
@@ -217,16 +201,8 @@ public class DateFormatter implements Formatter<Date> {
 			return getDateFormat(locale).parse(text);
 		}
 		catch (ParseException ex) {
-			Set<String> fallbackPatterns = new LinkedHashSet<>();
-			String isoPattern = ISO_FALLBACK_PATTERNS.get(this.iso);
-			if (isoPattern != null) {
-				fallbackPatterns.add(isoPattern);
-			}
 			if (!ObjectUtils.isEmpty(this.fallbackPatterns)) {
-				Collections.addAll(fallbackPatterns, this.fallbackPatterns);
-			}
-			if (!fallbackPatterns.isEmpty()) {
-				for (String pattern : fallbackPatterns) {
+				for (String pattern : this.fallbackPatterns) {
 					try {
 						DateFormat dateFormat = configureDateFormat(new SimpleDateFormat(pattern, locale));
 						// Align timezone for parsing format with printing format if ISO is set.
@@ -244,8 +220,8 @@ public class DateFormatter implements Formatter<Date> {
 			}
 			if (this.source != null) {
 				ParseException parseException = new ParseException(
-						String.format("Unable to parse date time value \"%s\" using configuration from %s", text, this.source),
-						ex.getErrorOffset());
+					String.format("Unable to parse date time value \"%s\" using configuration from %s", text, this.source),
+					ex.getErrorOffset());
 				parseException.initCause(ex);
 				throw parseException;
 			}

spring-context/src/main/java/org/springframework/format/datetime/standard/InstantFormatter.java

@@ -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.
@@ -41,12 +41,12 @@ public class InstantFormatter implements Formatter<Instant> {
 
 	@Override
 	public Instant parse(String text, Locale locale) throws ParseException {
-		if (!text.isEmpty() && Character.isAlphabetic(text.charAt(0))) {
+		if (text.length() > 0 && Character.isAlphabetic(text.charAt(0))) {
 			// assuming RFC-1123 value a la "Tue, 3 Jun 2008 11:05:30 GMT"
 			return Instant.from(DateTimeFormatter.RFC_1123_DATE_TIME.parse(text));
 		}
 		else {
-			// assuming UTC instant a la "2007-12-03T10:15:30.000Z"
+			// assuming UTC instant a la "2007-12-03T10:15:30.00Z"
 			return Instant.parse(text);
 		}
 	}

spring-context/src/main/java/org/springframework/scheduling/TaskScheduler.java

@@ -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.
@@ -29,7 +29,7 @@ import org.springframework.lang.Nullable;
  * {@link Runnable Runnables} based on different kinds of triggers.
  *
  * <p>This interface is separate from {@link SchedulingTaskExecutor} since it
- * usually represents a different kind of backend, i.e. a thread pool with
+ * usually represents for a different kind of backend, i.e. a thread pool with
  * different characteristics and capabilities. Implementations may implement
  * both interfaces if they can handle both kinds of execution characteristics.
  *

spring-context/src/main/java/org/springframework/scheduling/annotation/Scheduled.java

@@ -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.
@@ -100,9 +100,9 @@ public @interface Scheduled {
 
 	/**
 	 * A time zone for which the cron expression will be resolved. By default, this
-	 * attribute is the empty String (i.e. the scheduler's time zone will be used).
+	 * attribute is the empty String (i.e. the server's local time zone will be used).
 	 * @return a zone id accepted by {@link java.util.TimeZone#getTimeZone(String)},
-	 * or an empty String to indicate the scheduler's default time zone
+	 * or an empty String to indicate the server's default time zone
 	 * @since 4.0
 	 * @see org.springframework.scheduling.support.CronTrigger#CronTrigger(String, java.util.TimeZone)
 	 * @see java.util.TimeZone

spring-context/src/main/java/org/springframework/scheduling/annotation/ScheduledAnnotationBeanPostProcessor.java

@@ -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.
@@ -27,6 +27,7 @@ import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.TimeZone;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
@@ -83,7 +84,7 @@ import org.springframework.util.StringValueResolver;
  * "fixedRate", "fixedDelay", or "cron" expression provided via the annotation.
  *
  * <p>This post-processor is automatically registered by Spring's
- * {@code <task:annotation-driven>} XML element and also by the
+ * {@code <task:annotation-driven>} XML element, and also by the
  * {@link EnableScheduling @EnableScheduling} annotation.
  *
  * <p>Autodetects any {@link SchedulingConfigurer} instances in the container,
@@ -433,14 +434,14 @@ public class ScheduledAnnotationBeanPostProcessor
 					Assert.isTrue(initialDelay == -1, "'initialDelay' not supported for cron triggers");
 					processedSchedule = true;
 					if (!Scheduled.CRON_DISABLED.equals(cron)) {
-						CronTrigger trigger;
+						TimeZone timeZone;
 						if (StringUtils.hasText(zone)) {
-							trigger = new CronTrigger(cron, StringUtils.parseTimeZoneString(zone));
+							timeZone = StringUtils.parseTimeZoneString(zone);
 						}
 						else {
-							trigger = new CronTrigger(cron);
+							timeZone = TimeZone.getDefault();
 						}
-						tasks.add(this.registrar.scheduleCronTask(new CronTask(runnable, trigger)));
+						tasks.add(this.registrar.scheduleCronTask(new CronTask(runnable, new CronTrigger(cron, timeZone))));
 					}
 				}
 			}

spring-context/src/main/java/org/springframework/scheduling/concurrent/ConcurrentTaskExecutor.java

@@ -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.
@@ -133,6 +133,11 @@ public class ConcurrentTaskExecutor implements AsyncListenableTaskExecutor, Sche
 	 * execution callback (which may be a wrapper around the user-supplied task).
 	 * <p>The primary use case is to set some execution context around the task's
 	 * invocation, or to provide some monitoring/statistics for task execution.
+	 * <p><b>NOTE:</b> Exception handling in {@code TaskDecorator} implementations
+	 * is limited to plain {@code Runnable} execution via {@code execute} calls.
+	 * In case of {@code #submit} calls, the exposed {@code Runnable} will be a
+	 * {@code FutureTask} which does not propagate any exceptions; you might
+	 * have to cast it and call {@code Future#get} to evaluate exceptions.
 	 * @since 4.3
 	 */
 	public final void setTaskDecorator(TaskDecorator taskDecorator) {
@@ -173,10 +178,11 @@ public class ConcurrentTaskExecutor implements AsyncListenableTaskExecutor, Sche
 	}
 
 
-	private TaskExecutorAdapter getAdaptedExecutor(Executor originalExecutor) {
-		TaskExecutorAdapter adapter =
-				(managedExecutorServiceClass != null && managedExecutorServiceClass.isInstance(originalExecutor) ?
-						new ManagedTaskExecutorAdapter(originalExecutor) : new TaskExecutorAdapter(originalExecutor));
+	private TaskExecutorAdapter getAdaptedExecutor(Executor concurrentExecutor) {
+		if (managedExecutorServiceClass != null && managedExecutorServiceClass.isInstance(concurrentExecutor)) {
+			return new ManagedTaskExecutorAdapter(concurrentExecutor);
+		}
+		TaskExecutorAdapter adapter = new TaskExecutorAdapter(concurrentExecutor);
 		if (this.taskDecorator != null) {
 			adapter.setTaskDecorator(this.taskDecorator);
 		}

spring-context/src/main/java/org/springframework/scheduling/concurrent/ConcurrentTaskScheduler.java

@@ -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.
@@ -177,7 +177,6 @@ public class ConcurrentTaskScheduler extends ConcurrentTaskExecutor implements T
 	 * @see Clock#systemDefaultZone()
 	 */
 	public void setClock(Clock clock) {
-		Assert.notNull(clock, "Clock must not be null");
 		this.clock = clock;
 	}
 

spring-context/src/main/java/org/springframework/scheduling/concurrent/ThreadPoolTaskScheduler.java

@@ -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.
@@ -45,9 +45,8 @@ import org.springframework.util.concurrent.ListenableFuture;
 import org.springframework.util.concurrent.ListenableFutureTask;
 
 /**
- * A standard implementation of Spring's {@link TaskScheduler} interface, wrapping
- * a native {@link java.util.concurrent.ScheduledThreadPoolExecutor} and providing
- * all applicable configuration options for it.
+ * Implementation of Spring's {@link TaskScheduler} interface, wrapping
+ * a native {@link java.util.concurrent.ScheduledThreadPoolExecutor}.
  *
  * @author Juergen Hoeller
  * @author Mark Fisher
@@ -155,7 +154,6 @@ public class ThreadPoolTaskScheduler extends ExecutorConfigurationSupport
 	 * @see Clock#systemDefaultZone()
 	 */
 	public void setClock(Clock clock) {
-		Assert.notNull(clock, "Clock must not be null");
 		this.clock = clock;
 	}
 

spring-context/src/main/java/org/springframework/scheduling/support/BitsCronField.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2021 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,15 +29,17 @@ import org.springframework.util.StringUtils;
  * Created using the {@code parse*} methods.
  *
  * @author Arjen Poutsma
- * @author Juergen Hoeller
  * @since 5.3
  */
 final class BitsCronField extends CronField {
 
-	public static final BitsCronField ZERO_NANOS = forZeroNanos();
-
 	private static final long MASK = 0xFFFFFFFFFFFFFFFFL;
 
+
+	@Nullable
+	private static BitsCronField zeroNanos = null;
+
+
 	// we store at most 60 bits, for seconds and minutes, so a 64-bit long suffices
 	private long bits;
 
@@ -46,14 +48,16 @@ final class BitsCronField extends CronField {
 		super(type);
 	}
 
-
 	/**
 	 * Return a {@code BitsCronField} enabled for 0 nanoseconds.
 	 */
-	private static BitsCronField forZeroNanos() {
-		BitsCronField field = new BitsCronField(Type.NANO);
-		field.setBit(0);
-		return field;
+	public static BitsCronField zeroNanos() {
+		if (zeroNanos == null) {
+			BitsCronField field = new BitsCronField(Type.NANO);
+			field.setBit(0);
+			zeroNanos = field;
+		}
+		return zeroNanos;
 	}
 
 	/**
@@ -104,6 +108,7 @@ final class BitsCronField extends CronField {
 		return result;
 	}
 
+
 	private static BitsCronField parseDate(String value, BitsCronField.Type type) {
 		if (value.equals("?")) {
 			value = "*";
@@ -169,7 +174,6 @@ final class BitsCronField extends CronField {
 		}
 	}
 
-
 	@Nullable
 	@Override
 	public <T extends Temporal & Comparable<? super T>> T nextOrSame(T temporal) {
@@ -213,6 +217,7 @@ final class BitsCronField extends CronField {
 		else {
 			return -1;
 		}
+
 	}
 
 	private void setBits(ValueRange range) {
@@ -242,20 +247,7 @@ final class BitsCronField extends CronField {
 	}
 
 	private void clearBit(int index) {
-		this.bits &= ~(1L << index);
-	}
-
-
-	@Override
-	public boolean equals(Object other) {
-		if (this == other) {
-			return true;
-		}
-		if (!(other instanceof BitsCronField)) {
-			return false;
-		}
-		BitsCronField otherField = (BitsCronField) other;
-		return (type() == otherField.type() && this.bits == otherField.bits);
+		this.bits &=  ~(1L << index);
 	}
 
 	@Override
@@ -263,6 +255,18 @@ final class BitsCronField extends CronField {
 		return Long.hashCode(this.bits);
 	}
 
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof BitsCronField)) {
+			return false;
+		}
+		BitsCronField other = (BitsCronField) o;
+		return type() == other.type() && this.bits == other.bits;
+	}
+
 	@Override
 	public String toString() {
 		StringBuilder builder = new StringBuilder(type().toString());