Bumping versions

.github/dependabot.yml

@@ -1,49 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    target-branch: "3.1.x" # oldest OSS supported branch
-    schedule:
-      interval: "weekly"
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    target-branch: "4.0.x" # oldest OSS supported branch
-    schedule:
-      interval: "weekly"
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    target-branch: "main"
-    schedule:
-      interval: "weekly"
-  - package-ecosystem: maven
-    directory: /
-    schedule:
-      interval: daily
-    target-branch: 3.1.x
-    ignore:
-      # only upgrade patch versions for maintenance branch
-      - dependency-name: "*"
-        update-types:
-          - version-update:semver-major
-          - version-update:semver-minor
-  - package-ecosystem: maven
-    directory: /
-    schedule:
-      interval: daily
-    target-branch: 4.0.x
-    ignore:
-      # only upgrade patch versions for maintenance branch
-      - dependency-name: "*"
-        update-types:
-          - version-update:semver-major
-          - version-update:semver-minor
-  - package-ecosystem: maven
-    directory: /
-    schedule:
-      interval: daily
-    target-branch: main
-    ignore:
-      # only upgrade by minor or patch
-      - dependency-name: "*"
-        update-types:
-          - version-update:semver-major

.github/workflows/deploy-docs.yml

@@ -1,32 +0,0 @@
-name: Deploy Docs
-on:
-  push:
-    branches-ignore: [ gh-pages ]
-    tags: '**'
-  repository_dispatch:
-    types: request-build-reference # legacy
-  #schedule:
-  #- cron: '0 10 * * *' # Once per day at 10am UTC
-  workflow_dispatch:
-permissions:
-  actions: write
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    # if: github.repository_owner == 'spring-cloud'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: docs-build
-          fetch-depth: 1
-      - name: Dispatch (partial build)
-        if: github.ref_type == 'branch'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: gh workflow run deploy-docs.yml -r $(git rev-parse --abbrev-ref HEAD) -f build-refname=${{ github.ref_name }}
-      - name: Dispatch (full build)
-        if: github.ref_type == 'tag'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: gh workflow run deploy-docs.yml -r $(git rev-parse --abbrev-ref HEAD)

.github/workflows/maven.yml

@@ -5,9 +5,9 @@ name: Build
 
 on:
   push:
-    branches: [ main ]
+    branches: [ 3.0.x ]
   pull_request:
-    branches: [ main ]
+    branches: [ 3.0.x ]
 
 jobs:
   build:
@@ -16,18 +16,18 @@ jobs:
 
     strategy:
       matrix:
-        java: ["17"]
+        java: ["8", "11", "16"]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
       - name: Set up JDK ${{ matrix.java }}
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v2
         with:
           distribution: 'zulu'
           java-version: ${{ matrix.java }}
           cache: 'maven'
       - name: Build with Maven
         run: ./mvnw clean install -B -U -P sonar
-      - uses: codecov/codecov-action@v3
+      - uses: codecov/codecov-action@v1
         with:
           fail_ci_if_error: true

.gitignore

@@ -1,6 +1,3 @@
-/application.yml
-/application.properties
-asciidoctor.css
 *~
 #*
 *#
@@ -8,7 +5,6 @@ asciidoctor.css
 .classpath
 .project
 .settings/
-.settings
 .springBeans
 target/
 bin/
@@ -22,16 +18,7 @@ _site/
 .shelf
 *.swp
 *.swo
-/spring-cloud-release-tools*.jar
-antrun
 .vscode/
 .flattened-pom.xml
-node
-node_modules
-build
-_configprops.adoc
-_spans.adoc
-_metrics.adoc
-_conventions.adoc
-package.json
-package-lock.json
+.sdkmanrc
+

.java-version

@@ -1 +0,0 @@
-17

.mvn/maven.config

@@ -1,2 +1 @@
--DaltSnapshotDeploymentRepository=repo.spring.io::default::https://repo.spring.io/libs-snapshot-local
--P spring
+-DaltSnapshotDeploymentRepository=repo.spring.io::default::https://repo.spring.io/libs-snapshot-local -P spring

.mvn/wrapper/maven-wrapper.properties

@@ -1,18 +1 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.4/apache-maven-3.9.4-bin.zip
-wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar
+distributionUrl=https://repo1.maven.org/maven2/org/apache/maven/apache-maven/3.5.0/apache-maven-3.5.0-bin.zip

.sdkmanrc

@@ -1,3 +0,0 @@
-# Enable auto-env through the sdkman_auto_env config
-# Add key=value pairs of SDKs to use below
-java=17.0.1-tem

README.adoc

@@ -7,21 +7,43 @@ Edit the files in the src/main/asciidoc/ directory instead.
 
 image::https://github.com/spring-cloud/spring-cloud-openfeign/workflows/Build/badge.svg?branch=main&style=svg["Build",link="https://github.com/spring-cloud/spring-cloud-openfeign/actions"]
 
-image:https://codecov.io/gh/spring-cloud/spring-cloud-openfeign/branch/main/graph/badge.svg["Codecov", link="https://app.codecov.io/gh/spring-cloud/spring-cloud-openfeign/tree/main"]
+image:https://codecov.io/gh/spring-cloud/spring-cloud-openfeign/branch/main/graph/badge.svg["Codecov", link="https://codecov.io/gh/spring-cloud/spring-cloud-openfeign"]
+
+image:https://api.codacy.com/project/badge/Grade/97b04c4e609c4b4f86b415e4437a6484["Codacy code quality", link="https://www.codacy.com/app/Spring-Cloud/spring-cloud-openfeign?utm_source=github.com&utm_medium=referral&utm_content=spring-cloud/spring-cloud-openfeign&utm_campaign=Badge_Grade"]
+
+:doctype: book
+:idprefix:
+:idseparator: -
+:toc: left
+:toclevels: 4
+:tabsize: 4
+:numbered:
+:sectanchors:
+:sectnums:
+:icons: font
+:hide-uri-scheme:
+:docinfo: shared,private
+
+:sc-ext: java
+:project-full-name: Spring Cloud OpenFeign
+:all: {asterisk}{asterisk}
+
+:core_path: {project-root}/spring-cloud-openfeign-core
+
+This project provides OpenFeign integrations for Spring Boot apps through autoconfiguration
+and binding to the Spring Environment and other Spring programming model idioms.
 
 
-[[features]]
 == Features
 
 * Declarative REST Client: Feign creates a dynamic implementation of an interface decorated with JAX-RS or Spring MVC annotations
 
-[[building]]
 == Building
 
+
 :jdkversion: 17
 
-[[basic-compile-and-test]]
-== Basic Compile and Test
+=== Basic Compile and Test
 
 To build the source you will need to install JDK {jdkversion}.
 
@@ -48,36 +70,31 @@ source control.
 The projects that require middleware (i.e. Redis) for testing generally
 require that a local instance of [Docker](https://www.docker.com/get-started) is installed and running.
 
-[[documentation]]
-== Documentation
 
-The spring-cloud-build module has a "docs" profile, and if you switch
-that on it will try to build asciidoc sources using https://docs.antora.org/antora/latest/[Antora] from
-`modules/ROOT/`.
+=== Documentation
 
-As part of that process it will look for a
-`docs/src/main/asciidoc/README.adoc` and process it by loading all the includes, but not
+The spring-cloud-build module has a "docs" profile, and if you switch
+that on it will try to build asciidoc sources from
+`src/main/asciidoc`. As part of that process it will look for a
+`README.adoc` and process it by loading all the includes, but not
 parsing or rendering it, just copying it to `${main.basedir}`
-(defaults to `$\{basedir}`, i.e. the root of the project). If there are
+(defaults to `${basedir}`, i.e. the root of the project). If there are
 any changes in the README it will then show up after a Maven build as
 a modified file in the correct place. Just commit it and push the change.
 
-[[working-with-the-code]]
-== Working with the code
+=== Working with the code
 If you don't have an IDE preference we would recommend that you use
 https://www.springsource.com/developer/sts[Spring Tools Suite] or
 https://eclipse.org[Eclipse] when working with the code. We use the
 https://eclipse.org/m2e/[m2eclipse] eclipse plugin for maven support. Other IDEs and tools
 should also work without issue as long as they use Maven 3.3.3 or better.
 
-[[activate-the-spring-maven-profile]]
-=== Activate the Spring Maven profile
+==== Activate the Spring Maven profile
 Spring Cloud projects require the 'spring' Maven profile to be activated to resolve
 the spring milestone and snapshot repositories. Use your preferred IDE to set this
 profile to be active, or you may experience build errors.
 
-[[importing-into-eclipse-with-m2eclipse]]
-=== Importing into eclipse with m2eclipse
+==== Importing into eclipse with m2eclipse
 We recommend the https://eclipse.org/m2e/[m2eclipse] eclipse plugin when working with
 eclipse. If you don't already have m2eclipse installed it is available from the "eclipse
 marketplace".
@@ -91,8 +108,7 @@ add the "spring" profile to your `settings.xml`. Alternatively you can
 copy the repository settings from the "spring" profile of the parent
 pom into your `settings.xml`.
 
-[[importing-into-eclipse-without-m2eclipse]]
-=== Importing into eclipse without m2eclipse
+==== Importing into eclipse without m2eclipse
 If you prefer not to use m2eclipse you can generate eclipse project metadata using the
 following command:
 
@@ -105,12 +121,240 @@ The generated eclipse projects can be imported by selecting `import existing pro
 from the `file` menu.
 
 
-[[contributing]]
+
 == Contributing
 
-NOTE: Spring Cloud is released under the non-restrictive Apache 2.0 license. If you would like to contribute to this section of the documentation or if you find an error, please find the source code and issue trackers in the project at {github-project}[github].
+:spring-cloud-build-branch: master
+
+Spring Cloud is released under the non-restrictive Apache 2.0 license,
+and follows a very standard Github development process, using Github
+tracker for issues and merging pull requests into master. If you want
+to contribute even something trivial please do not hesitate, but
+follow the guidelines below.
+
+=== Sign the Contributor License Agreement
+Before we accept a non-trivial patch or pull request we will need you to sign the
+https://cla.pivotal.io/sign/spring[Contributor License Agreement].
+Signing the contributor's agreement does not grant anyone commit rights to the main
+repository, but it does mean that we can accept your contributions, and you will get an
+author credit if we do.  Active contributors might be asked to join the core team, and
+given the ability to merge pull requests.
+
+=== Code of Conduct
+This project adheres to the Contributor Covenant https://github.com/spring-cloud/spring-cloud-build/blob/master/docs/src/main/asciidoc/code-of-conduct.adoc[code of
+conduct]. By participating, you  are expected to uphold this code. Please report
+unacceptable behavior to spring-code-of-conduct@pivotal.io.
+
+=== Code Conventions and Housekeeping
+None of these is essential for a pull request, but they will all help.  They can also be
+added after the original pull request but before a merge.
+
+* Use the Spring Framework code format conventions. If you use Eclipse
+  you can import formatter settings using the
+  `eclipse-code-formatter.xml` file from the
+  https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-dependencies-parent/eclipse-code-formatter.xml[Spring
+  Cloud Build] project. If using IntelliJ, you can use the
+  https://plugins.jetbrains.com/plugin/6546[Eclipse Code Formatter
+  Plugin] to import the same file.
+* Make sure all new `.java` files to have a simple Javadoc class comment with at least an
+  `@author` tag identifying you, and preferably at least a paragraph on what the class is
+  for.
+* Add the ASF license header comment to all new `.java` files (copy from existing files
+  in the project)
+* Add yourself as an `@author` to the .java files that you modify substantially (more
+  than cosmetic changes).
+* Add some Javadocs and, if you change the namespace, some XSD doc elements.
+* A few unit tests would help a lot as well -- someone has to do it.
+* If no-one else is using your branch, please rebase it against the current master (or
+  other target branch in the main project).
+* When writing a commit message please follow https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html[these conventions],
+  if you are fixing an existing issue please add `Fixes gh-XXXX` at the end of the commit
+  message (where XXXX is the issue number).
+
+=== Checkstyle
+
+Spring Cloud Build comes with a set of checkstyle rules. You can find them in the `spring-cloud-build-tools` module. The most notable files under the module are:
+
+.spring-cloud-build-tools/
+----
+└── src
+    ├── checkstyle
+    │   └── checkstyle-suppressions.xml <3>
+    └── main
+        └── resources
+            ├── checkstyle-header.txt <2>
+            └── checkstyle.xml <1>
+----
+<1> Default Checkstyle rules
+<2> File header setup
+<3> Default suppression rules
+
+==== Checkstyle configuration
+
+Checkstyle rules are *disabled by default*. To add checkstyle to your project just define the following properties and plugins.
+
+.pom.xml
+----
+<properties>
+<maven-checkstyle-plugin.failsOnError>true</maven-checkstyle-plugin.failsOnError> <1>
+        <maven-checkstyle-plugin.failsOnViolation>true
+        </maven-checkstyle-plugin.failsOnViolation> <2>
+        <maven-checkstyle-plugin.includeTestSourceDirectory>true
+        </maven-checkstyle-plugin.includeTestSourceDirectory> <3>
+</properties>
+
+<build>
+        <plugins>
+            <plugin> <4>
+                <groupId>io.spring.javaformat</groupId>
+                <artifactId>spring-javaformat-maven-plugin</artifactId>
+            </plugin>
+            <plugin> <5>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-checkstyle-plugin</artifactId>
+            </plugin>
+        </plugins>
+
+    <reporting>
+        <plugins>
+            <plugin> <5>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-checkstyle-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </reporting>
+</build>
+----
+<1> Fails the build upon Checkstyle errors
+<2> Fails the build upon Checkstyle violations
+<3> Checkstyle analyzes also the test sources
+<4> Add the Spring Java Format plugin that will reformat your code to pass most of the Checkstyle formatting rules
+<5> Add checkstyle plugin to your build and reporting phases
+
+If you need to suppress some rules (e.g. line length needs to be longer), then it's enough for you to define a file under `${project.root}/src/checkstyle/checkstyle-suppressions.xml` with your suppressions. Example:
+
+.projectRoot/src/checkstyle/checkstyle-suppresions.xml
+----
+<?xml version="1.0"?>
+<!DOCTYPE suppressions PUBLIC
+		"-//Puppy Crawl//DTD Suppressions 1.1//EN"
+		"https://www.puppycrawl.com/dtds/suppressions_1_1.dtd">
+<suppressions>
+	<suppress files=".*ConfigServerApplication\.java" checks="HideUtilityClassConstructor"/>
+	<suppress files=".*ConfigClientWatch\.java" checks="LineLengthCheck"/>
+</suppressions>
+----
+
+It's advisable to copy the `${spring-cloud-build.rootFolder}/.editorconfig` and `${spring-cloud-build.rootFolder}/.springformat` to your project. That way, some default formatting rules will be applied. You can do so by running this script:
+
+```bash
+$ curl https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/.editorconfig -o .editorconfig
+$ touch .springformat
+```
+
+=== IDE setup
+
+==== Intellij IDEA
+
+In order to setup Intellij you should import our coding conventions, inspection profiles and set up the checkstyle plugin.
+The following files can be found in the https://github.com/spring-cloud/spring-cloud-build/tree/master/spring-cloud-build-tools[Spring Cloud Build] project.
+
+.spring-cloud-build-tools/
+----
+└── src
+    ├── checkstyle
+    │   └── checkstyle-suppressions.xml <3>
+    └── main
+        └── resources
+            ├── checkstyle-header.txt <2>
+            ├── checkstyle.xml <1>
+            └── intellij
+                ├── Intellij_Project_Defaults.xml <4>
+                └── Intellij_Spring_Boot_Java_Conventions.xml <5>
+----
+<1> Default Checkstyle rules
+<2> File header setup
+<3> Default suppression rules
+<4> Project defaults for Intellij that apply most of Checkstyle rules
+<5> Project style conventions for Intellij that apply most of Checkstyle rules
+
+.Code style
+
+image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-code-style.png[Code style]
+
+Go to `File` -> `Settings` -> `Editor` -> `Code style`. There click on the icon next to the `Scheme` section. There, click on the `Import Scheme` value and pick the `Intellij IDEA code style XML` option. Import the `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Spring_Boot_Java_Conventions.xml` file.
+
+.Inspection profiles
+
+image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-inspections.png[Code style]
+
+Go to `File` -> `Settings` -> `Editor` -> `Inspections`. There click on the icon next to the `Profile` section. There, click on the `Import Profile` and import the `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Project_Defaults.xml` file.
+
+.Checkstyle
+
+To have Intellij work with Checkstyle, you have to install the `Checkstyle` plugin. It's advisable to also install the `Assertions2Assertj` to automatically convert the JUnit assertions
+
+image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-checkstyle.png[Checkstyle]
+
+Go to `File` -> `Settings` -> `Other settings` -> `Checkstyle`. There click on the `+` icon in the `Configuration file` section. There, you'll have to define where the checkstyle rules should be picked from. In the image above, we've picked the rules from the cloned Spring Cloud Build repository. However, you can point to the Spring Cloud Build's GitHub repository (e.g. for the `checkstyle.xml` : `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle.xml`). We need to provide the following variables:
+
+- `checkstyle.header.file` - please point it to the Spring Cloud Build's, `spring-cloud-build-tools/src/main/resources/checkstyle-header.txt` file either in your cloned repo or via the `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle-header.txt` URL.
+- `checkstyle.suppressions.file` - default suppressions. Please point it to the Spring Cloud Build's, `spring-cloud-build-tools/src/checkstyle/checkstyle-suppressions.xml` file either in your cloned repo or via the `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/checkstyle/checkstyle-suppressions.xml` URL.
+- `checkstyle.additional.suppressions.file` - this variable corresponds to suppressions in your local project. E.g. you're working on `spring-cloud-contract`. Then point to the `project-root/src/checkstyle/checkstyle-suppressions.xml` folder. Example for `spring-cloud-contract` would be: `/home/username/spring-cloud-contract/src/checkstyle/checkstyle-suppressions.xml`.
+
+IMPORTANT: Remember to set the `Scan Scope` to `All sources` since we apply checkstyle rules for production and test sources.
+
+=== Duplicate Finder
+
+Spring Cloud Build brings along the  `basepom:duplicate-finder-maven-plugin`, that enables flagging duplicate and conflicting classes and resources on the java classpath.
+
+==== Duplicate Finder configuration
+
+Duplicate finder is *enabled by default* and will run in the `verify` phase of your Maven build, but it will only take effect in your project if you add the `duplicate-finder-maven-plugin` to the `build` section of the projecst's `pom.xml`.
+
+.pom.xml
+[source,xml]
+----
+<build>
+    <plugins>
+        <plugin>
+            <groupId>org.basepom.maven</groupId>
+            <artifactId>duplicate-finder-maven-plugin</artifactId>
+        </plugin>
+    </plugins>
+</build>
+----
+
+For other properties, we have set defaults as listed in the https://github.com/basepom/duplicate-finder-maven-plugin/wiki[plugin documentation].
+
+You can easily override them but setting the value of the selected property prefixed with `duplicate-finder-maven-plugin`. For example, set `duplicate-finder-maven-plugin.skip` to `true` in order to skip duplicates check in your build.
+
+If you need to add `ignoredClassPatterns` or `ignoredResourcePatterns` to your setup, make sure to add them in the plugin configuration section of your project:
+
+[source,xml]
+----
+<build>
+    <plugins>
+        <plugin>
+            <groupId>org.basepom.maven</groupId>
+            <artifactId>duplicate-finder-maven-plugin</artifactId>
+            <configuration>
+                <ignoredClassPatterns>
+                    <ignoredClassPattern>org.joda.time.base.BaseDateTime</ignoredClassPattern>
+                    <ignoredClassPattern>.*module-info</ignoredClassPattern>
+                </ignoredClassPatterns>
+                <ignoredResourcePatterns>
+                    <ignoredResourcePattern>changelog.txt</ignoredResourcePattern>
+                </ignoredResourcePatterns>
+            </configuration>
+        </plugin>
+    </plugins>
+</build>
+
+
+----
+
 
-[[license]]
 == License
 
 The project license file is available https://raw.githubusercontent.com/spring-cloud/spring-cloud-openfeign/main/LICENSE.txt[here].

docs/antora-playbook.yml

@@ -1,39 +0,0 @@
-antora:
-  extensions:
-    - '@springio/antora-extensions/partial-build-extension'
-    - require: '@springio/antora-extensions/latest-version-extension'
-    - require: '@springio/antora-extensions/inject-collector-cache-config-extension'
-    - '@antora/collector-extension'
-    - '@antora/atlas-extension'
-    - require: '@springio/antora-extensions/root-component-extension'
-      root_component_name: 'cloud-openfeign'
-    - '@springio/antora-extensions/static-page-extension'
-site:
-  title: Spring Cloud Openfeign
-  url: https://docs.spring.io/spring-cloud-openfeign/reference/
-content:
-  sources:
-    - url: ./..
-      branches: HEAD
-      start_path: docs
-      worktrees: true
-asciidoc:
-  attributes:
-    page-stackoverflow-url: https://stackoverflow.com/tags/spring-cloud
-    page-pagination: ''
-    hide-uri-scheme: '@'
-    tabs-sync-option: '@'
-    chomp: 'all'
-  extensions:
-    - '@asciidoctor/tabs'
-    - '@springio/asciidoctor-extensions'
-  sourcemap: true
-urls:
-  latest_version_segment: ''
-runtime:
-  log:
-    failure_level: warn
-    format: pretty
-ui:
-  bundle:
-    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.2/ui-bundle.zip

docs/antora.yml

@@ -1,12 +0,0 @@
-name: cloud-openfeign
-version: true
-title: Spring Cloud OpenFeign
-nav:
-  - modules/ROOT/nav.adoc
-ext:
-  collector:
-    run:
-      command: ./mvnw --no-transfer-progress -B process-resources -Pdocs -pl docs -Dantora-maven-plugin.phase=none -Dgenerate-docs.phase=none -Dgenerate-readme.phase=none -Dgenerate-cloud-resources.phase=none -Dmaven-dependency-plugin-for-docs.phase=none -Dmaven-dependency-plugin-for-docs-classes.phase=none -DskipTests
-      local: true
-    scan:
-      dir: ./target/classes/antora-resources/

docs/modules/ROOT/nav.adoc

@@ -1,4 +0,0 @@
-* xref:index.adoc[Introduction]
-* xref:spring-cloud-openfeign.adoc[]
-* xref:appendix.adoc[]
-** xref:configprops.adoc[]

docs/modules/ROOT/pages/configprops.adoc

@@ -1,6 +0,0 @@
-[[configuration-properties]]
-= Configuration Properties
-
-Below you can find a list of configuration properties.
-
-include::partial$_configprops.adoc[]

docs/modules/ROOT/pages/index.adoc

@@ -1 +0,0 @@
-include::intro.adoc[]

docs/modules/ROOT/partials/_attributes.adoc

@@ -1,3 +0,0 @@
-:sc-ext: java
-:project-full-name: Spring Cloud OpenFeign
-:all: {asterisk}{asterisk}

docs/modules/ROOT/partials/_configprops.adoc

@@ -1,113 +0,0 @@
-|===
-|Name | Default | Description
-
-|spring.cloud.compatibility-verifier.compatible-boot-versions | `+++3.2.x+++` | Default accepted versions for the Spring Boot dependency. You can set {@code x} for the patch version if you don't want to specify a concrete value. Example: {@code 3.4.x}
-|spring.cloud.compatibility-verifier.enabled | `+++false+++` | Enables creation of Spring Cloud compatibility verification.
-|spring.cloud.config.allow-override | `+++true+++` | Flag to indicate that {@link #isOverrideSystemProperties() systemPropertiesOverride} can be used. Set to false to prevent users from changing the default accidentally. Default true.
-|spring.cloud.config.initialize-on-context-refresh | `+++false+++` | Flag to initialize bootstrap configuration on context refresh event. Default false.
-|spring.cloud.config.override-none | `+++false+++` | Flag to indicate that when {@link #setAllowOverride(boolean) allowOverride} is true, external properties should take lowest priority and should not override any existing property sources (including local config files). Default false. This will only have an effect when using config first bootstrap.
-|spring.cloud.config.override-system-properties | `+++true+++` | Flag to indicate that the external properties should override system properties. Default true.
-|spring.cloud.decrypt-environment-post-processor.enabled | `+++true+++` | Enable the DecryptEnvironmentPostProcessor.
-|spring.cloud.discovery.client.composite-indicator.enabled | `+++true+++` | Enables discovery client composite health indicator.
-|spring.cloud.discovery.client.health-indicator.enabled | `+++true+++` | 
-|spring.cloud.discovery.client.health-indicator.include-description | `+++false+++` | 
-|spring.cloud.discovery.client.health-indicator.use-services-query | `+++true+++` | Whether or not the indicator should use {@link DiscoveryClient#getServices} to check its health. When set to {@code false} the indicator instead uses the lighter {@link DiscoveryClient#probe()}. This can be helpful in large deployments where the number of services returned makes the operation unnecessarily heavy.
-|spring.cloud.discovery.client.simple.instances |  | 
-|spring.cloud.discovery.client.simple.local.host |  | 
-|spring.cloud.discovery.client.simple.local.instance-id |  | 
-|spring.cloud.discovery.client.simple.local.metadata |  | 
-|spring.cloud.discovery.client.simple.local.port | `+++0+++` | 
-|spring.cloud.discovery.client.simple.local.secure | `+++false+++` | 
-|spring.cloud.discovery.client.simple.local.service-id |  | 
-|spring.cloud.discovery.client.simple.local.uri |  | 
-|spring.cloud.discovery.client.simple.order |  | 
-|spring.cloud.discovery.enabled | `+++true+++` | Enables discovery client health indicators.
-|spring.cloud.features.enabled | `+++true+++` | Enables the features endpoint.
-|spring.cloud.httpclientfactories.apache.enabled | `+++true+++` | Enables creation of Apache Http Client factory beans.
-|spring.cloud.httpclientfactories.ok.enabled | `+++true+++` | Enables creation of OK Http Client factory beans.
-|spring.cloud.hypermedia.refresh.fixed-delay | `+++5000+++` | 
-|spring.cloud.hypermedia.refresh.initial-delay | `+++10000+++` | 
-|spring.cloud.inetutils.default-hostname | `+++localhost+++` | The default hostname. Used in case of errors.
-|spring.cloud.inetutils.default-ip-address | `+++127.0.0.1+++` | The default IP address. Used in case of errors.
-|spring.cloud.inetutils.ignored-interfaces |  | List of Java regular expressions for network interfaces that will be ignored.
-|spring.cloud.inetutils.preferred-networks |  | List of Java regular expressions for network addresses that will be preferred.
-|spring.cloud.inetutils.timeout-seconds | `+++1+++` | Timeout, in seconds, for calculating hostname.
-|spring.cloud.inetutils.use-only-site-local-interfaces | `+++false+++` | Whether to use only interfaces with site local addresses. See {@link InetAddress#isSiteLocalAddress()} for more details.
-|spring.cloud.loadbalancer.call-get-with-request-on-delegates | `+++true+++` | If this flag is set to {@code true}, {@code ServiceInstanceListSupplier#get(Request request)} method will be implemented to call {@code delegate.get(request)} in classes assignable from {@code DelegatingServiceInstanceListSupplier} that don't already implement that method, with the exclusion of {@code CachingServiceInstanceListSupplier} and {@code HealthCheckServiceInstanceListSupplier}, which should be placed in the instance supplier hierarchy directly after the supplier performing instance retrieval over the network, before any request-based filtering is done, {@code true} by default.
-|spring.cloud.loadbalancer.clients |  | 
-|spring.cloud.loadbalancer.eager-load.clients |  | 
-|spring.cloud.loadbalancer.health-check.initial-delay | `+++0+++` | Initial delay value for the HealthCheck scheduler.
-|spring.cloud.loadbalancer.health-check.interval | `+++25s+++` | Interval for rerunning the HealthCheck scheduler.
-|spring.cloud.loadbalancer.health-check.interval  | `+++25s+++` | Interval for rerunning the HealthCheck scheduler.
-|spring.cloud.loadbalancer.health-check.path |  | Path at which the health-check request should be made. Can be set up per `serviceId`. A `default` value can be set up as well. If none is set up, `/actuator/health` will be used.
-|spring.cloud.loadbalancer.health-check.port |  | Path at which the health-check request should be made. If none is set, the port under which the requested service is available at the service instance.
-|spring.cloud.loadbalancer.health-check.refetch-instances | `+++false+++` | Indicates whether the instances should be refetched by the `HealthCheckServiceInstanceListSupplier`. This can be used if the instances can be updated and the underlying delegate does not provide an ongoing flux.
-|spring.cloud.loadbalancer.health-check.refetch-instances-interval | `+++25s+++` | Interval for refetching available service instances.
-|spring.cloud.loadbalancer.health-check.repeat-health-check | `+++true+++` | Indicates whether health checks should keep repeating. It might be useful to set it to `false` if periodically refetching the instances, as every refetch will also trigger a healthcheck.
-|spring.cloud.loadbalancer.health-check.update-results-list | `+++true+++` | Indicates whether the {@code healthCheckFlux} should emit on each alive {@link ServiceInstance} that has been retrieved. If set to {@code false}, the entire alive instances sequence is first collected into a list and only then emitted.
-|spring.cloud.loadbalancer.hint |  | Allows setting the value of <code>hint</code> that is passed on to the LoadBalancer request and can subsequently be used in {@link ReactiveLoadBalancer} implementations.
-|spring.cloud.loadbalancer.hint-header-name | `+++X-SC-LB-Hint+++` | Allows setting the name of the header used for passing the hint for hint-based service instance filtering.
-|spring.cloud.loadbalancer.retry.backoff.enabled | `+++false+++` | Indicates whether Reactor Retry backoffs should be applied.
-|spring.cloud.loadbalancer.retry.backoff.jitter | `+++0.5+++` | Used to set `RetryBackoffSpec.jitter`.
-|spring.cloud.loadbalancer.retry.backoff.max-backoff | `+++Long.MAX ms+++` | Used to set `RetryBackoffSpec.maxBackoff`.
-|spring.cloud.loadbalancer.retry.backoff.min-backoff | `+++5 ms+++` | Used to set `RetryBackoffSpec#minBackoff`.
-|spring.cloud.loadbalancer.retry.enabled | `+++true+++` | Enables LoadBalancer retries.
-|spring.cloud.loadbalancer.retry.max-retries-on-next-service-instance | `+++1+++` | Number of retries to be executed on the next `ServiceInstance`. A `ServiceInstance` is chosen before each retry call.
-|spring.cloud.loadbalancer.retry.max-retries-on-same-service-instance | `+++0+++` | Number of retries to be executed on the same `ServiceInstance`.
-|spring.cloud.loadbalancer.retry.retry-on-all-exceptions | `+++false+++` | Indicates retries should be attempted for all exceptions, not only those specified in `retryableExceptions`.
-|spring.cloud.loadbalancer.retry.retry-on-all-operations | `+++false+++` | Indicates retries should be attempted on operations other than `HttpMethod.GET`.
-|spring.cloud.loadbalancer.retry.retryable-exceptions | `+++{}+++` | A `Set` of `Throwable` classes that should trigger a retry.
-|spring.cloud.loadbalancer.retry.retryable-status-codes | `+++{}+++` | A `Set` of status codes that should trigger a retry.
-|spring.cloud.loadbalancer.sticky-session.add-service-instance-cookie | `+++false+++` | Indicates whether a cookie with the newly selected instance should be added by LoadBalancer.
-|spring.cloud.loadbalancer.sticky-session.instance-id-cookie-name | `+++sc-lb-instance-id+++` | The name of the cookie holding the preferred instance id.
-|spring.cloud.loadbalancer.x-forwarded.enabled | `+++false+++` | To Enable X-Forwarded Headers.
-|spring.cloud.openfeign.autoconfiguration.jackson.enabled | `+++true+++` | If true, PageJacksonModule and SortJacksonModule bean will be provided for Jackson page decoding.
-|spring.cloud.openfeign.circuitbreaker.alphanumeric-ids.enabled | `+++false+++` | If true, Circuit Breaker ids will only contain alphanumeric characters to allow for configuration via configuration properties.
-|spring.cloud.openfeign.circuitbreaker.enabled | `+++false+++` | If true, an OpenFeign client will be wrapped with a Spring Cloud CircuitBreaker circuit breaker.
-|spring.cloud.openfeign.circuitbreaker.group.enabled | `+++false+++` | If true, an OpenFeign client will be wrapped with a Spring Cloud CircuitBreaker circuit breaker with with group.
-|spring.cloud.openfeign.client.config |  | 
-|spring.cloud.openfeign.client.decode-slash | `+++true+++` | Feign clients do not encode slash `/` characters by default. To change this behavior, set the `decodeSlash` to `false`.
-|spring.cloud.openfeign.client.default-config | `+++default+++` | 
-|spring.cloud.openfeign.client.default-to-properties | `+++true+++` | 
-|spring.cloud.openfeign.client.refresh-enabled | `+++false+++` | Enables options value refresh capability for Feign.
-|spring.cloud.openfeign.compression.request.enabled | `+++false+++` | Enables the request sent by Feign to be compressed.
-|spring.cloud.openfeign.compression.request.mime-types | `+++[text/xml, application/xml, application/json]+++` | The list of supported mime types.
-|spring.cloud.openfeign.compression.request.min-request-size | `+++2048+++` | The minimum threshold content size.
-|spring.cloud.openfeign.compression.response.enabled | `+++false+++` | Enables the response from Feign to be compressed.
-|spring.cloud.openfeign.encoder.charset-from-content-type | `+++false+++` | Indicates whether the charset should be derived from the {@code Content-Type} header.
-|spring.cloud.openfeign.http2client.enabled | `+++false+++` | Enables the use of the Java11 HTTP 2 Client by Feign.
-|spring.cloud.openfeign.httpclient.connection-timeout | `+++2000+++` | 
-|spring.cloud.openfeign.httpclient.connection-timer-repeat | `+++3000+++` | 
-|spring.cloud.openfeign.httpclient.disable-ssl-validation | `+++false+++` | 
-|spring.cloud.openfeign.httpclient.enabled | `+++true+++` | Enables the use of the Apache HTTP Client by Feign.
-|spring.cloud.openfeign.httpclient.follow-redirects | `+++true+++` | 
-|spring.cloud.openfeign.httpclient.hc5.connection-request-timeout | `+++3+++` | Default value for connection request timeout.
-|spring.cloud.openfeign.httpclient.hc5.connection-request-timeout-unit |  | Default value for connection request timeout unit.
-|spring.cloud.openfeign.httpclient.hc5.enabled | `+++false+++` | Enables the use of the Apache HTTP Client 5 by Feign.
-|spring.cloud.openfeign.httpclient.hc5.pool-concurrency-policy |  | Pool concurrency policies.
-|spring.cloud.openfeign.httpclient.hc5.pool-reuse-policy |  | Pool connection re-use policies.
-|spring.cloud.openfeign.httpclient.hc5.socket-timeout | `+++5+++` | Default value for socket timeout.
-|spring.cloud.openfeign.httpclient.hc5.socket-timeout-unit |  | Default value for socket timeout unit.
-|spring.cloud.openfeign.httpclient.http2.version | `+++HTTP_2+++` | Configure the protocols used by this client to communicate with remote servers. Uses {@link String} value of {@link HttpClient.Version}.
-|spring.cloud.openfeign.httpclient.max-connections | `+++200+++` | 
-|spring.cloud.openfeign.httpclient.max-connections-per-route | `+++50+++` | 
-|spring.cloud.openfeign.httpclient.ok-http.protocols |  | Configure the protocols used by this client to communicate with remote servers. Uses {@link String} values of {@link Protocol}.
-|spring.cloud.openfeign.httpclient.ok-http.read-timeout | `+++60s+++` | {@link OkHttpClient} read timeout; defaults to 60 seconds.
-|spring.cloud.openfeign.httpclient.time-to-live | `+++900+++` | 
-|spring.cloud.openfeign.httpclient.time-to-live-unit |  | 
-|spring.cloud.openfeign.lazy-attributes-resolution | `+++false+++` | Switches @FeignClient attributes resolution mode to lazy.
-|spring.cloud.openfeign.micrometer.enabled | `+++true+++` | Enables Micrometer capabilities for Feign.
-|spring.cloud.openfeign.oauth2.clientRegistrationId |  | Provides a clientId to be used with OAuth2.
-|spring.cloud.openfeign.oauth2.enabled | `+++false+++` | Enables feign interceptor for managing oauth2 access token.
-|spring.cloud.openfeign.okhttp.enabled | `+++false+++` | Enables the use of the OK HTTP Client by Feign.
-|spring.cloud.refresh.additional-property-sources-to-retain |  | Additional property sources to retain during a refresh. Typically only system property sources are retained. This property allows property sources, such as property sources created by EnvironmentPostProcessors to be retained as well.
-|spring.cloud.refresh.enabled | `+++true+++` | Enables autoconfiguration for the refresh scope and associated features.
-|spring.cloud.refresh.extra-refreshable | `+++true+++` | Additional class names for beans to post process into refresh scope.
-|spring.cloud.refresh.never-refreshable | `+++true+++` | Comma separated list of class names for beans to never be refreshed or rebound.
-|spring.cloud.refresh.on-restart.enabled | `+++true+++` | Enable refreshing context on start.
-|spring.cloud.service-registry.auto-registration.enabled | `+++true+++` | Whether service auto-registration is enabled. Defaults to true.
-|spring.cloud.service-registry.auto-registration.fail-fast | `+++false+++` | Whether startup fails if there is no AutoServiceRegistration. Defaults to false.
-|spring.cloud.service-registry.auto-registration.register-management | `+++true+++` | Whether to register the management as a service. Defaults to true.
-|spring.cloud.util.enabled | `+++true+++` | Enables creation of Spring Cloud utility beans.
-
-|===

docs/modules/ROOT/partials/_conventions.adoc

@@ -1,6 +0,0 @@
-[[observability-conventions]]
-=== Observability - Conventions
-
-Below you can find a list of all `GlobalObservationConvention` and `ObservationConvention` declared by this project.
-
-

docs/modules/ROOT/partials/_metrics.adoc

@@ -1,6 +0,0 @@
-[[observability-metrics]]
-=== Observability - Metrics
-
-Below you can find a list of all metrics declared by this project.
-
-

docs/modules/ROOT/partials/_spans.adoc

@@ -1,6 +0,0 @@
-[[observability-spans]]
-=== Observability - Spans
-
-Below you can find a list of all spans declared by this project.
-
-

docs/pom.xml

@@ -3,32 +3,20 @@
 		 xmlns="http://maven.apache.org/POM/4.0.0"
 		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
-	<groupId>org.springframework.cloud</groupId>
-	<artifactId>spring-cloud-openfeign-docs</artifactId>
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>4.1.0-SNAPSHOT</version>
-		<relativePath>..</relativePath>
+		<version>3.0.8-SNAPSHOT</version>
 	</parent>
-	<scm>
-		<url>https://github.com/spring-cloud/spring-cloud-openfeign</url>
-	</scm>
+	<artifactId>spring-cloud-openfeign-docs</artifactId>
 	<packaging>jar</packaging>
 	<name>Spring Cloud OpenFeign Docs</name>
-	<description>Spring Cloud OpenFeign Docs</description>
+	<description>Spring Cloud Docs</description>
 	<properties>
 		<docs.main>spring-cloud-openfeign</docs.main>
 		<main.basedir>${basedir}/..</main.basedir>
-		<configprops.inclusionPattern>spring.cloud.*</configprops.inclusionPattern>
-		<!-- Don't upload docs jar to central / repo.spring.io -->
-		<maven-deploy-plugin-default.phase>none</maven-deploy-plugin-default.phase>
-
-		<!-- Observability -->
-		<micrometer-docs-generator.version>1.0.2</micrometer-docs-generator.version>
-		<micrometer-docs-generator.inputPath>${maven.multiModuleProjectDirectory}/</micrometer-docs-generator.inputPath>
-		<micrometer-docs-generator.inclusionPattern>.*</micrometer-docs-generator.inclusionPattern>
-		<micrometer-docs-generator.outputPath>${maven.multiModuleProjectDirectory}/docs/modules/ROOT/partials/</micrometer-docs-generator.outputPath>
+		<configprops.inclusionPattern>feign.*</configprops.inclusionPattern>
+		<upload-docs-zip.phase>deploy</upload-docs-zip.phase>
 	</properties>
 	<dependencies>
 		<dependency>
@@ -43,12 +31,6 @@
 		<profile>
 			<id>docs</id>
 			<build>
-				<resources>
-					<resource>
-						<directory>src/main/antora/resources/antora-resources</directory>
-						<filtering>true</filtering>
-					</resource>
-				</resources>
 				<plugins>
 					<plugin>
 						<groupId>pl.project13.maven</groupId>
@@ -59,43 +41,16 @@
 						<artifactId>maven-dependency-plugin</artifactId>
 					</plugin>
 					<plugin>
-						<groupId>org.codehaus.mojo</groupId>
-						<artifactId>exec-maven-plugin</artifactId>
-						<!-- TODO: Remove this execution if you have no observability -->
-						<executions>
-							<execution>
-								<id>generate-observability-docs</id>
-								<phase>${generate-docs.phase}</phase>
-								<goals>
-									<goal>java</goal>
-								</goals>
-								<configuration>
-									<mainClass>io.micrometer.docs.DocsGeneratorCommand</mainClass>
-									<includePluginDependencies>true</includePluginDependencies>
-									<arguments>
-										<argument>${micrometer-docs-generator.inputPath}</argument>
-										<argument>${micrometer-docs-generator.inclusionPattern}</argument>
-										<argument>${micrometer-docs-generator.outputPath}</argument>
-									</arguments>
-								</configuration>
-							</execution>
-						</executions>
-						<dependencies>
-							<dependency>
-								<groupId>io.micrometer</groupId>
-								<artifactId>micrometer-docs-generator</artifactId>
-								<version>${micrometer-docs-generator.version}</version>
-								<type>jar</type>
-							</dependency>
-						</dependencies>
+						<groupId>org.apache.maven.plugins</groupId>
+						<artifactId>maven-resources-plugin</artifactId>
 					</plugin>
 					<plugin>
-						<groupId>io.spring.maven.antora</groupId>
-						<artifactId>antora-component-version-maven-plugin</artifactId>
+						<groupId>org.codehaus.mojo</groupId>
+						<artifactId>exec-maven-plugin</artifactId>
 					</plugin>
 					<plugin>
-						<groupId>io.spring.maven.antora</groupId>
-						<artifactId>antora-maven-plugin</artifactId>
+						<groupId>org.asciidoctor</groupId>
+						<artifactId>asciidoctor-maven-plugin</artifactId>
 					</plugin>
 					<plugin>
 						<groupId>org.apache.maven.plugins</groupId>

docs/src/main/antora/resources/antora-resources/antora.yml

@@ -1,20 +0,0 @@
-version: @antora-component.version@
-prerelease: @antora-component.prerelease@
-
-asciidoc:
-  attributes:
-    attribute-missing: 'warn'
-    chomp: 'all'
-    project-root: @maven.multiModuleProjectDirectory@
-    github-repo: @docs.main@
-    github-raw: https://raw.githubusercontent.com/spring-cloud/@docs.main@/@github-tag@
-    github-code: https://github.com/spring-cloud/@docs.main@/tree/@github-tag@
-    github-issues: https://github.com/spring-cloud/@docs.main@/issues/
-    github-wiki: https://github.com/spring-cloud/@docs.main@/wiki
-    spring-cloud-version: @project.version@
-    github-tag: @github-tag@
-    version-type: @version-type@
-    docs-url: https://docs.spring.io/@docs.main@/docs/@project.version@
-    raw-docs-url: https://raw.githubusercontent.com/spring-cloud/@docs.main@/@github-tag@
-    project-version: @project.version@
-    project-name: @docs.main@

docs/src/main/asciidoc/README.adoc

@@ -1,24 +1,25 @@
 image::https://github.com/spring-cloud/spring-cloud-openfeign/workflows/Build/badge.svg?branch=main&style=svg["Build",link="https://github.com/spring-cloud/spring-cloud-openfeign/actions"]
 
-image:https://codecov.io/gh/spring-cloud/spring-cloud-openfeign/branch/main/graph/badge.svg["Codecov", link="https://app.codecov.io/gh/spring-cloud/spring-cloud-openfeign/tree/main"]
+image:https://codecov.io/gh/spring-cloud/spring-cloud-openfeign/branch/main/graph/badge.svg["Codecov", link="https://codecov.io/gh/spring-cloud/spring-cloud-openfeign"]
 
+image:https://api.codacy.com/project/badge/Grade/97b04c4e609c4b4f86b415e4437a6484["Codacy code quality", link="https://www.codacy.com/app/Spring-Cloud/spring-cloud-openfeign?utm_source=github.com&utm_medium=referral&utm_content=spring-cloud/spring-cloud-openfeign&utm_campaign=Badge_Grade"]
+
+include::_attributes.adoc[]
+
+include::intro.adoc[]
 
-[[features]]
 == Features
 
 * Declarative REST Client: Feign creates a dynamic implementation of an interface decorated with JAX-RS or Spring MVC annotations
 
-[[building]]
 == Building
 
-include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/main/docs/modules/ROOT/partials/building.adoc[]
+include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/main/docs/src/main/asciidoc/building-jdk8.adoc[]
 
-[[contributing]]
 == Contributing
 
-include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/main/docs/modules/ROOT/partials/contributing-docs.adoc[]
+include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/main/docs/src/main/asciidoc/contributing.adoc[]
 
-[[license]]
 == License
 
 The project license file is available https://raw.githubusercontent.com/spring-cloud/spring-cloud-openfeign/main/LICENSE.txt[here].

docs/src/main/asciidoc/_attributes.adoc

@@ -1,6 +1,8 @@
 :doctype: book
 :idprefix:
 :idseparator: -
+:toc: left
+:toclevels: 4
 :tabsize: 4
 :numbered:
 :sectanchors:

docs/src/main/asciidoc/_configprops.adoc

@@ -0,0 +1,35 @@
+|===
+|Name | Default | Description
+
+|feign.autoconfiguration.jackson.enabled | `false` | If true, PageJacksonModule and SortJacksonModule bean will be provided for Jackson page decoding.
+|feign.circuitbreaker.enabled | `false` | If true, an OpenFeign client will be wrapped with a Spring Cloud CircuitBreaker circuit breaker.
+|feign.circuitbreaker.group.enabled | `false` | If true, an OpenFeign client will be wrapped with a Spring Cloud CircuitBreaker circuit breaker with with group.
+|feign.client.config |  | 
+|feign.client.decode-slash | `true` | Feign clients do not encode slash `/` characters by default. To change this behavior, set the `decodeSlash` to `false`.
+|feign.client.default-config | `default` | 
+|feign.client.default-to-properties | `true` | 
+|feign.client.refresh-enabled | `false` | Enables options value refresh capability for Feign.
+|feign.compression.request.enabled | `false` | Enables the request sent by Feign to be compressed.
+|feign.compression.request.mime-types | `[text/xml, application/xml, application/json]` | The list of supported mime types.
+|feign.compression.request.min-request-size | `2048` | The minimum threshold content size.
+|feign.compression.response.enabled | `false` | Enables the response from Feign to be compressed.
+|feign.compression.response.useGzipDecoder | `false` | Enables the default gzip decoder to be used.
+|feign.encoder.charset-from-content-type | `false` | Indicates whether the charset should be derived from the {@code Content-Type} header.
+|feign.httpclient.connection-timeout | `2000` | 
+|feign.httpclient.connection-timer-repeat | `3000` | 
+|feign.httpclient.disable-ssl-validation | `false` | 
+|feign.httpclient.enabled | `true` | Enables the use of the Apache HTTP Client by Feign.
+|feign.httpclient.follow-redirects | `true` | 
+|feign.httpclient.hc5.enabled | `false` | Enables the use of the Apache HTTP Client 5 by Feign.
+|feign.httpclient.hc5.pool-concurrency-policy |  | Pool concurrency policies.
+|feign.httpclient.hc5.pool-reuse-policy |  | Pool connection re-use policies.
+|feign.httpclient.hc5.socket-timeout | `5` | Default value for socket timeout.
+|feign.httpclient.hc5.socket-timeout-unit |  | Default value for socket timeout unit.
+|feign.httpclient.max-connections | `200` | 
+|feign.httpclient.max-connections-per-route | `50` | 
+|feign.httpclient.time-to-live | `900` | 
+|feign.httpclient.time-to-live-unit |  | 
+|feign.metrics.enabled | `true` | Enables metrics capability for Feign.
+|feign.okhttp.enabled | `false` | Enables the use of the OK HTTP Client by Feign.
+
+|===

docs/src/main/asciidoc/appendix.adoc

@@ -1,13 +1,14 @@
 :numbered!:
 [appendix]
 [[common-application-properties]]
-= Common application properties
-:page-section-summary-toc: 1
+== Common application properties
 
+include::_attributes.adoc[]
 
 Various properties can be specified inside your `application.properties` file, inside your `application.yml` file, or as command line switches.
-This appendix provides a list of common Spring Cloud OpenFeign properties and references to the underlying classes that consume them.
+This appendix provides a list of common {project-full-name} properties and references to the underlying classes that consume them.
 
 NOTE: Property contributions can come from additional jar files on your classpath, so you should not consider this an exhaustive list.
 Also, you can define your own properties.
 
+include::_configprops.adoc[]

docs/src/main/asciidoc/index.adoc

@@ -0,0 +1 @@
+spring-cloud-openfeign.adoc

docs/src/main/asciidoc/intro.adoc

@@ -1,6 +1,3 @@
-[[introduction]]
-= Spring Cloud OpenFeign
-
 This project provides OpenFeign integrations for Spring Boot apps through autoconfiguration
 and binding to the Spring Environment and other Spring programming model idioms.
 

docs/src/main/asciidoc/spring-cloud-openfeign.adoc

@@ -1,5 +1,10 @@
-[[features]]
-= Spring Cloud OpenFeign Features
+= Spring Cloud OpenFeign
+include::_attributes.adoc[]
+
+*{spring-cloud-version}*
+
+include::intro.adoc[]
+
 
 [[spring-cloud-feign]]
 == Declarative REST Client: Feign
@@ -47,9 +52,6 @@ public interface StoreClient {
 
 	@RequestMapping(method = RequestMethod.POST, value = "/stores/{storeId}", consumes = "application/json")
 	Store update(@PathVariable("storeId") Long storeId, Store store);
-
-	@RequestMapping(method = RequestMethod.DELETE, value = "/stores/{storeId:\\d+}")
-	void delete(@PathVariable Long storeId);
 }
 ----
 
@@ -73,15 +75,6 @@ TIP: To use `@EnableFeignClients` annotation on `@Configuration`-annotated-class
 or list them explicitly:
 `@EnableFeignClients(clients = InventoryServiceFeignClient.class)`
 
-[[attribute-resolution-mode]]
-==== Attribute resolution mode
-
-While creating `Feign` client beans, we resolve the values passed via the `@FeignClient` annotation. As of `4.x`, the values are being resolved eagerly. This is a good solution for most use-cases, and it also allows for AOT support.
-
-If you need the attributes to be resolved lazily, set the `spring.cloud.openfeign.lazy-attributes-resolution` property value to `true`.
-
-TIP: For Spring Cloud Contract test integration, lazy attribute resolution should be used.
-
 [[spring-cloud-feign-overriding-defaults]]
 === Overriding Feign Defaults
 
@@ -125,22 +118,16 @@ Spring Cloud OpenFeign provides the following beans by default for feign (`BeanT
 * `Decoder` feignDecoder: `ResponseEntityDecoder` (which wraps a `SpringDecoder`)
 * `Encoder` feignEncoder: `SpringEncoder`
 * `Logger` feignLogger: `Slf4jLogger`
-* `MicrometerObservationCapability` micrometerObservationCapability: If `feign-micrometer` is on the classpath and `ObservationRegistry` is available
-* `MicrometerCapability` micrometerCapability: If `feign-micrometer` is on the classpath, `MeterRegistry` is available and `ObservationRegistry` is not available
-* `CachingCapability` cachingCapability: If `@EnableCaching` annotation is used. Can be disabled via `spring.cloud.openfeign.cache.enabled`.
+* `MicrometerCapability` micrometerCapability: If `feign-micrometer` is on the classpath and `MeterRegistry` is available
 * `Contract` feignContract: `SpringMvcContract`
 * `Feign.Builder` feignBuilder: `FeignCircuitBreaker.Builder`
 * `Client` feignClient: If Spring Cloud LoadBalancer is on the classpath, `FeignBlockingLoadBalancerClient` is used.
 If none of them is on the classpath, the default feign client is used.
 
-NOTE: `spring-cloud-starter-openfeign` supports `spring-cloud-starter-loadbalancer`. However, as is an optional dependency, you need to make sure it has been added to your project if you want to use it.
-
-The OkHttpClient, Apache HttpClient 5 and Http2Client Feign clients can be used by setting `spring.cloud.openfeign.okhttp.enabled` or `spring.cloud.openfeign.httpclient.hc5.enabled` or `spring.cloud.openfeign.http2client.enabled` to `true`, respectively, and having them on the classpath.
-You can customize the HTTP client used by providing a bean of either `org.apache.hc.client5.http.impl.classic.CloseableHttpClient` when using Apache HC5.
+NOTE: `spring-cloud-starter-openfeign` supports `spring-cloud-starter-loadbalancer`. However, as is an optional dependency, you need to make sure it been added to your project if you want to use it.
 
-You can further customise http clients by setting values in the `spring.cloud.openfeign.httpclient.xxx` properties. The ones prefixed just with `httpclient` will work for all the clients, the ones prefixed with `httpclient.hc5` to Apache HttpClient 5, the ones prefixed with `httpclient.okhttp` to OkHttpClient and the ones prefixed with `httpclient.http2` to Http2Client. You can find a full list of properties you can customise in the appendix.
-
-TIP: Starting with Spring Cloud OpenFeign 4, the Feign Apache HttpClient 4 is no longer supported. We suggest using Apache HttpClient 5 instead.
+The OkHttpClient and ApacheHttpClient and ApacheHC5 feign clients can be used by setting `feign.okhttp.enabled` or `feign.httpclient.enabled` or `feign.httpclient.hc5.enabled` to `true`, respectively, and having them on the classpath.
+You can customize the HTTP client used by providing a bean of either `org.apache.http.impl.client.CloseableHttpClient` when using Apache or `okhttp3.OkHttpClient` when using OK HTTP or `org.apache.hc.client5.http.impl.classic.CloseableHttpClient` when using Apache HC5.
 
 Spring Cloud OpenFeign _does not_ provide the following beans by default for feign, but still looks up beans of these types from the application context to create the feign client:
 
@@ -151,7 +138,7 @@ Spring Cloud OpenFeign _does not_ provide the following beans by default for fei
 * `Collection<RequestInterceptor>`
 * `SetterFactory`
 * `QueryMapEncoder`
-* `Capability` (`MicrometerObservationCapability` and `CachingCapability` are provided by default)
+* `Capability` (`MicrometerCapability` is provided by default)
 
 A bean of `Retryer.NEVER_RETRY` with the type `Retryer` is created by default, which will disable retrying.
 Notice this retrying behavior is different from the Feign default one, where it will automatically retry IOExceptions,
@@ -182,62 +169,53 @@ This replaces the `SpringMvcContract` with `feign.Contract.Default` and adds a `
 application.yml
 [source,yaml]
 ----
-spring:
-	cloud:
-		openfeign:
-			client:
-				config:
-					feignName:
-                        url: http://remote-service.com
-						connectTimeout: 5000
-						readTimeout: 5000
-						loggerLevel: full
-						errorDecoder: com.example.SimpleErrorDecoder
-						retryer: com.example.SimpleRetryer
-						defaultQueryParameters:
-							query: queryValue
-						defaultRequestHeaders:
-							header: headerValue
-						requestInterceptors:
-							- com.example.FooRequestInterceptor
-							- com.example.BarRequestInterceptor
-						responseInterceptor: com.example.BazResponseInterceptor
-						dismiss404: false
-						encoder: com.example.SimpleEncoder
-						decoder: com.example.SimpleDecoder
-						contract: com.example.SimpleContract
-						capabilities:
-							- com.example.FooCapability
-							- com.example.BarCapability
-						queryMapEncoder: com.example.SimpleQueryMapEncoder
-						micrometer.enabled: false
-----
-`feignName` in this example refers to `@FeignClient` `value`, that is also aliased with `@FeignClient` `name` and `@FeignClient` `contextId`. In a load-balanced scenario, it also corresponds to the `serviceId` of the server app that will be used to retrieve the instances. The specified classes for decoders, retryer and other ones must have a bean in the Spring context or have a default constructor.
-
+feign:
+	client:
+		config:
+			feignName:
+				connectTimeout: 5000
+				readTimeout: 5000
+				loggerLevel: full
+				errorDecoder: com.example.SimpleErrorDecoder
+				retryer: com.example.SimpleRetryer
+				defaultQueryParameters:
+					query: queryValue
+				defaultRequestHeaders:
+					header: headerValue
+				requestInterceptors:
+					- com.example.FooRequestInterceptor
+					- com.example.BarRequestInterceptor
+				decode404: false
+				encoder: com.example.SimpleEncoder
+				decoder: com.example.SimpleDecoder
+				contract: com.example.SimpleContract
+				capabilities:
+					- com.example.FooCapability
+					- com.example.BarCapability
+				metrics.enabled: false
+----
 
 Default configurations can be specified in the `@EnableFeignClients` attribute `defaultConfiguration` in a similar manner as described above. The difference is that this configuration will apply to _all_ feign clients.
 
 If you prefer using configuration properties to configure all `@FeignClient`, you can create configuration properties with `default` feign name.
 
-You can use `spring.cloud.openfeign.client.config.feignName.defaultQueryParameters` and `spring.cloud.openfeign.client.config.feignName.defaultRequestHeaders` to specify query parameters and headers that will be sent with every request of the client named `feignName`.
+You can use `feign.client.config.feignName.defaultQueryParameters` and `feign.client.config.feignName.defaultRequestHeaders` to specify query parameters and headers that will be sent with every request of the client named `feignName`.
 
 application.yml
 [source,yaml]
 ----
-spring:
-	cloud:
-		openfeign:
-			client:
-				config:
-					default:
-						connectTimeout: 5000
-						readTimeout: 5000
-						loggerLevel: basic
+feign:
+	client:
+		config:
+			default:
+				connectTimeout: 5000
+				readTimeout: 5000
+				loggerLevel: basic
 ----
 
 If we create both `@Configuration` bean and configuration properties, configuration properties will win.
 It will override `@Configuration` values. But if you want to change the priority to `@Configuration`,
-you can change `spring.cloud.openfeign.client.default-to-properties` to `false`.
+you can change `feign.client.default-to-properties` to `false`.
 
 If we want to create multiple feign clients with the same name or url
 so that they would point to the same server but each with a different custom configuration then
@@ -283,14 +261,13 @@ public FeignClientConfigurer feignClientConfigurer() {
 }
 ----
 
-TIP: By default, Feign clients do not encode slash `/` characters. You can change this behaviour, by setting the value of `spring.cloud.openfeign.client.decodeSlash` to `false`.
+TIP: By default, Feign clients do not encode slash `/` characters. You can change this behaviour, by setting the value of `feign.client.decodeSlash` to `false`.
 
-[[springencoder-configuration]]
 ==== `SpringEncoder` configuration
 
 In the `SpringEncoder` that we provide, we set `null` charset for binary content types and `UTF-8` for all the other ones.
 
-You can modify this behaviour to derive the charset from the `Content-Type` header charset instead by setting the value of `spring.cloud.openfeign.encoder.charset-from-content-type` to `true`.
+You can modify this behaviour to derive the charset from the `Content-Type` header charset instead by setting the value of `feign.encoder.charset-from-content-type` to `true`.
 
 [[timeout-handling]]
 === Timeout Handling
@@ -302,7 +279,6 @@ We can configure timeouts on both the default and the named client. OpenFeign wo
 
 NOTE: In case the server is not running or available a packet results in _connection refused_. The communication ends either with an error message or in a fallback. This can happen _before_ the `connectTimeout` if it is set very low. The time taken to perform a lookup and to receive such a packet causes a significant part of this delay. It is subject to change based on the remote host that involves a DNS lookup.
 
-[[creating-feign-clients-manually]]
 === Creating Feign Clients Manually
 
 In some cases it might be necessary to customize your Feign Clients in a way that is not
@@ -321,12 +297,12 @@ class FooController {
 	private FooClient adminClient;
 
 	@Autowired
-	public FooController(Client client, Encoder encoder, Decoder decoder, Contract contract, MicrometerObservationCapability micrometerObservationCapability) {
+	public FooController(Client client, Encoder encoder, Decoder decoder, Contract contract, MicrometerCapability micrometerCapability) {
 		this.fooClient = Feign.builder().client(client)
 				.encoder(encoder)
 				.decoder(decoder)
 				.contract(contract)
-				.addCapability(micrometerObservationCapability)
+				.addCapability(micrometerCapability)
 				.requestInterceptor(new BasicAuthRequestInterceptor("user", "user"))
 				.target(FooClient.class, "https://PROD-SVC");
 
@@ -334,7 +310,7 @@ class FooController {
 				.encoder(encoder)
 				.decoder(decoder)
 				.contract(contract)
-				.addCapability(micrometerObservationCapability)
+				.addCapability(micrometerCapability)
 				.requestInterceptor(new BasicAuthRequestInterceptor("admin", "admin"))
 				.target(FooClient.class, "https://PROD-SVC");
 	}
@@ -356,7 +332,7 @@ You can do this by overriding calling `inheritParentContext(false)` on the `Buil
 [[spring-cloud-feign-circuitbreaker]]
 === Feign Spring Cloud CircuitBreaker Support
 
-If Spring Cloud CircuitBreaker is on the classpath and `spring.cloud.openfeign.circuitbreaker.enabled=true`, Feign will wrap all methods with a circuit breaker.
+If Spring Cloud CircuitBreaker is on the classpath and `feign.circuitbreaker.enabled=true`, Feign will wrap all methods with a circuit breaker.
 
 To disable Spring Cloud CircuitBreaker support on a per-client basis create a vanilla `Feign.Builder` with the "prototype" scope, e.g.:
 
@@ -389,49 +365,8 @@ public class FooConfiguration {
 }
 ----
 
-To enable Spring Cloud CircuitBreaker group set the `spring.cloud.openfeign.circuitbreaker.group.enabled` property to `true` (by default `false`).
-
-[[spring-clou-feign-circuitbreaker-configurationproperties]]
-=== Configuring CircuitBreakers With Configuration Properties
-
-You can configure CircuitBreakers via configuration properties.
-
-For example, if you had this Feign client
-
-[source,java,indent=0]
-----
-@FeignClient(url = "http://localhost:8080")
-public interface DemoClient {
-
-    @GetMapping("demo")
-    String getDemo();
-}
-----
-
-You could configure it using configuration properties by doing the following
+To enable Spring Cloud CircuitBreaker group set the `feign.circuitbreaker.group.enabled` property to `true` (by default `false`).
 
-[source,yaml,indent=0]
-----
-spring:
-  cloud:
-    openfeign:
-      circuitbreaker:
-        enabled: true
-        alphanumeric-ids:
-          enabled: true
-resilience4j:
-  circuitbreaker:
-    instances:
-      DemoClientgetDemo:
-        minimumNumberOfCalls: 69
-  timelimiter:
-    instances:
-      DemoClientgetDemo:
-        timeoutDuration: 10s
-----
-
-NOTE: If you want to switch back to the circuit breaker names used prior to Spring Cloud
-2022.0.0 you can set `spring.cloud.openfeign.circuitbreaker.alphanumeric-ids.enabled` to `false`.
 
 [[spring-cloud-feign-circuitbreaker-fallback]]
 === Feign Spring Cloud CircuitBreaker Fallbacks
@@ -508,7 +443,6 @@ If one needs access to the cause that made the fallback trigger, one can use the
 	}
 ----
 
-[[feign-and-primary]]
 === Feign and `@Primary`
 
 When using Feign with Spring Cloud CircuitBreaker fallbacks, there are multiple beans in the `ApplicationContext` of the same type. This will cause `@Autowired` to not work because there isn't exactly one bean, or one marked as primary. To work around this, Spring Cloud OpenFeign marks all Feign instances as `@Primary`, so Spring Framework will know which bean to inject. In some cases, this may not be desirable. To turn off this behavior set the `primary` attribute of `@FeignClient` to false.
@@ -559,7 +493,6 @@ public interface UserClient extends UserService {
 
 WARNING: `@FeignClient` interfaces should not be shared between server and client and annotating `@FeignClient` interfaces with `@RequestMapping` on class level is no longer supported.
 
-[[feign-request/response-compression]]
 === Feign request/response compression
 
 You may consider enabling the request or response GZIP compression for your
@@ -567,27 +500,32 @@ Feign requests. You can do this by enabling one of the properties:
 
 [source,java]
 ----
-spring.cloud.openfeign.compression.request.enabled=true
-spring.cloud.openfeign.compression.response.enabled=true
+feign.compression.request.enabled=true
+feign.compression.response.enabled=true
 ----
 
 Feign request compression gives you settings similar to what you may set for your web server:
 
 [source,java]
 ----
-spring.cloud.openfeign.compression.request.enabled=true
-spring.cloud.openfeign.compression.request.mime-types=text/xml,application/xml,application/json
-spring.cloud.openfeign.compression.request.min-request-size=2048
+feign.compression.request.enabled=true
+feign.compression.request.mime-types=text/xml,application/xml,application/json
+feign.compression.request.min-request-size=2048
 ----
 
 These properties allow you to be selective about the compressed media types and minimum request threshold length.
 
-TIP: Since the OkHttpClient uses "transparent" compression, that is disabled if the `content-encoding` or `accept-encoding` header is present, we do not enable compression when `feign.okhttp.OkHttpClient` is present on the classpath and `spring.cloud.openfeign.okhttp.enabled` is set to `true`.
+For http clients except OkHttpClient, default gzip decoder can be enabled to decode gzip response in UTF-8 encoding:
+
+[source,java]
+----
+feign.compression.response.enabled=true
+feign.compression.response.useGzipDecoder=true
+----
 
-[[feign-logging]]
 === Feign logging
 
-A logger is created for each Feign client created. By default, the name of the logger is the full class name of the interface used to create the Feign client. Feign logging only responds to the `DEBUG` level.
+A logger is created for each Feign client created. By default the name of the logger is the full class name of the interface used to create the Feign client. Feign logging only responds to the `DEBUG` level.
 
 .application.yml
 
@@ -616,11 +554,10 @@ public class FooConfiguration {
 }
 ----
 
-[[feign-capability-support]]
 === Feign Capability support
 
 The Feign capabilities expose core Feign components so that these components can be modified. For example, the capabilities can take the `Client`, _decorate_ it, and give the decorated instance back to Feign.
-The support for Micrometer is a good real-life example for this. See xref:spring-cloud-openfeign.adoc#micrometer-support[Micrometer Support].
+The support for metrics libraries is a good real-life example for this. See <<feign-metrics>>.
 
 Creating one or more `Capability` beans and placing them in a `@FeignClient` configuration lets you register them and modify the behavior of the involved client.
 
@@ -635,43 +572,29 @@ public class FooConfiguration {
 }
 ----
 
-[[micrometer-support]]
-=== Micrometer Support
+=== Feign metrics
 
-If all of the following conditions are true, a `MicrometerObservationCapability` bean is created and registered so that your Feign client is observable by Micrometer:
+If all of the following conditions are true, a `MicrometerCapability` bean is created and registered so that your Feign client publishes metrics to Micrometer:
 
 * `feign-micrometer` is on the classpath
-* A `ObservationRegistry` bean is available
-* feign micrometer properties are set to `true` (by default)
-	- `spring.cloud.openfeign.micrometer.enabled=true` (for all clients)
-	- `spring.cloud.openfeign.client.config.feignName.micrometer.enabled=true` (for a single client)
+* A `MeterRegistry` bean is available
+* feign metrics properties are set to `true` (by default)
+	- `feign.metrics.enabled=true` (for all clients)
+	- `feign.client.config.feignName.metrics.enabled=true` (for a single client)
 
-NOTE: If your application already uses Micrometer, enabling this feature is as simple as putting `feign-micrometer` onto your classpath.
+NOTE: If your application already uses Micrometer, enabling metrics is as simple as putting `feign-micrometer` onto your classpath.
 
 You can also disable the feature by either:
 
 * excluding `feign-micrometer` from your classpath
-* setting one of the feign micrometer properties to `false`
-	- `spring.cloud.openfeign.micrometer.enabled=false`
-	- `spring.cloud.openfeign.client.config.feignName.micrometer.enabled=false`
-
-NOTE: `spring.cloud.openfeign.micrometer.enabled=false` disables Micrometer support for *all* Feign clients regardless of the value of the client-level flags: `spring.cloud.openfeign.client.config.feignName.micrometer.enabled`.
-If you want to enable or disable Micrometer support per client, don't set `spring.cloud.openfeign.micrometer.enabled` and use `spring.cloud.openfeign.client.config.feignName.micrometer.enabled`.
-
-You can also customize the `MicrometerObservationCapability` by registering your own bean:
+* setting one of the feign metrics properties to `false`
+	- `feign.metrics.enabled=false`
+	- `feign.client.config.feignName.metrics.enabled=false`
 
-[source,java,indent=0]
-----
-@Configuration
-public class FooConfiguration {
-	@Bean
-	public MicrometerObservationCapability micrometerObservationCapability(ObservationRegistry registry) {
-		return new MicrometerObservationCapability(registry);
-	}
-}
-----
+NOTE: `feign.metrics.enabled=false` disables metrics support for *all* Feign clients regardless of the value of the client-level flags: `feign.client.config.feignName.metrics.enabled`.
+If you want to enable or disable merics per client, don't set `feign.metrics.enabled` and use `feign.client.config.feignName.metrics.enabled`.
 
-It is still possible to use `MicrometerCapability` with Feign (metrics-only support), you need to disable Micrometer support (`spring.cloud.openfeign.micrometer.enabled=false`) and create a `MicrometerCapability` bean:
+You can also customize the `MicrometerCapability` by registering your own bean:
 
 [source,java,indent=0]
 ----
@@ -684,26 +607,12 @@ public class FooConfiguration {
 }
 ----
 
-[[feign-caching]]
-=== Feign Caching
-
-If `@EnableCaching` annotation is used, a `CachingCapability` bean is created and registered so that your Feign client recognizes `@Cache*` annotations on its interface:
-
-[source,java,indent=0]
-----
-public interface DemoClient {
-
-	@GetMapping("/demo/{filterParam}")
-    @Cacheable(cacheNames = "demo-cache", key = "#keyParam")
-	String demoEndpoint(String keyParam, @PathVariable String filterParam);
-}
-----
-
-You can also disable the feature via property `spring.cloud.openfeign.cache.enabled=false`.
-
-[[feign-querymap-support]]
 === Feign @QueryMap support
 
+The OpenFeign `@QueryMap` annotation provides support for POJOs to be used as
+GET parameter maps. Unfortunately, the default OpenFeign QueryMap annotation is
+incompatible with Spring because it lacks a `value` property.
+
 Spring Cloud OpenFeign provides an equivalent `@SpringQueryMap` annotation, which
 is used to annotate a POJO or Map parameter as a query parameter map.
 
@@ -734,7 +643,6 @@ public interface DemoTemplate {
 
 If you need more control over the generated query parameter map, you can implement a custom `QueryMapEncoder` bean.
 
-[[hateoas-support]]
 === HATEOAS support
 
 Spring provides some APIs to create REST representations that follow the https://en.wikipedia.org/wiki/HATEOAS[HATEOAS] principle, https://spring.io/projects/spring-hateoas[Spring Hateoas] and https://spring.io/projects/spring-data-rest[Spring Data REST].
@@ -755,7 +663,6 @@ public interface DemoTemplate {
 }
 ----
 
-[[spring-matrixvariable-support]]
 === Spring @MatrixVariable Support
 
 Spring Cloud OpenFeign provides support for the Spring `@MatrixVariable` annotation.
@@ -786,32 +693,30 @@ public interface DemoTemplate {
 }
 ----
 
-[[feign-collectionformat-support]]
 === Feign `CollectionFormat` support
-We support `feign.CollectionFormat` by providing the `@CollectionFormat` annotation.
-You can annotate a Feign client method (or the whole class to affect all methods) with it by passing the desired `feign.CollectionFormat` as annotation value.
+We support `feign.CollectionFormat` by providing the `@CollectionFormat` annotation.You can annotate a Feign client method with it by passing the desired `feign.CollectionFormat` as annotation value.
 
 In the following example, the `CSV` format is used instead of the default `EXPLODED` to process the method.
 
 [source,java,indent=0]
 ----
 @FeignClient(name = "demo")
-protected interface DemoFeignClient {
+	protected interface PageableFeignClient {
 
-    @CollectionFormat(feign.CollectionFormat.CSV)
-    @GetMapping(path = "/test")
-    ResponseEntity performRequest(String test);
+		@CollectionFormat(feign.CollectionFormat.CSV)
+		@GetMapping(path = "/page")
+		ResponseEntity performRequest(Pageable page);
 
-}
+	}
 ----
 
-[[reactive-support]]
+TIP: Set the `CSV` format while sending `Pageable` as a query parameter in order for it to be encoded correctly.
+
 === Reactive Support
 As the https://github.com/OpenFeign/feign[OpenFeign project] does not currently support reactive clients, such as https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/reactive/function/client/WebClient.html[Spring WebClient], neither does Spring Cloud OpenFeign.We will add support for it here as soon as it becomes available in the core project.
 
 Until that is done, we recommend using https://github.com/Playtika/feign-reactive[feign-reactive] for Spring WebClient support.
 
-[[early-initialization-errors]]
 ==== Early Initialization Errors
 
 Depending on how you are using your Feign clients you may see initialization errors when starting your application.
@@ -820,134 +725,29 @@ To work around this problem you can use an `ObjectProvider` when autowiring your
 [source,java,indent=0]
 ----
 @Autowired
-ObjectProvider<TestFeignClient> testFeignClient;
+ObjectProvider<TestFeginClient> testFeginClient;
 ----
 
-[[spring-data-support]]
 === Spring Data Support
 
-If Jackson Databind and Spring Data Commons are on the classpath, converters for `org.springframework.data.domain.Page` and `org.springframework.data.domain.Sort` will be added automatically.
+You may consider enabling Jackson Modules for the support `org.springframework.data.domain.Page` and `org.springframework.data.domain.Sort` decoding.
 
-To disable this behaviour set
 [source,java]
 ----
-spring.cloud.openfeign.autoconfiguration.jackson.enabled=false
+feign.autoconfiguration.jackson.enabled=true
 ----
 
-See `org.springframework.cloud.openfeign.FeignAutoConfiguration.FeignJacksonConfiguration` for details.
-
-[[spring-refreshscope-support]]
 === Spring `@RefreshScope` Support
-If Feign client refresh is enabled, each Feign client is created with:
-
-* `feign.Request.Options` as a refresh-scoped bean. This means properties such as `connectTimeout` and `readTimeout` can be refreshed against any Feign client instance.
-* A url wrapped under `org.springframework.cloud.openfeign.RefreshableUrl`. This means the URL of Feign client, if defined
-with `spring.cloud.openfeign.client.config.\{feignName}.url` property, can be refreshed against any Feign client instance.
-
-You can refresh these properties through `POST /actuator/refresh`.
+If Feign client refresh is enabled, each feign client is created with `feign.Request.Options` as a refresh-scoped bean. This means properties such as `connectTimeout` and `readTimeout` can be refreshed against any Feign client instance through `POST /actuator/refresh`.
 
 By default, refresh behavior in Feign clients is disabled. Use the following property to enable refresh behavior:
 [source,java]
 ----
-spring.cloud.openfeign.client.refresh-enabled=true
+feign.client.refresh-enabled=true
 ----
 TIP: DO NOT annotate the `@FeignClient` interface with the `@RefreshScope` annotation.
 
-[[oauth2-support]]
-=== OAuth2 Support
-OAuth2 support can be enabled by setting following flag:
-----
-spring.cloud.openfeign.oauth2.enabled=true
-----
-When the flag is set to true, and the oauth2 client context resource details are present, a bean of class `OAuth2AccessTokenInterceptor` is created. Before each request, the interceptor resolves the required access token and includes it as a header.
-`OAuth2AccessTokenInterceptor` uses the `OAuth2AuthorizedClientManager` to get `OAuth2AuthorizedClient` that holds an `OAuth2AccessToken`. If the user has specified an OAuth2 `clientRegistrationId` using the `spring.cloud.openfeign.oauth2.clientRegistrationId` property, it will be used to retrieve the token. If the token is not retrieved or the `clientRegistrationId` has not been specified, the `serviceId` retrieved from the `url` host segment will be used.
-
-TIP:: Using the `serviceId` as OAuth2 client registrationId is convenient for load-balanced Feign clients. For non-load-balanced ones, the property-based `clientRegistrationId` is a suitable approach.
-
-TIP:: If you do not want to use the default setup for the `OAuth2AuthorizedClientManager`, you can just instantiate a bean of this type in your configuration.
-
-[[transform-the-load-balanced-http-request]]
-=== Transform the load-balanced HTTP request
-
-You can use the selected `ServiceInstance` to transform the load-balanced HTTP Request.
-
-For `Request`, you need to implement and define `LoadBalancerFeignRequestTransformer`, as follows:
-
-[source,java,indent=0]
-----
-	@Bean
-	public LoadBalancerFeignRequestTransformer transformer() {
-		return new LoadBalancerFeignRequestTransformer() {
-
-			@Override
-			public Request transformRequest(Request request, ServiceInstance instance) {
-				Map<String, Collection<String>> headers = new HashMap<>(request.headers());
-				headers.put("X-ServiceId", Collections.singletonList(instance.getServiceId()));
-				headers.put("X-InstanceId", Collections.singletonList(instance.getInstanceId()));
-				return Request.create(request.httpMethod(), request.url(), headers, request.body(), request.charset(),
-						request.requestTemplate());
-			}
-		};
-	}
-----
-
-If multiple transformers are defined, they are applied in the order in which beans are defined.
-Alternatively, you can use `LoadBalancerFeignRequestTransformer.DEFAULT_ORDER` to specify the order.
-
-[[x-forwarded-headers-support]]
-=== X-Forwarded Headers Support
-
-`X-Forwarded-Host` and `X-Forwarded-Proto` support can be enabled by setting following flag:
-
-[source,properties]
-----
-spring.cloud.loadbalancer.x-forwarded.enabled=true
-----
-
-[[supported-ways-to-provide-url-to-a-feign-client]]
-=== Supported Ways To Provide URL To A Feign Client
-You can provide a URL to a Feign client in any of the following ways:
-
-|===
-|Case |Example |Details
-
-|The URL is provided in the `@FeignClient` annotation.
-|`@FeignClient(name="testClient", url="http://localhost:8081")`
-|The URL is resolved from the `url` attribute of the annotation, without load-balancing.
-
-|The URL is provided in the `@FeignClient` annotation and in the
-configuration properties.
-|`@FeignClient(name="testClient", url="http://localhost:8081")` and the property defined in `application.yml` as
-`spring.cloud.openfeign.client.config.testClient.url=http://localhost:8081`
-|The URL is resolved from the `url` attribute of the annotation, without load-balancing.
-The URL provided in the configuration properties remains unused.
-
-|The URL is not provided in the `@FeignClient` annotation but is provided in configuration properties.
-| `@FeignClient(name="testClient")` and the property defined in `application.yml` as
-`spring.cloud.openfeign.client.config.testClient.url=http://localhost:8081`
-|The URL is resolved from configuration properties, without load-balancing. If
-`spring.cloud.openfeign.client.refresh-enabled=true`, then the URL defined in configuration properties can be refreshed as described in <<Spring `@RefreshScope` Support,Spring RefreshScope Support>>.
-
-|The URL is neither provided in the `@FeignClient` annotation nor in configuration properties.
-|`@FeignClient(name="testClient")`
-|The URL is resolved from `name` attribute of annotation, with load balancing.
-
-|===
-
-[[aot-and-native-image-support]]
-=== AOT and Native Image Support
-
-Spring Cloud OpenFeign supports Spring AOT transformations and native images, however, only with refresh mode disabled, Feign clients refresh disabled (default setting) and xref:spring-cloud-openfeign.adoc#attribute-resolution-mode[lazy `@FeignClient` attribute resolution] disabled (default setting).
-
-WARNING: If you want to run Spring Cloud OpenFeign clients in AOT or native image modes, make sure to set `spring.cloud.refresh.enabled` to `false`.
-
-TIP: If you want to run Spring Cloud OpenFeign clients in AOT or native image modes, ensure `spring.cloud.openfeign.client.refresh-enabled` has not been set to `true`.
-
-TIP: If you want to run Spring Cloud OpenFeign clients in AOT or native image modes, ensure `spring.cloud.openfeign.lazy-attributes-resolution` has not been set to `true`.
-
-TIP:  However, if you set the `url` value via properties, it is possible to override the `@FeignClient` `url` value by running the image with `-Dspring.cloud.openfeign.client.config.[clientId].url=[url]` flag. In order to enable overriding, a `url` value also has to be set via properties and not `@FeignClient` attribute during buildtime.
 
-[[configuration-properties]]
 == Configuration properties
 
 To see the list of all Spring Cloud OpenFeign related configuration properties please check link:appendix.html[the Appendix page].

mvnw

@@ -8,7 +8,7 @@
 # "License"); you may not use this file except in compliance
 # with the License.  You may obtain a copy of the License at
 #
-#    http://www.apache.org/licenses/LICENSE-2.0
+#    https://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing,
 # software distributed under the License is distributed on an
@@ -19,7 +19,7 @@
 # ----------------------------------------------------------------------------
 
 # ----------------------------------------------------------------------------
-# Apache Maven Wrapper startup batch script, version 3.2.0
+# Maven2 Start Up Batch script
 #
 # Required ENV vars:
 # ------------------
@@ -27,6 +27,7 @@
 #
 # Optional ENV vars
 # -----------------
+#   M2_HOME - location of maven2's installed home dir
 #   MAVEN_OPTS - parameters passed to the Java VM when running Maven
 #     e.g. to debug Maven itself, use
 #       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
@@ -35,10 +36,6 @@
 
 if [ -z "$MAVEN_SKIP_RC" ] ; then
 
-  if [ -f /usr/local/etc/mavenrc ] ; then
-    . /usr/local/etc/mavenrc
-  fi
-
   if [ -f /etc/mavenrc ] ; then
     . /etc/mavenrc
   fi
@@ -53,56 +50,109 @@ fi
 cygwin=false;
 darwin=false;
 mingw=false
-case "$(uname)" in
+case "`uname`" in
   CYGWIN*) cygwin=true ;;
   MINGW*) mingw=true;;
   Darwin*) darwin=true
-    # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
-    # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
-    if [ -z "$JAVA_HOME" ]; then
-      if [ -x "/usr/libexec/java_home" ]; then
-        JAVA_HOME="$(/usr/libexec/java_home)"; export JAVA_HOME
-      else
-        JAVA_HOME="/Library/Java/Home"; export JAVA_HOME
-      fi
-    fi
-    ;;
+           #
+           # Look for the Apple JDKs first to preserve the existing behaviour, and then look
+           # for the new JDKs provided by Oracle.
+           #
+           if [ -z "$JAVA_HOME" ] && [ -L /System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK ] ; then
+             #
+             # Apple JDKs
+             #
+             export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Home
+           fi
+
+           if [ -z "$JAVA_HOME" ] && [ -L /System/Library/Java/JavaVirtualMachines/CurrentJDK ] ; then
+             #
+             # Apple JDKs
+             #
+             export JAVA_HOME=/System/Library/Java/JavaVirtualMachines/CurrentJDK/Contents/Home
+           fi
+
+           if [ -z "$JAVA_HOME" ] && [ -L "/Library/Java/JavaVirtualMachines/CurrentJDK" ] ; then
+             #
+             # Oracle JDKs
+             #
+             export JAVA_HOME=/Library/Java/JavaVirtualMachines/CurrentJDK/Contents/Home
+           fi
+
+           if [ -z "$JAVA_HOME" ] && [ -x "/usr/libexec/java_home" ]; then
+             #
+             # Apple JDKs
+             #
+             export JAVA_HOME=`/usr/libexec/java_home`
+           fi
+           ;;
 esac
 
 if [ -z "$JAVA_HOME" ] ; then
   if [ -r /etc/gentoo-release ] ; then
-    JAVA_HOME=$(java-config --jre-home)
+    JAVA_HOME=`java-config --jre-home`
   fi
 fi
 
+if [ -z "$M2_HOME" ] ; then
+  ## resolve links - $0 may be a link to maven's home
+  PRG="$0"
+
+  # need this for relative symlinks
+  while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+      PRG="$link"
+    else
+      PRG="`dirname "$PRG"`/$link"
+    fi
+  done
+
+  saveddir=`pwd`
+
+  M2_HOME=`dirname "$PRG"`/..
+
+  # make it fully qualified
+  M2_HOME=`cd "$M2_HOME" && pwd`
+
+  cd "$saveddir"
+  # echo Using m2 at $M2_HOME
+fi
+
 # For Cygwin, ensure paths are in UNIX format before anything is touched
 if $cygwin ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --unix "$M2_HOME"`
   [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME=$(cygpath --unix "$JAVA_HOME")
+    JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
   [ -n "$CLASSPATH" ] &&
-    CLASSPATH=$(cygpath --path --unix "$CLASSPATH")
+    CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
 fi
 
-# For Mingw, ensure paths are in UNIX format before anything is touched
+# For Migwn, ensure paths are in UNIX format before anything is touched
 if $mingw ; then
-  [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] &&
-    JAVA_HOME="$(cd "$JAVA_HOME" || (echo "cannot cd into $JAVA_HOME."; exit 1); pwd)"
+  [ -n "$M2_HOME" ] &&
+    M2_HOME="`(cd "$M2_HOME"; pwd)`"
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+  # TODO classpath?
 fi
 
 if [ -z "$JAVA_HOME" ]; then
-  javaExecutable="$(which javac)"
-  if [ -n "$javaExecutable" ] && ! [ "$(expr "\"$javaExecutable\"" : '\([^ ]*\)')" = "no" ]; then
+  javaExecutable="`which javac`"
+  if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
     # readlink(1) is not available as standard on Solaris 10.
-    readLink=$(which readlink)
-    if [ ! "$(expr "$readLink" : '\([^ ]*\)')" = "no" ]; then
+    readLink=`which readlink`
+    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
       if $darwin ; then
-        javaHome="$(dirname "\"$javaExecutable\"")"
-        javaExecutable="$(cd "\"$javaHome\"" && pwd -P)/javac"
+        javaHome="`dirname \"$javaExecutable\"`"
+        javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
       else
-        javaExecutable="$(readlink -f "\"$javaExecutable\"")"
+        javaExecutable="`readlink -f \"$javaExecutable\"`"
       fi
-      javaHome="$(dirname "\"$javaExecutable\"")"
-      javaHome=$(expr "$javaHome" : '\(.*\)/bin')
+      javaHome="`dirname \"$javaExecutable\"`"
+      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
       JAVA_HOME="$javaHome"
       export JAVA_HOME
     fi
@@ -118,7 +168,7 @@ if [ -z "$JAVACMD" ] ; then
       JAVACMD="$JAVA_HOME/bin/java"
     fi
   else
-    JAVACMD="$(\unset -f command 2>/dev/null; \command -v java)"
+    JAVACMD="`which java`"
   fi
 fi
 
@@ -132,177 +182,72 @@ if [ -z "$JAVA_HOME" ] ; then
   echo "Warning: JAVA_HOME environment variable is not set."
 fi
 
+CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --path --windows "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
+fi
+
 # traverses directory structure from process work directory to filesystem root
 # first directory with .mvn subdirectory is considered project base directory
 find_maven_basedir() {
-  if [ -z "$1" ]
-  then
-    echo "Path not specified to find_maven_basedir"
-    return 1
-  fi
-
-  basedir="$1"
-  wdir="$1"
+  local basedir=$(pwd)
+  local wdir=$(pwd)
   while [ "$wdir" != '/' ] ; do
     if [ -d "$wdir"/.mvn ] ; then
       basedir=$wdir
       break
     fi
-    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
-    if [ -d "${wdir}" ]; then
-      wdir=$(cd "$wdir/.." || exit 1; pwd)
-    fi
-    # end of workaround
+    wdir=$(cd "$wdir/.."; pwd)
   done
-  printf '%s' "$(cd "$basedir" || exit 1; pwd)"
+  echo "${basedir}"
 }
 
 # concatenates all lines of a file
 concat_lines() {
   if [ -f "$1" ]; then
-    # Remove \r in case we run on Windows within Git Bash
-    # and check out the repository with auto CRLF management
-    # enabled. Otherwise, we may read lines that are delimited with
-    # \r\n and produce $'-Xarg\r' rather than -Xarg due to word
-    # splitting rules.
-    tr -s '\r\n' ' ' < "$1"
+    echo "$(tr -s '\n' ' ' < "$1")"
   fi
 }
 
-log() {
-  if [ "$MVNW_VERBOSE" = true ]; then
-    printf '%s\n' "$1"
-  fi
-}
-
-BASE_DIR=$(find_maven_basedir "$(dirname "$0")")
-if [ -z "$BASE_DIR" ]; then
-  exit 1;
-fi
-
-MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}; export MAVEN_PROJECTBASEDIR
-log "$MAVEN_PROJECTBASEDIR"
-
-##########################################################################################
-# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
-# This allows using the maven wrapper in projects that prohibit checking in binary data.
-##########################################################################################
-wrapperJarPath="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar"
-if [ -r "$wrapperJarPath" ]; then
-    log "Found $wrapperJarPath"
-else
-    log "Couldn't find $wrapperJarPath, downloading it ..."
-
-    if [ -n "$MVNW_REPOURL" ]; then
-      wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
-    else
-      wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
-    fi
-    while IFS="=" read -r key value; do
-      # Remove '\r' from value to allow usage on windows as IFS does not consider '\r' as a separator ( considers space, tab, new line ('\n'), and custom '=' )
-      safeValue=$(echo "$value" | tr -d '\r')
-      case "$key" in (wrapperUrl) wrapperUrl="$safeValue"; break ;;
-      esac
-    done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
-    log "Downloading from: $wrapperUrl"
-
-    if $cygwin; then
-      wrapperJarPath=$(cygpath --path --windows "$wrapperJarPath")
-    fi
-
-    if command -v wget > /dev/null; then
-        log "Found wget ... using wget"
-        [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--quiet"
-        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
-            wget $QUIET "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
-        else
-            wget $QUIET --http-user="$MVNW_USERNAME" --http-password="$MVNW_PASSWORD" "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
-        fi
-    elif command -v curl > /dev/null; then
-        log "Found curl ... using curl"
-        [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--silent"
-        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
-            curl $QUIET -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
-        else
-            curl $QUIET --user "$MVNW_USERNAME:$MVNW_PASSWORD" -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
-        fi
-    else
-        log "Falling back to using Java to download"
-        javaSource="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.java"
-        javaClass="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.class"
-        # For Cygwin, switch paths to Windows format before running javac
-        if $cygwin; then
-          javaSource=$(cygpath --path --windows "$javaSource")
-          javaClass=$(cygpath --path --windows "$javaClass")
-        fi
-        if [ -e "$javaSource" ]; then
-            if [ ! -e "$javaClass" ]; then
-                log " - Compiling MavenWrapperDownloader.java ..."
-                ("$JAVA_HOME/bin/javac" "$javaSource")
-            fi
-            if [ -e "$javaClass" ]; then
-                log " - Running MavenWrapperDownloader.java ..."
-                ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$wrapperUrl" "$wrapperJarPath") || rm -f "$wrapperJarPath"
-            fi
-        fi
-    fi
-fi
-##########################################################################################
-# End of extension
-##########################################################################################
-
-# If specified, validate the SHA-256 sum of the Maven wrapper jar file
-wrapperSha256Sum=""
-while IFS="=" read -r key value; do
-  case "$key" in (wrapperSha256Sum) wrapperSha256Sum=$value; break ;;
-  esac
-done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
-if [ -n "$wrapperSha256Sum" ]; then
-  wrapperSha256Result=false
-  if command -v sha256sum > /dev/null; then
-    if echo "$wrapperSha256Sum  $wrapperJarPath" | sha256sum -c > /dev/null 2>&1; then
-      wrapperSha256Result=true
-    fi
-  elif command -v shasum > /dev/null; then
-    if echo "$wrapperSha256Sum  $wrapperJarPath" | shasum -a 256 -c > /dev/null 2>&1; then
-      wrapperSha256Result=true
-    fi
-  else
-    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available."
-    echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties."
-    exit 1
-  fi
-  if [ $wrapperSha256Result = false ]; then
-    echo "Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised." >&2
-    echo "Investigate or delete $wrapperJarPath to attempt a clean download." >&2
-    echo "If you updated your Maven version, you need to update the specified wrapperSha256Sum property." >&2
-    exit 1
-  fi
-fi
-
+export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-$(find_maven_basedir)}
 MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
 
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin; then
-  [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME")
-  [ -n "$CLASSPATH" ] &&
-    CLASSPATH=$(cygpath --path --windows "$CLASSPATH")
-  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
-    MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR")
-fi
-
 # Provide a "standardized" way to retrieve the CLI args that will
 # work with both Windows and non-Windows executions.
-MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $*"
+MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@"
 export MAVEN_CMD_LINE_ARGS
 
 WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
 
-# shellcheck disable=SC2086 # safe args
+echo "Running version check"
+VERSION=$( sed '\!<parent!,\!</parent!d' `dirname $0`/pom.xml | grep '<version' | head -1 | sed -e 's/.*<version>//' -e 's!</version>.*$!!' )
+echo "The found version is [${VERSION}]"
+
+if echo $VERSION | egrep -q 'M|RC'; then
+    echo Activating \"milestone\" profile for version=\"$VERSION\"
+    echo $MAVEN_ARGS | grep -q milestone || MAVEN_ARGS="$MAVEN_ARGS -Pmilestone"
+else
+    echo Deactivating \"milestone\" profile for version=\"$VERSION\"
+    echo $MAVEN_ARGS | grep -q milestone && MAVEN_ARGS=$(echo $MAVEN_ARGS | sed -e 's/-Pmilestone//')
+fi
+
+if echo $VERSION | egrep -q 'RELEASE'; then
+    echo Activating \"central\" profile for version=\"$VERSION\"
+    echo $MAVEN_ARGS | grep -q milestone || MAVEN_ARGS="$MAVEN_ARGS -Pcentral"
+else
+    echo Deactivating \"central\" profile for version=\"$VERSION\"
+    echo $MAVEN_ARGS | grep -q central && MAVEN_ARGS=$(echo $MAVEN_ARGS | sed -e 's/-Pcentral//')
+fi
+
 exec "$JAVACMD" \
   $MAVEN_OPTS \
-  $MAVEN_DEBUG_OPTS \
   -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
-  "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
-  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
+  "-Dmaven.home=${M2_HOME}" "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+  ${WRAPPER_LAUNCHER} ${MAVEN_ARGS} "$@"

mvnw.cmd

@@ -7,7 +7,7 @@
 @REM "License"); you may not use this file except in compliance
 @REM with the License.  You may obtain a copy of the License at
 @REM
-@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM    https://www.apache.org/licenses/LICENSE-2.0
 @REM
 @REM Unless required by applicable law or agreed to in writing,
 @REM software distributed under the License is distributed on an
@@ -18,14 +18,15 @@
 @REM ----------------------------------------------------------------------------
 
 @REM ----------------------------------------------------------------------------
-@REM Apache Maven Wrapper startup batch script, version 3.2.0
+@REM Maven2 Start Up Batch script
 @REM
 @REM Required ENV vars:
 @REM JAVA_HOME - location of a JDK home dir
 @REM
 @REM Optional ENV vars
+@REM M2_HOME - location of maven2's installed home dir
 @REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
-@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a key stroke before ending
 @REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
 @REM     e.g. to debug Maven itself, use
 @REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
@@ -34,9 +35,7 @@
 
 @REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
 @echo off
-@REM set title of command window
-title %0
-@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@REM enable echoing my setting MAVEN_BATCH_ECHO to 'on'
 @if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
 
 @REM set %HOME% to equivalent of $HOME
@@ -45,8 +44,8 @@ if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
 @REM Execute a user defined script before this one
 if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
 @REM check for pre script, once with legacy .bat ending and once with .cmd ending
-if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
-if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+if exist "%HOME%\mavenrc_pre.bat" call "%HOME%\mavenrc_pre.bat"
+if exist "%HOME%\mavenrc_pre.cmd" call "%HOME%\mavenrc_pre.cmd"
 :skipRcPre
 
 @setlocal
@@ -81,6 +80,8 @@ goto error
 
 :init
 
+set MAVEN_CMD_LINE_ARGS=%*
+
 @REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
 @REM Fallback to current working directory if not found.
 
@@ -116,72 +117,11 @@ for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do s
 :endReadAdditionalConfig
 
 SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
-set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
-set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
 
-set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
-
-FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
-    IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B
-)
-
-@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
-@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
-if exist %WRAPPER_JAR% (
-    if "%MVNW_VERBOSE%" == "true" (
-        echo Found %WRAPPER_JAR%
-    )
-) else (
-    if not "%MVNW_REPOURL%" == "" (
-        SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
-    )
-    if "%MVNW_VERBOSE%" == "true" (
-        echo Couldn't find %WRAPPER_JAR%, downloading it ...
-        echo Downloading from: %WRAPPER_URL%
-    )
-
-    powershell -Command "&{"^
-		"$webclient = new-object System.Net.WebClient;"^
-		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
-		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
-		"}"^
-		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%WRAPPER_URL%', '%WRAPPER_JAR%')"^
-		"}"
-    if "%MVNW_VERBOSE%" == "true" (
-        echo Finished downloading %WRAPPER_JAR%
-    )
-)
-@REM End of extension
-
-@REM If specified, validate the SHA-256 sum of the Maven wrapper jar file
-SET WRAPPER_SHA_256_SUM=""
-FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
-    IF "%%A"=="wrapperSha256Sum" SET WRAPPER_SHA_256_SUM=%%B
-)
-IF NOT %WRAPPER_SHA_256_SUM%=="" (
-    powershell -Command "&{"^
-       "$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^
-       "If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^
-       "  Write-Output 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
-       "  Write-Output 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
-       "  Write-Output 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
-       "  exit 1;"^
-       "}"^
-       "}"
-    if ERRORLEVEL 1 goto error
-)
-
-@REM Provide a "standardized" way to retrieve the CLI args that will
-@REM work with both Windows and non-Windows executions.
-set MAVEN_CMD_LINE_ARGS=%*
+set WRAPPER_JAR="".\.mvn\wrapper\maven-wrapper.jar""
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
 
-%MAVEN_JAVA_EXE% ^
-  %JVM_CONFIG_MAVEN_PROPS% ^
-  %MAVEN_OPTS% ^
-  %MAVEN_DEBUG_OPTS% ^
-  -classpath %WRAPPER_JAR% ^
-  "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
-  %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+%MAVEN_JAVA_EXE% %JVM_CONFIG_MAVEN_PROPS% %MAVEN_OPTS% %MAVEN_DEBUG_OPTS% -classpath %WRAPPER_JAR% "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" %WRAPPER_LAUNCHER% %MAVEN_CMD_LINE_ARGS%
 if ERRORLEVEL 1 goto error
 goto end
 
@@ -191,15 +131,15 @@ set ERROR_CODE=1
 :end
 @endlocal & set ERROR_CODE=%ERROR_CODE%
 
-if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPost
 @REM check for post script, once with legacy .bat ending and once with .cmd ending
-if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
-if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+if exist "%HOME%\mavenrc_post.bat" call "%HOME%\mavenrc_post.bat"
+if exist "%HOME%\mavenrc_post.cmd" call "%HOME%\mavenrc_post.cmd"
 :skipRcPost
 
 @REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
-if "%MAVEN_BATCH_PAUSE%"=="on" pause
+if "%MAVEN_BATCH_PAUSE%" == "on" pause
 
-if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+if "%MAVEN_TERMINATE_CMD%" == "on" exit %ERROR_CODE%
 
-cmd /C exit /B %ERROR_CODE%
+exit /B %ERROR_CODE%

pom.xml

@@ -4,14 +4,14 @@
 		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>spring-cloud-openfeign</artifactId>
-	<version>4.1.0-SNAPSHOT</version>
+	<version>3.0.8-SNAPSHOT</version>
 	<packaging>pom</packaging>
 	<name>Spring Cloud OpenFeign</name>
 	<description>Spring Cloud OpenFeign</description>
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-build</artifactId>
-		<version>4.1.0-SNAPSHOT</version>
+		<version>3.0.6-SNAPSHOT</version>
 		<relativePath/>
 	</parent>
 	<scm>
@@ -25,8 +25,8 @@
 	</scm>
 	<properties>
 		<main.basedir>${basedir}</main.basedir>
-		<jackson.version>2.15.2</jackson.version>
-		<spring-cloud-commons.version>4.1.0-SNAPSHOT</spring-cloud-commons.version>
+		<jackson.version>2.11.3</jackson.version>
+		<spring-cloud-commons.version>3.0.7-SNAPSHOT</spring-cloud-commons.version>
 
 		<!-- Plugin versions -->
 		<maven-eclipse-plugin.version>2.10</maven-eclipse-plugin.version>
@@ -64,6 +64,13 @@
 					</additionalConfig>
 				</configuration>
 			</plugin>
+			<plugin>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<configuration>
+					<source>1.8</source>
+					<target>1.8</target>
+				</configuration>
+			</plugin>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-checkstyle-plugin</artifactId>
@@ -72,15 +79,6 @@
 				<groupId>io.spring.javaformat</groupId>
 				<artifactId>spring-javaformat-maven-plugin</artifactId>
 			</plugin>
-			<plugin>
-				<groupId>org.basepom.maven</groupId>
-				<artifactId>duplicate-finder-maven-plugin</artifactId>
-				<configuration>
-					<ignoredResourcePatterns>
-						<ignoredResourcePattern>mozilla/public-suffix-list.txt</ignoredResourcePattern>
-					</ignoredResourcePatterns>
-				</configuration>
-			</plugin>
 		</plugins>
 	</build>
 
@@ -135,7 +133,7 @@
 				<repository>
 					<id>spring-snapshots</id>
 					<name>Spring Snapshots</name>
-					<url>https://repo.spring.io/snapshot</url>
+					<url>https://repo.spring.io/libs-snapshot-local</url>
 					<snapshots>
 						<enabled>true</enabled>
 					</snapshots>
@@ -146,7 +144,7 @@
 				<repository>
 					<id>spring-milestones</id>
 					<name>Spring Milestones</name>
-					<url>https://repo.spring.io/milestone</url>
+					<url>https://repo.spring.io/libs-milestone-local</url>
 					<snapshots>
 						<enabled>false</enabled>
 					</snapshots>
@@ -164,7 +162,7 @@
 				<pluginRepository>
 					<id>spring-snapshots</id>
 					<name>Spring Snapshots</name>
-					<url>https://repo.spring.io/snapshot</url>
+					<url>https://repo.spring.io/libs-snapshot-local</url>
 					<snapshots>
 						<enabled>true</enabled>
 					</snapshots>
@@ -175,7 +173,7 @@
 				<pluginRepository>
 					<id>spring-milestones</id>
 					<name>Spring Milestones</name>
-					<url>https://repo.spring.io/milestone</url>
+					<url>https://repo.spring.io/libs-milestone-local</url>
 					<snapshots>
 						<enabled>false</enabled>
 					</snapshots>
@@ -183,7 +181,7 @@
 				<pluginRepository>
 					<id>spring-releases</id>
 					<name>Spring Releases</name>
-					<url>https://repo.spring.io/release</url>
+					<url>https://repo.spring.io/libs-release-local</url>
 					<snapshots>
 						<enabled>false</enabled>
 					</snapshots>
@@ -228,7 +226,7 @@
 						<artifactId>maven-surefire-plugin</artifactId>
 						<configuration>
 							<!-- Sets the VM argument line used when unit tests are run. -->
-							<argLine>${surefireArgLine} --add-opens=java.base/java.net=ALL-UNNAMED</argLine>
+							<argLine>${surefireArgLine}</argLine>
 						</configuration>
 					</plugin>
 				</plugins>

spring-cloud-openfeign-core/pom.xml

@@ -6,12 +6,9 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>4.1.0-SNAPSHOT</version>
+		<version>3.0.8-SNAPSHOT</version>
 		<relativePath>..</relativePath> <!-- lookup parent from repository -->
 	</parent>
-	<scm>
-		<url>https://github.com/spring-cloud/spring-cloud-openfeign</url>
-	</scm>
 	<artifactId>spring-cloud-openfeign-core</artifactId>
 	<packaging>jar</packaging>
 	<name>Spring Cloud OpenFeign Core</name>
@@ -64,16 +61,15 @@
 			<artifactId>reactor-core</artifactId>
 			<optional>true</optional>
 		</dependency>
+		<dependency>
+			<groupId>io.reactivex</groupId>
+			<artifactId>rxjava-reactive-streams</artifactId>
+			<optional>true</optional>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.retry</groupId>
 			<artifactId>spring-retry</artifactId>
 			<optional>true</optional>
-			<exclusions>
-				<exclusion>
-					<groupId>javax.annotation</groupId>
-					<artifactId>javax.annotation-api</artifactId>
-				</exclusion>
-			</exclusions>
 		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
@@ -97,21 +93,6 @@
 		<dependency>
 			<groupId>io.github.openfeign.form</groupId>
 			<artifactId>feign-form-spring</artifactId>
-			<exclusions>
-<!--				Vulnerable in 3.8.0-->
-				<exclusion>
-					<groupId>commons-io</groupId>
-					<artifactId>commons-io</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>commons-fileupload</groupId>
-					<artifactId>commons-fileupload</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-		<dependency>
-			<groupId>commons-fileupload</groupId>
-			<artifactId>commons-fileupload</artifactId>
 		</dependency>
 		<dependency>
 			<groupId>io.github.openfeign</groupId>
@@ -123,6 +104,11 @@
 			<artifactId>feign-micrometer</artifactId>
 			<optional>true</optional>
 		</dependency>
+		<dependency>
+			<groupId>io.github.openfeign</groupId>
+			<artifactId>feign-httpclient</artifactId>
+			<optional>true</optional>
+		</dependency>
 		<dependency>
 			<groupId>io.github.openfeign</groupId>
 			<artifactId>feign-hc5</artifactId>
@@ -134,8 +120,8 @@
 			<optional>true</optional>
 		</dependency>
 		<dependency>
-			<groupId>io.github.openfeign</groupId>
-			<artifactId>feign-java11</artifactId>
+			<groupId>io.reactivex</groupId>
+			<artifactId>rxjava</artifactId>
 			<optional>true</optional>
 		</dependency>
 		<dependency>
@@ -143,6 +129,11 @@
 			<artifactId>okhttp</artifactId>
 			<optional>true</optional>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework.security.oauth.boot</groupId>
+			<artifactId>spring-security-oauth2-autoconfigure</artifactId>
+			<optional>true</optional>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-autoconfigure-processor</artifactId>
@@ -158,6 +149,11 @@
 			<artifactId>spring-boot-starter-test</artifactId>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.junit.vintage</groupId>
+			<artifactId>junit-vintage-engine</artifactId>
+			<scope>test</scope>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.cloud</groupId>
 			<artifactId>spring-cloud-test-support</artifactId>
@@ -187,7 +183,7 @@
 		<dependency>
 			<groupId>com.google.protobuf</groupId>
 			<artifactId>protobuf-java</artifactId>
-			<version>3.19.6</version>
+			<version>3.19.1</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
@@ -201,27 +197,6 @@
 			<artifactId>spring-cloud-loadbalancer</artifactId>
 			<optional>true</optional>
 		</dependency>
-		<dependency>
-			<groupId>commons-io</groupId>
-			<artifactId>commons-io</artifactId>
-			<version>2.13.0</version>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-core-test</artifactId>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.junit.platform</groupId>
-			<artifactId>junit-platform-launcher</artifactId>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.security</groupId>
-			<artifactId>spring-security-oauth2-client</artifactId>
-			<optional>true</optional>
-		</dependency>
 	</dependencies>
 	<profiles>
 		<profile>

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/CollectionFormat.java

@@ -25,10 +25,9 @@ import java.lang.annotation.Target;
  * Indicates which collection format should be used while processing the annotated method.
  *
  * @author Olga Maciaszek-Sharma
- * @author Sam Kruglov
  * @see feign.CollectionFormat
  */
-@Target({ ElementType.METHOD, ElementType.TYPE })
+@Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface CollectionFormat {
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/DefaultFeignLoggerFactory.java

@@ -21,11 +21,10 @@ import feign.slf4j.Slf4jLogger;
 
 /**
  * @author Venil Noronha
- * @author Olga Maciaszek-Sharma
  */
 public class DefaultFeignLoggerFactory implements FeignLoggerFactory {
 
-	private final Logger logger;
+	private Logger logger;
 
 	public DefaultFeignLoggerFactory(Logger logger) {
 		this.logger = logger;

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/DefaultTargeter.java

@@ -25,7 +25,7 @@ import feign.Target;
 class DefaultTargeter implements Targeter {
 
 	@Override
-	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignClientFactory context,
+	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
 			Target.HardCodedTarget<T> target) {
 		return feign.target(target);
 	}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2023 the original author or authors.
+ * Copyright 2013-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.
@@ -16,42 +16,33 @@
 
 package org.springframework.cloud.openfeign;
 
+import java.io.IOException;
 import java.lang.reflect.Method;
-import java.net.http.HttpClient;
-import java.security.KeyManagementException;
-import java.security.NoSuchAlgorithmException;
-import java.security.cert.X509Certificate;
-import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
 import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
 
-import javax.net.ssl.HostnameVerifier;
-import javax.net.ssl.SSLContext;
-import javax.net.ssl.SSLSession;
-import javax.net.ssl.SSLSocketFactory;
-import javax.net.ssl.TrustManager;
-import javax.net.ssl.X509TrustManager;
+import javax.annotation.PreDestroy;
 
 import com.fasterxml.jackson.databind.Module;
-import feign.Capability;
 import feign.Client;
 import feign.Feign;
+import feign.RequestInterceptor;
 import feign.Target;
 import feign.hc5.ApacheHttp5Client;
-import feign.http2client.Http2Client;
+import feign.httpclient.ApacheHttpClient;
 import feign.okhttp.OkHttpClient;
-import jakarta.annotation.PreDestroy;
 import okhttp3.ConnectionPool;
-import okhttp3.Protocol;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.config.RegistryBuilder;
+import org.apache.http.conn.HttpClientConnectionManager;
+import org.apache.http.impl.client.CloseableHttpClient;
 
-import org.springframework.aot.hint.MemberCategory;
-import org.springframework.aot.hint.RuntimeHints;
-import org.springframework.aot.hint.RuntimeHintsRegistrar;
-import org.springframework.aot.hint.TypeReference;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
@@ -59,13 +50,15 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
-import org.springframework.cache.interceptor.CacheInterceptor;
 import org.springframework.cloud.client.actuator.HasFeatures;
 import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
 import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
-import org.springframework.cloud.openfeign.aot.FeignChildContextInitializer;
-import org.springframework.cloud.openfeign.aot.FeignClientBeanFactoryInitializationAotProcessor;
-import org.springframework.cloud.openfeign.security.OAuth2AccessTokenInterceptor;
+import org.springframework.cloud.commons.httpclient.ApacheHttpClientConnectionManagerFactory;
+import org.springframework.cloud.commons.httpclient.ApacheHttpClientFactory;
+import org.springframework.cloud.commons.httpclient.OkHttpClientConnectionPoolFactory;
+import org.springframework.cloud.commons.httpclient.OkHttpClientFactory;
+import org.springframework.cloud.openfeign.security.OAuth2FeignRequestInterceptor;
+import org.springframework.cloud.openfeign.support.DefaultGzipDecoderConfiguration;
 import org.springframework.cloud.openfeign.support.FeignEncoderProperties;
 import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
 import org.springframework.cloud.openfeign.support.PageJacksonModule;
@@ -74,14 +67,10 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
-import org.springframework.context.support.GenericApplicationContext;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Sort;
-import org.springframework.security.oauth2.client.AuthorizedClientServiceOAuth2AuthorizedClientManager;
-import org.springframework.security.oauth2.client.OAuth2AuthorizedClientManager;
-import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
-import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
-import org.springframework.util.ClassUtils;
+import org.springframework.security.oauth2.client.OAuth2ClientContext;
+import org.springframework.security.oauth2.client.resource.OAuth2ProtectedResourceDetails;
 
 /**
  * @author Spencer Gibb
@@ -93,15 +82,12 @@ import org.springframework.util.ClassUtils;
  * @author Nguyen Ky Thanh
  * @author Andrii Bohutskyi
  * @author Kwangyong Kim
- * @author Sam Kruglov
- * @author Wojciech Mąka
- * @author Dangzhicairang(小水牛)
- * @author changjin wei(魏昌进)
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnClass(Feign.class)
 @EnableConfigurationProperties({ FeignClientProperties.class, FeignHttpClientProperties.class,
 		FeignEncoderProperties.class })
+@Import(DefaultGzipDecoderConfiguration.class)
 public class FeignAutoConfiguration {
 
 	private static final Log LOG = LogFactory.getLog(FeignAutoConfiguration.class);
@@ -115,35 +101,15 @@ public class FeignAutoConfiguration {
 	}
 
 	@Bean
-	public FeignClientFactory feignContext() {
-		FeignClientFactory context = new FeignClientFactory();
+	public FeignContext feignContext() {
+		FeignContext context = new FeignContext();
 		context.setConfigurations(this.configurations);
 		return context;
 	}
 
-	@Bean
-	static FeignChildContextInitializer feignChildContextInitializer(GenericApplicationContext parentContext,
-			FeignClientFactory feignClientFactory) {
-		return new FeignChildContextInitializer(parentContext, feignClientFactory);
-	}
-
-	@Bean
-	static FeignClientBeanFactoryInitializationAotProcessor feignClientBeanFactoryInitializationCodeGenerator(
-			GenericApplicationContext applicationContext, FeignClientFactory feignClientFactory) {
-		return new FeignClientBeanFactoryInitializationAotProcessor(applicationContext, feignClientFactory);
-	}
-
-	@Bean
-	@ConditionalOnProperty(value = "spring.cloud.openfeign.cache.enabled", matchIfMissing = true)
-	@ConditionalOnBean(CacheInterceptor.class)
-	public Capability cachingCapability(CacheInterceptor cacheInterceptor) {
-		return new CachingCapability(cacheInterceptor);
-	}
-
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass({ Module.class, Page.class, Sort.class })
-	@ConditionalOnProperty(value = "spring.cloud.openfeign.autoconfiguration.jackson.enabled", havingValue = "true",
-			matchIfMissing = true)
+	@ConditionalOnProperty(value = "feign.autoconfiguration.jackson.enabled", havingValue = "true")
 	protected static class FeignJacksonConfiguration {
 
 		@Bean
@@ -174,7 +140,7 @@ public class FeignAutoConfiguration {
 
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(CircuitBreaker.class)
-	@ConditionalOnProperty(value = "spring.cloud.openfeign.circuitbreaker.enabled", havingValue = "true")
+	@ConditionalOnProperty(value = "feign.circuitbreaker.enabled", havingValue = "true")
 	protected static class CircuitBreakerPresentFeignTargeterConfiguration {
 
 		@Bean
@@ -185,26 +151,15 @@ public class FeignAutoConfiguration {
 
 		@Bean
 		@ConditionalOnMissingBean(CircuitBreakerNameResolver.class)
-		@ConditionalOnProperty(value = "spring.cloud.openfeign.circuitbreaker.alphanumeric-ids.enabled",
-				havingValue = "false")
 		public CircuitBreakerNameResolver circuitBreakerNameResolver() {
 			return new DefaultCircuitBreakerNameResolver();
 		}
 
-		@Bean
-		@ConditionalOnMissingBean(CircuitBreakerNameResolver.class)
-		@ConditionalOnProperty(value = "spring.cloud.openfeign.circuitbreaker.alphanumeric-ids.enabled",
-				havingValue = "true", matchIfMissing = true)
-		public CircuitBreakerNameResolver alphanumericCircuitBreakerNameResolver() {
-			return new AlphanumericCircuitBreakerNameResolver();
-		}
-
-		@SuppressWarnings("rawtypes")
 		@Bean
 		@ConditionalOnMissingBean
 		@ConditionalOnBean(CircuitBreakerFactory.class)
 		public Targeter circuitBreakerFeignTargeter(CircuitBreakerFactory circuitBreakerFactory,
-				@Value("${spring.cloud.openfeign.circuitbreaker.group.enabled:false}") boolean circuitBreakerGroupEnabled,
+				@Value("${feign.circuitbreaker.group.enabled:false}") boolean circuitBreakerGroupEnabled,
 				CircuitBreakerNameResolver circuitBreakerNameResolver) {
 			return new FeignCircuitBreakerTargeter(circuitBreakerFactory, circuitBreakerGroupEnabled,
 					circuitBreakerNameResolver);
@@ -219,78 +174,110 @@ public class FeignAutoConfiguration {
 
 		}
 
-		static class AlphanumericCircuitBreakerNameResolver extends DefaultCircuitBreakerNameResolver {
-
-			@Override
-			public String resolveCircuitBreakerName(String feignClientName, Target<?> target, Method method) {
-				return super.resolveCircuitBreakerName(feignClientName, target, method).replaceAll("[^a-zA-Z0-9]", "");
-			}
-
-		}
-
 	}
 
 	// the following configuration is for alternate feign clients if
 	// SC loadbalancer is not on the class path.
 	// see corresponding configurations in FeignLoadBalancerAutoConfiguration
 	// for load-balanced clients.
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnClass(ApacheHttpClient.class)
+	@ConditionalOnMissingBean(CloseableHttpClient.class)
+	@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
+	@Conditional(HttpClient5DisabledConditions.class)
+	protected static class HttpClientFeignConfiguration {
+
+		private final Timer connectionManagerTimer = new Timer(
+				"FeignApacheHttpClientConfiguration.connectionManagerTimer", true);
+
+		@Autowired(required = false)
+		private RegistryBuilder registryBuilder;
+
+		private CloseableHttpClient httpClient;
+
+		@Bean
+		@ConditionalOnMissingBean(HttpClientConnectionManager.class)
+		public HttpClientConnectionManager connectionManager(
+				ApacheHttpClientConnectionManagerFactory connectionManagerFactory,
+				FeignHttpClientProperties httpClientProperties) {
+			final HttpClientConnectionManager connectionManager = connectionManagerFactory.newConnectionManager(
+					httpClientProperties.isDisableSslValidation(), httpClientProperties.getMaxConnections(),
+					httpClientProperties.getMaxConnectionsPerRoute(), httpClientProperties.getTimeToLive(),
+					httpClientProperties.getTimeToLiveUnit(), this.registryBuilder);
+			this.connectionManagerTimer.schedule(new TimerTask() {
+				@Override
+				public void run() {
+					connectionManager.closeExpiredConnections();
+				}
+			}, 30000, httpClientProperties.getConnectionTimerRepeat());
+			return connectionManager;
+		}
+
+		@Bean
+		public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory,
+				HttpClientConnectionManager httpClientConnectionManager,
+				FeignHttpClientProperties httpClientProperties) {
+			RequestConfig defaultRequestConfig = RequestConfig.custom()
+					.setConnectTimeout(httpClientProperties.getConnectionTimeout())
+					.setRedirectsEnabled(httpClientProperties.isFollowRedirects()).build();
+			this.httpClient = httpClientFactory.createBuilder().setConnectionManager(httpClientConnectionManager)
+					.setDefaultRequestConfig(defaultRequestConfig).build();
+			return this.httpClient;
+		}
+
+		@Bean
+		@ConditionalOnMissingBean(Client.class)
+		public Client feignClient(HttpClient httpClient) {
+			return new ApacheHttpClient(httpClient);
+		}
+
+		@PreDestroy
+		public void destroy() {
+			this.connectionManagerTimer.cancel();
+			if (this.httpClient != null) {
+				try {
+					this.httpClient.close();
+				}
+				catch (IOException e) {
+					if (LOG.isErrorEnabled()) {
+						LOG.error("Could not correctly close httpClient.");
+					}
+				}
+			}
+		}
+
+	}
+
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(OkHttpClient.class)
 	@ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
-	@ConditionalOnProperty("spring.cloud.openfeign.okhttp.enabled")
+	@ConditionalOnProperty("feign.okhttp.enabled")
 	protected static class OkHttpFeignConfiguration {
 
 		private okhttp3.OkHttpClient okHttpClient;
 
-		@Bean
-		@ConditionalOnMissingBean
-		public okhttp3.OkHttpClient.Builder okHttpClientBuilder() {
-			return new okhttp3.OkHttpClient.Builder();
-		}
-
 		@Bean
 		@ConditionalOnMissingBean(ConnectionPool.class)
-		public ConnectionPool httpClientConnectionPool(FeignHttpClientProperties httpClientProperties) {
-			int maxTotalConnections = httpClientProperties.getMaxConnections();
-			long timeToLive = httpClientProperties.getTimeToLive();
+		public ConnectionPool httpClientConnectionPool(FeignHttpClientProperties httpClientProperties,
+				OkHttpClientConnectionPoolFactory connectionPoolFactory) {
+			Integer maxTotalConnections = httpClientProperties.getMaxConnections();
+			Long timeToLive = httpClientProperties.getTimeToLive();
 			TimeUnit ttlUnit = httpClientProperties.getTimeToLiveUnit();
-			return new ConnectionPool(maxTotalConnections, timeToLive, ttlUnit);
+			return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
 		}
 
 		@Bean
-		public okhttp3.OkHttpClient okHttpClient(okhttp3.OkHttpClient.Builder builder, ConnectionPool connectionPool,
+		public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory, ConnectionPool connectionPool,
 				FeignHttpClientProperties httpClientProperties) {
-			boolean followRedirects = httpClientProperties.isFollowRedirects();
-			int connectTimeout = httpClientProperties.getConnectionTimeout();
-			boolean disableSslValidation = httpClientProperties.isDisableSslValidation();
-			Duration readTimeout = httpClientProperties.getOkHttp().getReadTimeout();
-			List<Protocol> protocols = httpClientProperties.getOkHttp().getProtocols().stream().map(Protocol::valueOf)
-					.collect(Collectors.toList());
-			if (disableSslValidation) {
-				disableSsl(builder);
-			}
-			this.okHttpClient = builder.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
-					.followRedirects(followRedirects).readTimeout(readTimeout).connectionPool(connectionPool)
-					.protocols(protocols).build();
+			Boolean followRedirects = httpClientProperties.isFollowRedirects();
+			Integer connectTimeout = httpClientProperties.getConnectionTimeout();
+			Boolean disableSslValidation = httpClientProperties.isDisableSslValidation();
+			this.okHttpClient = httpClientFactory.createBuilder(disableSslValidation)
+					.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).followRedirects(followRedirects)
+					.connectionPool(connectionPool).build();
 			return this.okHttpClient;
 		}
 
-		private void disableSsl(okhttp3.OkHttpClient.Builder builder) {
-			try {
-				X509TrustManager disabledTrustManager = new DisableValidationTrustManager();
-				TrustManager[] trustManagers = new TrustManager[1];
-				trustManagers[0] = disabledTrustManager;
-				SSLContext sslContext = SSLContext.getInstance("SSL");
-				sslContext.init(null, trustManagers, new java.security.SecureRandom());
-				SSLSocketFactory disabledSSLSocketFactory = sslContext.getSocketFactory();
-				builder.sslSocketFactory(disabledSSLSocketFactory, disabledTrustManager);
-				builder.hostnameVerifier(new TrustAllHostnames());
-			}
-			catch (NoSuchAlgorithmException | KeyManagementException e) {
-				LOG.warn("Error setting SSLSocketFactory in OKHttpClient", e);
-			}
-		}
-
 		@PreDestroy
 		public void destroy() {
 			if (this.okHttpClient != null) {
@@ -305,49 +292,12 @@ public class FeignAutoConfiguration {
 			return new OkHttpClient(client);
 		}
 
-		/**
-		 * A {@link X509TrustManager} that does not validate SSL certificates.
-		 */
-		class DisableValidationTrustManager implements X509TrustManager {
-
-			@Override
-			public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {
-			}
-
-			@Override
-			public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {
-			}
-
-			@Override
-			public X509Certificate[] getAcceptedIssuers() {
-				return new X509Certificate[0];
-			}
-
-		}
-
-		/**
-		 * A {@link HostnameVerifier} that does not validate any hostnames.
-		 */
-		class TrustAllHostnames implements HostnameVerifier {
-
-			@Override
-			public boolean verify(String s, SSLSession sslSession) {
-				return true;
-			}
-
-		}
-
 	}
 
-	// the following configuration is for alternate feign clients if
-	// SC loadbalancer is not on the class path.
-	// see corresponding configurations in FeignLoadBalancerAutoConfiguration
-	// for load-balanced clients.
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(ApacheHttp5Client.class)
 	@ConditionalOnMissingBean(org.apache.hc.client5.http.impl.classic.CloseableHttpClient.class)
-	@ConditionalOnProperty(value = "spring.cloud.openfeign.httpclient.hc5.enabled", havingValue = "true",
-			matchIfMissing = true)
+	@ConditionalOnProperty(value = "feign.httpclient.hc5.enabled", havingValue = "true")
 	@Import(org.springframework.cloud.openfeign.clientconfig.HttpClient5FeignConfiguration.class)
 	protected static class HttpClient5FeignConfiguration {
 
@@ -360,62 +310,19 @@ public class FeignAutoConfiguration {
 	}
 
 	@Configuration(proxyBeanMethods = false)
-	@ConditionalOnClass(OAuth2AuthorizedClientManager.class)
-	@ConditionalOnProperty("spring.cloud.openfeign.oauth2.enabled")
+	@ConditionalOnClass(OAuth2ClientContext.class)
+	@ConditionalOnProperty("feign.oauth2.enabled")
+	@Deprecated // spring-security-oauth2 reached EOL
 	protected static class Oauth2FeignConfiguration {
 
 		@Bean
-		@ConditionalOnBean({ OAuth2AuthorizedClientService.class, ClientRegistrationRepository.class })
-		@ConditionalOnMissingBean
-		OAuth2AuthorizedClientManager feignOAuth2AuthorizedClientManager(
-				ClientRegistrationRepository clientRegistrationRepository,
-				OAuth2AuthorizedClientService oAuth2AuthorizedClientService) {
-			return new AuthorizedClientServiceOAuth2AuthorizedClientManager(clientRegistrationRepository,
-					oAuth2AuthorizedClientService);
-
+		@ConditionalOnMissingBean(OAuth2FeignRequestInterceptor.class)
+		@ConditionalOnBean({ OAuth2ClientContext.class, OAuth2ProtectedResourceDetails.class })
+		public RequestInterceptor oauth2FeignRequestInterceptor(OAuth2ClientContext oAuth2ClientContext,
+				OAuth2ProtectedResourceDetails resource) {
+			return new OAuth2FeignRequestInterceptor(oAuth2ClientContext, resource);
 		}
 
-		@Bean
-		@ConditionalOnBean(OAuth2AuthorizedClientManager.class)
-		public OAuth2AccessTokenInterceptor defaultOAuth2AccessTokenInterceptor(
-				@Value("${spring.cloud.openfeign.oauth2.clientRegistrationId:}") String clientRegistrationId,
-				OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
-			return new OAuth2AccessTokenInterceptor(clientRegistrationId, oAuth2AuthorizedClientManager);
-		}
-
-	}
-
-	// the following configuration is for alternate feign clients if
-	// SC loadbalancer is not on the class path.
-	// see corresponding configurations in FeignLoadBalancerAutoConfiguration
-	// for load-balanced clients.
-	@Configuration(proxyBeanMethods = false)
-	@ConditionalOnClass({ Http2Client.class, HttpClient.class })
-	@ConditionalOnMissingBean(HttpClient.class)
-	@ConditionalOnProperty("spring.cloud.openfeign.http2client.enabled")
-	@Import(org.springframework.cloud.openfeign.clientconfig.Http2ClientFeignConfiguration.class)
-	protected static class Http2ClientFeignConfiguration {
-
-		@Bean
-		@ConditionalOnMissingBean(Client.class)
-		public Client feignClient(HttpClient httpClient) {
-			return new Http2Client(httpClient);
-		}
-
-	}
-
-}
-
-class FeignHints implements RuntimeHintsRegistrar {
-
-	@Override
-	public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
-		if (!ClassUtils.isPresent("feign.Feign", classLoader)) {
-			return;
-		}
-		hints.reflection().registerType(TypeReference.of(FeignClientFactoryBean.class),
-				hint -> hint.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
-						MemberCategory.INVOKE_DECLARED_METHODS, MemberCategory.DECLARED_FIELDS));
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignCachingInvocationHandlerFactory.java

@@ -1,82 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign;
-
-import java.lang.reflect.AccessibleObject;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.util.Map;
-import java.util.Optional;
-
-import feign.InvocationHandlerFactory;
-import feign.Target;
-import org.aopalliance.intercept.MethodInvocation;
-
-import org.springframework.cache.interceptor.CacheInterceptor;
-
-/**
- * Allows Spring's @Cache* annotations to be declared on the feign client's methods.
- *
- * @author Sam Kruglov
- */
-public class FeignCachingInvocationHandlerFactory implements InvocationHandlerFactory {
-
-	private final InvocationHandlerFactory delegateFactory;
-
-	private final CacheInterceptor cacheInterceptor;
-
-	public FeignCachingInvocationHandlerFactory(InvocationHandlerFactory delegateFactory,
-			CacheInterceptor cacheInterceptor) {
-		this.delegateFactory = delegateFactory;
-		this.cacheInterceptor = cacheInterceptor;
-	}
-
-	@Override
-	public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) {
-		final InvocationHandler delegateHandler = delegateFactory.create(target, dispatch);
-		return (proxy, method, argsNullable) -> {
-			Object[] args = Optional.ofNullable(argsNullable).orElseGet(() -> new Object[0]);
-			return cacheInterceptor.invoke(new MethodInvocation() {
-				@Override
-				public Method getMethod() {
-					return method;
-				}
-
-				@Override
-				public Object[] getArguments() {
-					return args;
-				}
-
-				@Override
-				public Object proceed() throws Throwable {
-					return delegateHandler.invoke(proxy, method, args);
-				}
-
-				@Override
-				public Object getThis() {
-					return target;
-				}
-
-				@Override
-				public AccessibleObject getStaticPart() {
-					return method;
-				}
-			});
-		};
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignCircuitBreaker.java

@@ -77,7 +77,7 @@ public final class FeignCircuitBreaker {
 		}
 
 		public <T> T target(Target<T> target, T fallback) {
-			return build(fallback != null ? new FallbackFactory.Default<>(fallback) : null).newInstance(target);
+			return build(fallback != null ? new FallbackFactory.Default<T>(fallback) : null).newInstance(target);
 		}
 
 		public <T> T target(Target<T> target, FallbackFactory<? extends T> fallbackFactory) {

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignCircuitBreakerDisabledConditions.java

@@ -31,8 +31,7 @@ class FeignCircuitBreakerDisabledConditions extends AnyNestedCondition {
 
 	}
 
-	@ConditionalOnProperty(value = "spring.cloud.openfeign.circuitbreaker.enabled", havingValue = "false",
-			matchIfMissing = true)
+	@ConditionalOnProperty(value = "feign.circuitbreaker.enabled", havingValue = "false", matchIfMissing = true)
 	static class CircuitBreakerDisabled {
 
 	}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignCircuitBreakerInvocationHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2023 the original author or authors.
+ * Copyright 2013-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.
@@ -36,14 +36,6 @@ import org.springframework.web.context.request.RequestContextHolder;
 
 import static feign.Util.checkNotNull;
 
-/**
- * @author Marcin Grzejszczak
- * @author Olga Maciaszek-Sharma
- * @author Niang
- * @author Bohutskyi
- * @author kim
- * @author Vicasong
- */
 class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 
 	private final CircuitBreakerFactory factory;
@@ -76,7 +68,7 @@ class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 	}
 
 	@Override
-	public Object invoke(final Object proxy, final Method method, final Object[] args) {
+	public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
 		// early exit if the invoked method is from java.lang.Object
 		// code is the same as ReflectiveFeign.FeignInvocationHandler
 		if ("equals".equals(method.getName())) {
@@ -130,13 +122,9 @@ class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 
 	private Supplier<Object> asSupplier(final Method method, final Object[] args) {
 		final RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
-		final Thread caller = Thread.currentThread();
 		return () -> {
-			boolean isAsync = caller != Thread.currentThread();
 			try {
-				if (isAsync) {
-					RequestContextHolder.setRequestAttributes(requestAttributes);
-				}
+				RequestContextHolder.setRequestAttributes(requestAttributes);
 				return dispatch.get(method).invoke(args);
 			}
 			catch (RuntimeException throwable) {
@@ -145,25 +133,20 @@ class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 			catch (Throwable throwable) {
 				throw new RuntimeException(throwable);
 			}
-			finally {
-				if (isAsync) {
-					RequestContextHolder.resetRequestAttributes();
-				}
-			}
 		};
 	}
 
 	/**
-	 * If the method param of {@link InvocationHandler#invoke(Object, Method, Object[])}
-	 * is not accessible, i.e in a package-private interface, the fallback call will cause
-	 * of access restrictions. But methods in dispatch are copied methods. So setting
-	 * access to dispatch method doesn't take effect to the method in
-	 * InvocationHandler.invoke. Use map to store a copy of method to invoke the fallback
-	 * to bypass this and reducing the count of reflection calls.
+	 * If the method param of InvocationHandler.invoke is not accessible, i.e in a
+	 * package-private interface, the fallback call will cause of access restrictions. But
+	 * methods in dispatch are copied methods. So setting access to dispatch method
+	 * doesn't take effect to the method in InvocationHandler.invoke. Use map to store a
+	 * copy of method to invoke the fallback to bypass this and reducing the count of
+	 * reflection calls.
 	 * @return cached methods map for fallback invoking
 	 */
 	static Map<Method, Method> toFallbackMethod(Map<Method, InvocationHandlerFactory.MethodHandler> dispatch) {
-		Map<Method, Method> result = new LinkedHashMap<>();
+		Map<Method, Method> result = new LinkedHashMap<Method, Method>();
 		for (Method method : dispatch.keySet()) {
 			method.setAccessible(true);
 			result.put(method, method);
@@ -173,7 +156,8 @@ class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 
 	@Override
 	public boolean equals(Object obj) {
-		if (obj instanceof FeignCircuitBreakerInvocationHandler other) {
+		if (obj instanceof FeignCircuitBreakerInvocationHandler) {
+			FeignCircuitBreakerInvocationHandler other = (FeignCircuitBreakerInvocationHandler) obj;
 			return this.target.equals(other.target);
 		}
 		return false;

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignCircuitBreakerTargeter.java

@@ -19,13 +19,9 @@ package org.springframework.cloud.openfeign;
 import feign.Feign;
 import feign.Target;
 
-import org.springframework.beans.factory.FactoryBean;
 import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
 import org.springframework.util.StringUtils;
 
-/**
- * @author 黄学敏（huangxuemin)
- */
 @SuppressWarnings("unchecked")
 class FeignCircuitBreakerTargeter implements Targeter {
 
@@ -43,11 +39,12 @@ class FeignCircuitBreakerTargeter implements Targeter {
 	}
 
 	@Override
-	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignClientFactory context,
+	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
 			Target.HardCodedTarget<T> target) {
-		if (!(feign instanceof FeignCircuitBreaker.Builder builder)) {
+		if (!(feign instanceof FeignCircuitBreaker.Builder)) {
 			return feign.target(target);
 		}
+		FeignCircuitBreaker.Builder builder = (FeignCircuitBreaker.Builder) feign;
 		String name = !StringUtils.hasText(factory.getContextId()) ? factory.getName() : factory.getContextId();
 		Class<?> fallback = factory.getFallback();
 		if (fallback != void.class) {
@@ -60,20 +57,20 @@ class FeignCircuitBreakerTargeter implements Targeter {
 		return builder(name, builder).target(target);
 	}
 
-	private <T> T targetWithFallbackFactory(String feignClientName, FeignClientFactory context,
+	private <T> T targetWithFallbackFactory(String feignClientName, FeignContext context,
 			Target.HardCodedTarget<T> target, FeignCircuitBreaker.Builder builder, Class<?> fallbackFactoryClass) {
 		FallbackFactory<? extends T> fallbackFactory = (FallbackFactory<? extends T>) getFromContext("fallbackFactory",
 				feignClientName, context, fallbackFactoryClass, FallbackFactory.class);
 		return builder(feignClientName, builder).target(target, fallbackFactory);
 	}
 
-	private <T> T targetWithFallback(String feignClientName, FeignClientFactory context,
-			Target.HardCodedTarget<T> target, FeignCircuitBreaker.Builder builder, Class<?> fallback) {
+	private <T> T targetWithFallback(String feignClientName, FeignContext context, Target.HardCodedTarget<T> target,
+			FeignCircuitBreaker.Builder builder, Class<?> fallback) {
 		T fallbackInstance = getFromContext("fallback", feignClientName, context, fallback, target.type());
 		return builder(feignClientName, builder).target(target, fallbackInstance);
 	}
 
-	private <T> T getFromContext(String fallbackMechanism, String feignClientName, FeignClientFactory context,
+	private <T> T getFromContext(String fallbackMechanism, String feignClientName, FeignContext context,
 			Class<?> beanType, Class<T> targetType) {
 		Object fallbackInstance = context.getInstance(feignClientName, beanType);
 		if (fallbackInstance == null) {
@@ -82,27 +79,10 @@ class FeignCircuitBreakerTargeter implements Targeter {
 							beanType, feignClientName));
 		}
 
-		if (fallbackInstance instanceof FactoryBean<?> factoryBean) {
-			try {
-				fallbackInstance = factoryBean.getObject();
-			}
-			catch (Exception e) {
-				throw new IllegalStateException(fallbackMechanism + " create fail", e);
-			}
-
-			if (!targetType.isAssignableFrom(fallbackInstance.getClass())) {
-				throw new IllegalStateException(String.format("Incompatible " + fallbackMechanism
-						+ " instance. Fallback/fallbackFactory of type %s is not assignable to %s for feign client %s",
-						fallbackInstance.getClass(), targetType, feignClientName));
-			}
-
-		}
-		else {
-			if (!targetType.isAssignableFrom(beanType)) {
-				throw new IllegalStateException(String.format("Incompatible " + fallbackMechanism
-						+ " instance. Fallback/fallbackFactory of type %s is not assignable to %s for feign client %s",
-						beanType, targetType, feignClientName));
-			}
+		if (!targetType.isAssignableFrom(beanType)) {
+			throw new IllegalStateException(String.format("Incompatible " + fallbackMechanism
+					+ " instance. Fallback/fallbackFactory of type %s is not assignable to %s for feign client %s",
+					beanType, targetType, feignClientName));
 		}
 		return (T) fallbackInstance;
 	}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClient.java

@@ -64,8 +64,27 @@ public @interface FeignClient {
 	@AliasFor("value")
 	String name() default "";
 
+	/**
+	 * @return the <code>@Qualifier</code> value for the feign client.
+	 * @deprecated in favour of {@link #qualifiers()}.
+	 *
+	 * If both {@link #qualifier()} and {@link #qualifiers()} are present, we will use the
+	 * latter, unless the array returned by {@link #qualifiers()} is empty or only
+	 * contains <code>null</code> or whitespace values, in which case we'll fall back
+	 * first to {@link #qualifier()} and, if that's also not present, to the default =
+	 * <code>contextId + "FeignClient"</code>.
+	 */
+	@Deprecated
+	String qualifier() default "";
+
 	/**
 	 * @return the <code>@Qualifiers</code> value for the feign client.
+	 *
+	 * If both {@link #qualifier()} and {@link #qualifiers()} are present, we will use the
+	 * latter, unless the array returned by {@link #qualifiers()} is empty or only
+	 * contains <code>null</code> or whitespace values, in which case we'll fall back
+	 * first to {@link #qualifier()} and, if that's also not present, to the default =
+	 * <code>contextId + "FeignClient"</code>.
 	 */
 	String[] qualifiers() default {};
 
@@ -77,7 +96,7 @@ public @interface FeignClient {
 	/**
 	 * @return whether 404s should be decoded instead of throwing FeignExceptions
 	 */
-	boolean dismiss404() default false;
+	boolean decode404() default false;
 
 	/**
 	 * A custom configuration class for the feign client. Can contain override

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientBuilder.java

@@ -29,7 +29,6 @@ import org.springframework.context.ApplicationContext;
  * @author Sven Döring
  * @author Matt King
  * @author Sam Kruglov
- * @author Olga Maciaszek-Sharma
  */
 public class FeignClientBuilder {
 
@@ -55,7 +54,7 @@ public class FeignClientBuilder {
 	 */
 	public static final class Builder<T> {
 
-		private final FeignClientFactoryBean feignClientFactoryBean;
+		private FeignClientFactoryBean feignClientFactoryBean;
 
 		private Builder(final ApplicationContext applicationContext, final Class<T> type, final String name) {
 			this(applicationContext, new FeignClientFactoryBean(), type, name);
@@ -72,7 +71,7 @@ public class FeignClientBuilder {
 			this.feignClientFactoryBean.setInheritParentContext(true);
 			// preset default values - these values resemble the default values on the
 			// FeignClient annotation
-			this.url("").path("").dismiss404(false);
+			this.url("").path("").decode404(false);
 		}
 
 		public Builder<T> url(final String url) {
@@ -102,8 +101,8 @@ public class FeignClientBuilder {
 			return this;
 		}
 
-		public Builder<T> dismiss404(final boolean dismiss404) {
-			this.feignClientFactoryBean.setDismiss404(dismiss404);
+		public Builder<T> decode404(final boolean decode404) {
+			this.feignClientFactoryBean.setDecode404(decode404);
 			return this;
 		}
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientFactoryBean.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2023 the original author or authors.
+ * Copyright 2013-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.
@@ -32,7 +32,6 @@ import feign.Logger;
 import feign.QueryMapEncoder;
 import feign.Request;
 import feign.RequestInterceptor;
-import feign.ResponseInterceptor;
 import feign.Retryer;
 import feign.Target.HardCodedTarget;
 import feign.codec.Decoder;
@@ -69,9 +68,6 @@ import org.springframework.util.StringUtils;
  * @author Jonatan Ivanov
  * @author Sam Kruglov
  * @author Jasbir Singh
- * @author Hyeonmin Park
- * @author Felix Dittrich
- * @author Dominique Villard
  */
 public class FeignClientFactoryBean
 		implements FactoryBean<Object>, InitializingBean, ApplicationContextAware, BeanFactoryAware {
@@ -81,7 +77,7 @@ public class FeignClientFactoryBean
 	 * lifecycle race condition.
 	 ***********************************/
 
-	private static final Log LOG = LogFactory.getLog(FeignClientFactoryBean.class);
+	private static Log LOG = LogFactory.getLog(FeignClientFactoryBean.class);
 
 	private Class<?> type;
 
@@ -93,7 +89,7 @@ public class FeignClientFactoryBean
 
 	private String path;
 
-	private boolean dismiss404;
+	private boolean decode404;
 
 	private boolean inheritParentContext = true;
 
@@ -115,22 +111,13 @@ public class FeignClientFactoryBean
 
 	private final List<FeignBuilderCustomizer> additionalCustomizers = new ArrayList<>();
 
-	private String[] qualifiers = new String[] {};
-
-	// For AOT testing
-	public FeignClientFactoryBean() {
-		if (LOG.isDebugEnabled()) {
-			LOG.debug("Creating a FeignClientFactoryBean.");
-		}
-	}
-
 	@Override
 	public void afterPropertiesSet() {
 		Assert.hasText(contextId, "Context id must be set");
 		Assert.hasText(name, "Name must be set");
 	}
 
-	protected Feign.Builder feign(FeignClientFactory context) {
+	protected Feign.Builder feign(FeignContext context) {
 		FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
 		Logger logger = loggerFactory.create(type);
 
@@ -144,11 +131,12 @@ public class FeignClientFactoryBean
 		// @formatter:on
 
 		configureFeign(context, builder);
+		applyBuildCustomizers(context, builder);
 
 		return builder;
 	}
 
-	private void applyBuildCustomizers(FeignClientFactory context, Feign.Builder builder) {
+	private void applyBuildCustomizers(FeignContext context, Feign.Builder builder) {
 		Map<String, FeignBuilderCustomizer> customizerMap = context.getInstances(contextId,
 				FeignBuilderCustomizer.class);
 
@@ -159,7 +147,7 @@ public class FeignClientFactoryBean
 		additionalCustomizers.forEach(customizer -> customizer.customize(builder));
 	}
 
-	protected void configureFeign(FeignClientFactory context, Feign.Builder builder) {
+	protected void configureFeign(FeignContext context, Feign.Builder builder) {
 		FeignClientProperties properties = beanFactory != null ? beanFactory.getBean(FeignClientProperties.class)
 				: applicationContext.getBean(FeignClientProperties.class);
 
@@ -183,7 +171,7 @@ public class FeignClientFactoryBean
 		}
 	}
 
-	protected void configureUsingConfiguration(FeignClientFactory context, Feign.Builder builder) {
+	protected void configureUsingConfiguration(FeignContext context, Feign.Builder builder) {
 		Logger.Level level = getInheritedAwareOptional(context, Logger.Level.class);
 		if (level != null) {
 			builder.logLevel(level);
@@ -221,16 +209,12 @@ public class FeignClientFactoryBean
 			AnnotationAwareOrderComparator.sort(interceptors);
 			builder.requestInterceptors(interceptors);
 		}
-		ResponseInterceptor responseInterceptor = getInheritedAwareOptional(context, ResponseInterceptor.class);
-		if (responseInterceptor != null) {
-			builder.responseInterceptor(responseInterceptor);
-		}
 		QueryMapEncoder queryMapEncoder = getInheritedAwareOptional(context, QueryMapEncoder.class);
 		if (queryMapEncoder != null) {
 			builder.queryMapEncoder(queryMapEncoder);
 		}
-		if (dismiss404) {
-			builder.dismiss404();
+		if (decode404) {
+			builder.decode404();
 		}
 		ExceptionPropagationPolicy exceptionPropagationPolicy = getInheritedAwareOptional(context,
 				ExceptionPropagationPolicy.class);
@@ -283,13 +267,9 @@ public class FeignClientFactoryBean
 			}
 		}
 
-		if (config.getResponseInterceptor() != null) {
-			builder.responseInterceptor(getOrInstantiate(config.getResponseInterceptor()));
-		}
-
-		if (config.getDismiss404() != null) {
-			if (config.getDismiss404()) {
-				builder.dismiss404();
+		if (config.getDecode404() != null) {
+			if (config.getDecode404()) {
+				builder.decode404();
 			}
 		}
 
@@ -315,10 +295,6 @@ public class FeignClientFactoryBean
 		if (config.getCapabilities() != null) {
 			config.getCapabilities().stream().map(this::getOrInstantiate).forEach(builder::addCapability);
 		}
-
-		if (config.getQueryMapEncoder() != null) {
-			builder.queryMapEncoder(getOrInstantiate(config.getQueryMapEncoder()));
-		}
 	}
 
 	private void addDefaultQueryParams(FeignClientProperties.FeignClientConfiguration config, Feign.Builder builder) {
@@ -359,7 +335,7 @@ public class FeignClientFactoryBean
 		}
 	}
 
-	protected <T> T get(FeignClientFactory context, Class<T> type) {
+	protected <T> T get(FeignContext context, Class<T> type) {
 		T instance = context.getInstance(contextId, type);
 		if (instance == null) {
 			throw new IllegalStateException("No bean found of type " + type + " for " + contextId);
@@ -367,11 +343,11 @@ public class FeignClientFactoryBean
 		return instance;
 	}
 
-	protected <T> T getOptional(FeignClientFactory context, Class<T> type) {
+	protected <T> T getOptional(FeignContext context, Class<T> type) {
 		return context.getInstance(contextId, type);
 	}
 
-	protected <T> T getInheritedAwareOptional(FeignClientFactory context, Class<T> type) {
+	protected <T> T getInheritedAwareOptional(FeignContext context, Class<T> type) {
 		if (inheritParentContext) {
 			return getOptional(context, type);
 		}
@@ -380,7 +356,7 @@ public class FeignClientFactoryBean
 		}
 	}
 
-	protected <T> Map<String, T> getInheritedAwareInstances(FeignClientFactory context, Class<T> type) {
+	protected <T> Map<String, T> getInheritedAwareInstances(FeignContext context, Class<T> type) {
 		if (inheritParentContext) {
 			return context.getInstances(contextId, type);
 		}
@@ -389,11 +365,10 @@ public class FeignClientFactoryBean
 		}
 	}
 
-	protected <T> T loadBalance(Feign.Builder builder, FeignClientFactory context, HardCodedTarget<T> target) {
+	protected <T> T loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget<T> target) {
 		Client client = getOptional(context, Client.class);
 		if (client != null) {
 			builder.client(client);
-			applyBuildCustomizers(context, builder);
 			Targeter targeter = get(context, Targeter.class);
 			return targeter.target(this, builder, context, target);
 		}
@@ -408,7 +383,7 @@ public class FeignClientFactoryBean
 	 * @param contextId name of feign client
 	 * @return returns Options found in context
 	 */
-	protected Request.Options getOptionsByName(FeignClientFactory context, String contextId) {
+	protected Request.Options getOptionsByName(FeignContext context, String contextId) {
 		if (refreshableClient) {
 			return context.getInstance(contextId, Request.Options.class.getCanonicalName() + "-" + contextId,
 					Request.Options.class);
@@ -426,12 +401,12 @@ public class FeignClientFactoryBean
 	 * @return a {@link Feign} client created with the specified data and the context
 	 * information
 	 */
-	@SuppressWarnings("unchecked")
 	<T> T getTarget() {
-		FeignClientFactory feignClientFactory = beanFactory != null ? beanFactory.getBean(FeignClientFactory.class)
-				: applicationContext.getBean(FeignClientFactory.class);
-		Feign.Builder builder = feign(feignClientFactory);
-		if (!StringUtils.hasText(url) && !isUrlAvailableInConfig(contextId)) {
+		FeignContext context = beanFactory != null ? beanFactory.getBean(FeignContext.class)
+				: applicationContext.getBean(FeignContext.class);
+		Feign.Builder builder = feign(context);
+
+		if (!StringUtils.hasText(url)) {
 
 			if (LOG.isInfoEnabled()) {
 				LOG.info("For '" + name + "' URL not provided. Will try picking an instance via load-balancing.");
@@ -443,13 +418,13 @@ public class FeignClientFactoryBean
 				url = name;
 			}
 			url += cleanPath();
-			return (T) loadBalance(builder, feignClientFactory, new HardCodedTarget<>(type, name, url));
+			return (T) loadBalance(builder, context, new HardCodedTarget<>(type, name, url));
 		}
 		if (StringUtils.hasText(url) && !url.startsWith("http")) {
 			url = "http://" + url;
 		}
 		String url = this.url + cleanPath();
-		Client client = getOptional(feignClientFactory, Client.class);
+		Client client = getOptional(context, Client.class);
 		if (client != null) {
 			if (client instanceof FeignBlockingLoadBalancerClient) {
 				// not load balancing because we have a url,
@@ -463,11 +438,8 @@ public class FeignClientFactoryBean
 			}
 			builder.client(client);
 		}
-
-		applyBuildCustomizers(feignClientFactory, builder);
-
-		Targeter targeter = get(feignClientFactory, Targeter.class);
-		return targeter.target(this, builder, feignClientFactory, resolveTarget(feignClientFactory, contextId, url));
+		Targeter targeter = get(context, Targeter.class);
+		return (T) targeter.target(this, builder, context, new HardCodedTarget<>(type, name, url));
 	}
 
 	private String cleanPath() {
@@ -486,39 +458,6 @@ public class FeignClientFactoryBean
 		return path;
 	}
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	private <T> HardCodedTarget<T> resolveTarget(FeignClientFactory context, String contextId, String url) {
-		if (StringUtils.hasText(url)) {
-			return new HardCodedTarget(type, name, url);
-		}
-
-		if (refreshableClient) {
-			RefreshableUrl refreshableUrl = context.getInstance(contextId,
-					RefreshableUrl.class.getCanonicalName() + "-" + contextId, RefreshableUrl.class);
-			if (Objects.nonNull(refreshableUrl) && StringUtils.hasText(refreshableUrl.getUrl())) {
-				return new RefreshableHardCodedTarget<>(type, name, refreshableUrl);
-			}
-		}
-		FeignClientProperties.FeignClientConfiguration config = findConfigByKey(contextId);
-		if (Objects.isNull(config) || !StringUtils.hasText(config.getUrl())) {
-			throw new IllegalStateException(
-					"Provide Feign client URL either in @FeignClient() or in config properties.");
-		}
-
-		return new PropertyBasedTarget(type, name, config);
-	}
-
-	private boolean isUrlAvailableInConfig(String contextId) {
-		FeignClientProperties.FeignClientConfiguration config = findConfigByKey(contextId);
-		return Objects.nonNull(config) && StringUtils.hasText(config.getUrl());
-	}
-
-	private FeignClientProperties.FeignClientConfiguration findConfigByKey(String configKey) {
-		FeignClientProperties properties = beanFactory != null ? beanFactory.getBean(FeignClientProperties.class)
-				: applicationContext.getBean(FeignClientProperties.class);
-		return properties.getConfig().get(configKey);
-	}
-
 	@Override
 	public Class<?> getObjectType() {
 		return type;
@@ -569,12 +508,12 @@ public class FeignClientFactoryBean
 		this.path = path;
 	}
 
-	public boolean isDismiss404() {
-		return dismiss404;
+	public boolean isDecode404() {
+		return decode404;
 	}
 
-	public void setDismiss404(boolean dismiss404) {
-		this.dismiss404 = dismiss404;
+	public void setDecode404(boolean decode404) {
+		this.decode404 = decode404;
 	}
 
 	public boolean isInheritParentContext() {
@@ -619,14 +558,6 @@ public class FeignClientFactoryBean
 		this.refreshableClient = refreshableClient;
 	}
 
-	public String[] getQualifiers() {
-		return qualifiers;
-	}
-
-	public void setQualifiers(String[] qualifiers) {
-		this.qualifiers = qualifiers;
-	}
-
 	@Override
 	public boolean equals(Object o) {
 		if (this == o) {
@@ -637,7 +568,7 @@ public class FeignClientFactoryBean
 		}
 		FeignClientFactoryBean that = (FeignClientFactoryBean) o;
 		return Objects.equals(applicationContext, that.applicationContext)
-				&& Objects.equals(beanFactory, that.beanFactory) && dismiss404 == that.dismiss404
+				&& Objects.equals(beanFactory, that.beanFactory) && decode404 == that.decode404
 				&& inheritParentContext == that.inheritParentContext && Objects.equals(fallback, that.fallback)
 				&& Objects.equals(fallbackFactory, that.fallbackFactory) && Objects.equals(name, that.name)
 				&& Objects.equals(path, that.path) && Objects.equals(type, that.type) && Objects.equals(url, that.url)
@@ -649,16 +580,15 @@ public class FeignClientFactoryBean
 
 	@Override
 	public int hashCode() {
-		return Objects.hash(applicationContext, beanFactory, dismiss404, inheritParentContext, fallback,
-				fallbackFactory, name, path, type, url, readTimeoutMillis, connectTimeoutMillis, followRedirects,
-				refreshableClient);
+		return Objects.hash(applicationContext, beanFactory, decode404, inheritParentContext, fallback, fallbackFactory,
+				name, path, type, url, readTimeoutMillis, connectTimeoutMillis, followRedirects, refreshableClient);
 	}
 
 	@Override
 	public String toString() {
 		return new StringBuilder("FeignClientFactoryBean{").append("type=").append(type).append(", ").append("name='")
 				.append(name).append("', ").append("url='").append(url).append("', ").append("path='").append(path)
-				.append("', ").append("dismiss404=").append(dismiss404).append(", ").append("inheritParentContext=")
+				.append("', ").append("decode404=").append(decode404).append(", ").append("inheritParentContext=")
 				.append(inheritParentContext).append(", ").append("applicationContext=").append(applicationContext)
 				.append(", ").append("beanFactory=").append(beanFactory).append(", ").append("fallback=")
 				.append(fallback).append(", ").append("fallbackFactory=").append(fallbackFactory).append("}")

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientMetricsEnabledCondition.java

@@ -25,7 +25,7 @@ import org.springframework.core.type.AnnotatedTypeMetadata;
 /**
  * @author Jonatan Ivanov
  */
-class FeignClientMicrometerEnabledCondition implements Condition {
+class FeignClientMetricsEnabledCondition implements Condition {
 
 	@Override
 	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
@@ -36,11 +36,11 @@ class FeignClientMicrometerEnabledCondition implements Condition {
 					.getConfig();
 			if (feignClientConfigMap != null) {
 				FeignClientProperties.FeignClientConfiguration feignClientConfig = feignClientConfigMap
-						.get(context.getEnvironment().getProperty("spring.cloud.openfeign.client.name"));
+						.get(context.getEnvironment().getProperty("feign.client.name"));
 				if (feignClientConfig != null) {
-					FeignClientProperties.MicrometerProperties micrometer = feignClientConfig.getMicrometer();
-					if (micrometer != null && micrometer.getEnabled() != null) {
-						return micrometer.getEnabled();
+					FeignClientProperties.MetricsProperties metrics = feignClientConfig.getMetrics();
+					if (metrics != null && metrics.getEnabled() != null) {
+						return metrics.getEnabled();
 					}
 				}
 			}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientProperties.java

@@ -26,9 +26,7 @@ import feign.Capability;
 import feign.Contract;
 import feign.ExceptionPropagationPolicy;
 import feign.Logger;
-import feign.QueryMapEncoder;
 import feign.RequestInterceptor;
-import feign.ResponseInterceptor;
 import feign.Retryer;
 import feign.codec.Decoder;
 import feign.codec.Encoder;
@@ -42,11 +40,8 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
  * @author Ram Anaswara
  * @author Jonatan Ivanov
  * @author Olga Maciaszek-Sharma
- * @author Hyeonmin Park
- * @author Jasbir Singh
- * @author Dominique Villard
  */
-@ConfigurationProperties("spring.cloud.openfeign.client")
+@ConfigurationProperties("feign.client")
 public class FeignClientProperties {
 
 	private boolean defaultToProperties = true;
@@ -128,13 +123,11 @@ public class FeignClientProperties {
 
 		private List<Class<RequestInterceptor>> requestInterceptors;
 
-		private Class<ResponseInterceptor> responseInterceptor;
-
 		private Map<String, Collection<String>> defaultRequestHeaders;
 
 		private Map<String, Collection<String>> defaultQueryParameters;
 
-		private Boolean dismiss404;
+		private Boolean decode404;
 
 		private Class<Decoder> decoder;
 
@@ -146,18 +139,10 @@ public class FeignClientProperties {
 
 		private List<Class<Capability>> capabilities;
 
-		private Class<QueryMapEncoder> queryMapEncoder;
-
-		private MicrometerProperties micrometer;
+		private MetricsProperties metrics;
 
 		private Boolean followRedirects;
 
-		/**
-		 * Allows setting Feign client host URL. This value will only be taken into
-		 * account if the url is not set in the @FeignClient annotation.
-		 */
-		private String url;
-
 		public Logger.Level getLoggerLevel() {
 			return loggerLevel;
 		}
@@ -206,14 +191,6 @@ public class FeignClientProperties {
 			this.requestInterceptors = requestInterceptors;
 		}
 
-		public Class<ResponseInterceptor> getResponseInterceptor() {
-			return responseInterceptor;
-		}
-
-		public void setResponseInterceptor(Class<ResponseInterceptor> responseInterceptor) {
-			this.responseInterceptor = responseInterceptor;
-		}
-
 		public Map<String, Collection<String>> getDefaultRequestHeaders() {
 			return defaultRequestHeaders;
 		}
@@ -230,12 +207,12 @@ public class FeignClientProperties {
 			this.defaultQueryParameters = defaultQueryParameters;
 		}
 
-		public Boolean getDismiss404() {
-			return dismiss404;
+		public Boolean getDecode404() {
+			return decode404;
 		}
 
-		public void setDismiss404(Boolean dismiss404) {
-			this.dismiss404 = dismiss404;
+		public void setDecode404(Boolean decode404) {
+			this.decode404 = decode404;
 		}
 
 		public Class<Decoder> getDecoder() {
@@ -278,20 +255,12 @@ public class FeignClientProperties {
 			this.capabilities = capabilities;
 		}
 
-		public Class<QueryMapEncoder> getQueryMapEncoder() {
-			return queryMapEncoder;
+		public MetricsProperties getMetrics() {
+			return metrics;
 		}
 
-		public void setQueryMapEncoder(Class<QueryMapEncoder> queryMapEncoder) {
-			this.queryMapEncoder = queryMapEncoder;
-		}
-
-		public MicrometerProperties getMicrometer() {
-			return micrometer;
-		}
-
-		public void setMicrometer(MicrometerProperties micrometer) {
-			this.micrometer = micrometer;
+		public void setMetrics(MetricsProperties metrics) {
+			this.metrics = metrics;
 		}
 
 		public Boolean isFollowRedirects() {
@@ -302,14 +271,6 @@ public class FeignClientProperties {
 			this.followRedirects = followRedirects;
 		}
 
-		public String getUrl() {
-			return url;
-		}
-
-		public void setUrl(String url) {
-			this.url = url;
-		}
-
 		@Override
 		public boolean equals(Object o) {
 			if (this == o) {
@@ -323,32 +284,28 @@ public class FeignClientProperties {
 					&& Objects.equals(readTimeout, that.readTimeout) && Objects.equals(retryer, that.retryer)
 					&& Objects.equals(errorDecoder, that.errorDecoder)
 					&& Objects.equals(requestInterceptors, that.requestInterceptors)
-					&& Objects.equals(responseInterceptor, that.responseInterceptor)
-					&& Objects.equals(dismiss404, that.dismiss404) && Objects.equals(encoder, that.encoder)
+					&& Objects.equals(decode404, that.decode404) && Objects.equals(encoder, that.encoder)
 					&& Objects.equals(decoder, that.decoder) && Objects.equals(contract, that.contract)
 					&& Objects.equals(exceptionPropagationPolicy, that.exceptionPropagationPolicy)
 					&& Objects.equals(defaultRequestHeaders, that.defaultRequestHeaders)
 					&& Objects.equals(defaultQueryParameters, that.defaultQueryParameters)
-					&& Objects.equals(capabilities, that.capabilities)
-					&& Objects.equals(queryMapEncoder, that.queryMapEncoder)
-					&& Objects.equals(micrometer, that.micrometer)
-					&& Objects.equals(followRedirects, that.followRedirects) && Objects.equals(url, that.url);
+					&& Objects.equals(capabilities, that.capabilities) && Objects.equals(metrics, that.metrics)
+					&& Objects.equals(followRedirects, that.followRedirects);
 		}
 
 		@Override
 		public int hashCode() {
 			return Objects.hash(loggerLevel, connectTimeout, readTimeout, retryer, errorDecoder, requestInterceptors,
-					responseInterceptor, dismiss404, encoder, decoder, contract, exceptionPropagationPolicy,
-					defaultQueryParameters, defaultRequestHeaders, capabilities, queryMapEncoder, micrometer,
-					followRedirects, url);
+					decode404, encoder, decoder, contract, exceptionPropagationPolicy, defaultQueryParameters,
+					defaultRequestHeaders, capabilities, metrics, followRedirects);
 		}
 
 	}
 
 	/**
-	 * Micrometer configuration for Feign Client.
+	 * Metrics configuration for Feign Client.
 	 */
-	public static class MicrometerProperties {
+	public static class MetricsProperties {
 
 		private Boolean enabled = true;
 
@@ -369,7 +326,7 @@ public class FeignClientProperties {
 				return false;
 			}
 
-			MicrometerProperties that = (MicrometerProperties) o;
+			MetricsProperties that = (MetricsProperties) o;
 			return Objects.equals(enabled, that.enabled);
 		}
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientSpecification.java

@@ -24,22 +24,18 @@ import org.springframework.cloud.context.named.NamedContextFactory;
 /**
  * @author Dave Syer
  * @author Gregor Zurowski
- * @author Olga Maciaszek-Sharma
  */
-public class FeignClientSpecification implements NamedContextFactory.Specification {
+class FeignClientSpecification implements NamedContextFactory.Specification {
 
 	private String name;
 
-	private String className;
-
 	private Class<?>[] configuration;
 
-	public FeignClientSpecification() {
+	FeignClientSpecification() {
 	}
 
-	public FeignClientSpecification(String name, String className, Class<?>[] configuration) {
+	FeignClientSpecification(String name, Class<?>[] configuration) {
 		this.name = name;
-		this.className = className;
 		this.configuration = configuration;
 	}
 
@@ -51,14 +47,6 @@ public class FeignClientSpecification implements NamedContextFactory.Specificati
 		this.name = name;
 	}
 
-	public String getClassName() {
-		return className;
-	}
-
-	public void setClassName(String className) {
-		this.className = className;
-	}
-
 	public Class<?>[] getConfiguration() {
 		return this.configuration;
 	}
@@ -72,24 +60,22 @@ public class FeignClientSpecification implements NamedContextFactory.Specificati
 		if (this == o) {
 			return true;
 		}
-		if (!(o instanceof FeignClientSpecification that)) {
+		if (o == null || getClass() != o.getClass()) {
 			return false;
 		}
-		return Objects.equals(name, that.name) && Objects.equals(className, that.className)
-				&& Arrays.equals(configuration, that.configuration);
+		FeignClientSpecification that = (FeignClientSpecification) o;
+		return Objects.equals(this.name, that.name) && Arrays.equals(this.configuration, that.configuration);
 	}
 
 	@Override
 	public int hashCode() {
-		int result = Objects.hash(name, className);
-		result = 31 * result + Arrays.hashCode(configuration);
-		return result;
+		return Objects.hash(this.name, this.configuration);
 	}
 
 	@Override
 	public String toString() {
-		return "FeignClientSpecification{" + "name='" + name + "', " + "className='" + className + "', "
-				+ "configuration=" + Arrays.toString(configuration) + "}";
+		return new StringBuilder("FeignClientSpecification{").append("name='").append(this.name).append("', ")
+				.append("configuration=").append(Arrays.toString(this.configuration)).append("}").toString();
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientsConfiguration.java

@@ -29,10 +29,8 @@ import feign.codec.Encoder;
 import feign.form.MultipartFormContentProcessor;
 import feign.form.spring.SpringFormEncoder;
 import feign.micrometer.MicrometerCapability;
-import feign.micrometer.MicrometerObservationCapability;
 import feign.optionals.OptionalDecoder;
 import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.observation.ObservationRegistry;
 
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.beans.factory.ObjectProvider;
@@ -49,7 +47,6 @@ import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
 import org.springframework.cloud.openfeign.clientconfig.FeignClientConfigurer;
 import org.springframework.cloud.openfeign.support.AbstractFormWriter;
 import org.springframework.cloud.openfeign.support.FeignEncoderProperties;
-import org.springframework.cloud.openfeign.support.HttpMessageConverterCustomizer;
 import org.springframework.cloud.openfeign.support.PageableSpringEncoder;
 import org.springframework.cloud.openfeign.support.PageableSpringQueryMapEncoder;
 import org.springframework.cloud.openfeign.support.ResponseEntityDecoder;
@@ -73,7 +70,6 @@ import static feign.form.ContentType.MULTIPART;
  * @author Jonatan Ivanov
  * @author Olga Maciaszek-Sharma
  * @author Hyeonmin Park
- * @author Yanming Zhou
  */
 @Configuration(proxyBeanMethods = false)
 public class FeignClientsConfiguration {
@@ -101,25 +97,22 @@ public class FeignClientsConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
-	public Decoder feignDecoder(ObjectProvider<HttpMessageConverterCustomizer> customizers) {
-		return new OptionalDecoder(new ResponseEntityDecoder(new SpringDecoder(messageConverters, customizers)));
+	public Decoder feignDecoder() {
+		return new OptionalDecoder(new ResponseEntityDecoder(new SpringDecoder(this.messageConverters)));
 	}
 
 	@Bean
 	@ConditionalOnMissingBean
 	@ConditionalOnMissingClass("org.springframework.data.domain.Pageable")
-	public Encoder feignEncoder(ObjectProvider<AbstractFormWriter> formWriterProvider,
-			ObjectProvider<HttpMessageConverterCustomizer> customizers) {
-		return springEncoder(formWriterProvider, encoderProperties, customizers);
+	public Encoder feignEncoder(ObjectProvider<AbstractFormWriter> formWriterProvider) {
+		return springEncoder(formWriterProvider, encoderProperties);
 	}
 
 	@Bean
 	@ConditionalOnClass(name = "org.springframework.data.domain.Pageable")
 	@ConditionalOnMissingBean
-	public Encoder feignEncoderPageable(ObjectProvider<AbstractFormWriter> formWriterProvider,
-			ObjectProvider<HttpMessageConverterCustomizer> customizers) {
-		PageableSpringEncoder encoder = new PageableSpringEncoder(
-				springEncoder(formWriterProvider, encoderProperties, customizers));
+	public Encoder feignEncoderPageable(ObjectProvider<AbstractFormWriter> formWriterProvider) {
+		PageableSpringEncoder encoder = new PageableSpringEncoder(springEncoder(formWriterProvider, encoderProperties));
 
 		if (springDataWebProperties != null) {
 			encoder.setPageParameter(springDataWebProperties.getPageable().getPageParameter());
@@ -133,26 +126,20 @@ public class FeignClientsConfiguration {
 	@ConditionalOnClass(name = "org.springframework.data.domain.Pageable")
 	@ConditionalOnMissingBean
 	public QueryMapEncoder feignQueryMapEncoderPageable() {
-		PageableSpringQueryMapEncoder queryMapEncoder = new PageableSpringQueryMapEncoder();
-		if (springDataWebProperties != null) {
-			queryMapEncoder.setPageParameter(springDataWebProperties.getPageable().getPageParameter());
-			queryMapEncoder.setSizeParameter(springDataWebProperties.getPageable().getSizeParameter());
-			queryMapEncoder.setSortParameter(springDataWebProperties.getSort().getSortParameter());
-		}
-		return queryMapEncoder;
+		return new PageableSpringQueryMapEncoder();
 	}
 
 	@Bean
 	@ConditionalOnMissingBean
 	public Contract feignContract(ConversionService feignConversionService) {
 		boolean decodeSlash = feignClientProperties == null || feignClientProperties.isDecodeSlash();
-		return new SpringMvcContract(parameterProcessors, feignConversionService, decodeSlash);
+		return new SpringMvcContract(this.parameterProcessors, feignConversionService, decodeSlash);
 	}
 
 	@Bean
 	public FormattingConversionService feignConversionService() {
 		FormattingConversionService conversionService = new DefaultFormattingConversionService();
-		for (FeignFormatterRegistrar feignFormatterRegistrar : feignFormatterRegistrars) {
+		for (FeignFormatterRegistrar feignFormatterRegistrar : this.feignFormatterRegistrars) {
 			feignFormatterRegistrar.registerFormatters(conversionService);
 		}
 		return conversionService;
@@ -167,7 +154,7 @@ public class FeignClientsConfiguration {
 	@Bean
 	@ConditionalOnMissingBean(FeignLoggerFactory.class)
 	public FeignLoggerFactory feignLoggerFactory() {
-		return new DefaultFeignLoggerFactory(logger);
+		return new DefaultFeignLoggerFactory(this.logger);
 	}
 
 	@Bean
@@ -178,15 +165,14 @@ public class FeignClientsConfiguration {
 	}
 
 	private Encoder springEncoder(ObjectProvider<AbstractFormWriter> formWriterProvider,
-			FeignEncoderProperties encoderProperties, ObjectProvider<HttpMessageConverterCustomizer> customizers) {
+			FeignEncoderProperties encoderProperties) {
 		AbstractFormWriter formWriter = formWriterProvider.getIfAvailable();
 
 		if (formWriter != null) {
-			return new SpringEncoder(new SpringPojoFormEncoder(formWriter), messageConverters, encoderProperties,
-					customizers);
+			return new SpringEncoder(new SpringPojoFormEncoder(formWriter), this.messageConverters, encoderProperties);
 		}
 		else {
-			return new SpringEncoder(new SpringFormEncoder(), messageConverters, encoderProperties, customizers);
+			return new SpringEncoder(new SpringFormEncoder(), this.messageConverters, encoderProperties);
 		}
 	}
 
@@ -216,7 +202,7 @@ public class FeignClientsConfiguration {
 
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(CircuitBreaker.class)
-	@ConditionalOnProperty("spring.cloud.openfeign.circuitbreaker.enabled")
+	@ConditionalOnProperty("feign.circuitbreaker.enabled")
 	protected static class CircuitBreakerPresentFeignBuilderConfiguration {
 
 		@Bean
@@ -237,23 +223,16 @@ public class FeignClientsConfiguration {
 	}
 
 	@Configuration(proxyBeanMethods = false)
-	@ConditionalOnProperty(name = "spring.cloud.openfeign.micrometer.enabled", matchIfMissing = true)
-	@ConditionalOnClass({ MicrometerObservationCapability.class, MicrometerCapability.class, MeterRegistry.class })
-	@Conditional(FeignClientMicrometerEnabledCondition.class)
-	protected static class MicrometerConfiguration {
+	@ConditionalOnBean(type = "io.micrometer.core.instrument.MeterRegistry")
+	@ConditionalOnClass(name = "feign.micrometer.MicrometerCapability")
+	@ConditionalOnProperty(name = "feign.metrics.enabled", matchIfMissing = true)
+	@Conditional(FeignClientMetricsEnabledCondition.class)
+	protected static class MetricsConfiguration {
 
 		@Bean
 		@ConditionalOnMissingBean
-		@ConditionalOnBean(type = "io.micrometer.observation.ObservationRegistry")
-		public MicrometerObservationCapability micrometerObservationCapability(ObservationRegistry registry) {
-			return new MicrometerObservationCapability(registry);
-		}
-
-		@Bean
-		@ConditionalOnBean(type = "io.micrometer.core.instrument.MeterRegistry")
-		@ConditionalOnMissingBean({ MicrometerCapability.class, MicrometerObservationCapability.class })
-		public MicrometerCapability micrometerCapability(MeterRegistry registry) {
-			return new MicrometerCapability(registry);
+		public MicrometerCapability micrometerCapability(MeterRegistry meterRegistry) {
+			return new MicrometerCapability(meterRegistry);
 		}
 
 	}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignClientsRegistrar.java

@@ -32,6 +32,7 @@ import java.util.Set;
 import feign.Request;
 
 import org.springframework.aop.scope.ScopedProxyUtils;
+import org.springframework.beans.factory.FactoryBean;
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
 import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -70,7 +71,7 @@ import org.springframework.util.StringUtils;
 class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
 
 	// patterned after Spring Integration IntegrationComponentScanRegistrar
-	// and RibbonClientsConfigurationRegistrar
+	// and RibbonClientsConfigurationRegistgrar
 
 	private ResourceLoader resourceLoader;
 
@@ -105,7 +106,7 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 			host = new URI(url).getHost();
 
 		}
-		catch (URISyntaxException ignored) {
+		catch (URISyntaxException e) {
 		}
 		Assert.state(host != null, "Service id not legal hostname (" + name + ")");
 		return name;
@@ -161,11 +162,12 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 			else {
 				name = "default." + metadata.getClassName();
 			}
-			registerClientConfiguration(registry, name, "default", defaultAttrs.get("defaultConfiguration"));
+			registerClientConfiguration(registry, name, defaultAttrs.get("defaultConfiguration"));
 		}
 	}
 
 	public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
+
 		LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
 		Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
 		final Class<?>[] clients = attrs == null ? null : (Class<?>[]) attrs.get("clients");
@@ -185,8 +187,9 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 		}
 
 		for (BeanDefinition candidateComponent : candidateComponents) {
-			if (candidateComponent instanceof AnnotatedBeanDefinition beanDefinition) {
+			if (candidateComponent instanceof AnnotatedBeanDefinition) {
 				// verify annotated class is an interface
+				AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
 				AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
 				Assert.isTrue(annotationMetadata.isInterface(), "@FeignClient can only be specified on an interface");
 
@@ -194,8 +197,7 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 						.getAnnotationAttributes(FeignClient.class.getCanonicalName());
 
 				String name = getClientName(attributes);
-				String className = annotationMetadata.getClassName();
-				registerClientConfiguration(registry, name, className, attributes.get("configuration"));
+				registerClientConfiguration(registry, name, attributes.get("configuration"));
 
 				registerFeignClient(registry, annotationMetadata, attributes);
 			}
@@ -205,62 +207,9 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 	private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata,
 			Map<String, Object> attributes) {
 		String className = annotationMetadata.getClassName();
-		if (String.valueOf(false).equals(
-				environment.getProperty("spring.cloud.openfeign.lazy-attributes-resolution", String.valueOf(false)))) {
-			eagerlyRegisterFeignClientBeanDefinition(className, attributes, registry);
-		}
-		else {
-			lazilyRegisterFeignClientBeanDefinition(className, attributes, registry);
-		}
-	}
-
-	private void eagerlyRegisterFeignClientBeanDefinition(String className, Map<String, Object> attributes,
-			BeanDefinitionRegistry registry) {
-		validate(attributes);
-		BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
-		definition.addPropertyValue("url", getUrl(null, attributes));
-		definition.addPropertyValue("path", getPath(null, attributes));
-		String name = getName(attributes);
-		definition.addPropertyValue("name", name);
-		String contextId = getContextId(null, attributes);
-		definition.addPropertyValue("contextId", contextId);
-		definition.addPropertyValue("type", className);
-		definition.addPropertyValue("dismiss404", Boolean.parseBoolean(String.valueOf(attributes.get("dismiss404"))));
-		Object fallback = attributes.get("fallback");
-		if (fallback != null) {
-			definition.addPropertyValue("fallback",
-					(fallback instanceof Class ? fallback : ClassUtils.resolveClassName(fallback.toString(), null)));
-		}
-		Object fallbackFactory = attributes.get("fallbackFactory");
-		if (fallbackFactory != null) {
-			definition.addPropertyValue("fallbackFactory", fallbackFactory instanceof Class ? fallbackFactory
-					: ClassUtils.resolveClassName(fallbackFactory.toString(), null));
-		}
-		definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
-		definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
-		definition.addPropertyValue("refreshableClient", isClientRefreshEnabled());
-		String[] qualifiers = getQualifiers(attributes);
-		if (ObjectUtils.isEmpty(qualifiers)) {
-			qualifiers = new String[] { contextId + "FeignClient" };
-		}
-		// This is done so that there's a way to retrieve qualifiers while generating AOT
-		// code
-		definition.addPropertyValue("qualifiers", qualifiers);
-		AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
-		// has a default, won't be null
-		boolean primary = (Boolean) attributes.get("primary");
-		beanDefinition.setPrimary(primary);
-		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);
-		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
-		registerRefreshableBeanDefinition(registry, contextId, Request.Options.class, OptionsFactoryBean.class);
-		registerRefreshableBeanDefinition(registry, contextId, RefreshableUrl.class, RefreshableUrlFactoryBean.class);
-	}
-
-	private void lazilyRegisterFeignClientBeanDefinition(String className, Map<String, Object> attributes,
-			BeanDefinitionRegistry registry) {
+		Class clazz = ClassUtils.resolveClassName(className, null);
 		ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory
 				? (ConfigurableBeanFactory) registry : null;
-		Class clazz = ClassUtils.resolveClassName(className, null);
 		String contextId = getContextId(beanFactory, attributes);
 		String name = getName(attributes);
 		FeignClientFactoryBean factoryBean = new FeignClientFactoryBean();
@@ -272,7 +221,7 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 		BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, () -> {
 			factoryBean.setUrl(getUrl(beanFactory, attributes));
 			factoryBean.setPath(getPath(beanFactory, attributes));
-			factoryBean.setDismiss404(Boolean.parseBoolean(String.valueOf(attributes.get("dismiss404"))));
+			factoryBean.setDecode404(Boolean.parseBoolean(String.valueOf(attributes.get("decode404"))));
 			Object fallback = attributes.get("fallback");
 			if (fallback != null) {
 				factoryBean.setFallback(fallback instanceof Class ? (Class<?>) fallback
@@ -290,6 +239,7 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 		validate(attributes);
 
 		AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
+		beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);
 		beanDefinition.setAttribute("feignClientsRegistrarFactoryBean", factoryBean);
 
 		// has a default, won't be null
@@ -305,8 +255,7 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);
 		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
 
-		registerRefreshableBeanDefinition(registry, contextId, Request.Options.class, OptionsFactoryBean.class);
-		registerRefreshableBeanDefinition(registry, contextId, RefreshableUrl.class, RefreshableUrlFactoryBean.class);
+		registerOptionsBeanDefinition(registry, contextId);
 	}
 
 	private void validate(Map<String, Object> attributes) {
@@ -457,11 +406,9 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 				"Either 'name' or 'value' must be provided in @" + FeignClient.class.getSimpleName());
 	}
 
-	private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object className,
-			Object configuration) {
+	private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
 		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class);
 		builder.addConstructorArgValue(name);
-		builder.addConstructorArgValue(className);
 		builder.addConstructorArgValue(configuration);
 		registry.registerBeanDefinition(name + "." + FeignClientSpecification.class.getSimpleName(),
 				builder.getBeanDefinition());
@@ -473,17 +420,16 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 	}
 
 	/**
-	 * This method registers beans definition with refreshScope.
+	 * This method is meant to create {@link Request.Options} beans definition with
+	 * refreshScope.
 	 * @param registry spring bean definition registry
 	 * @param contextId name of feign client
-	 * @param beanType type of bean
-	 * @param factoryBeanType points to a relevant bean factory
 	 */
-	private void registerRefreshableBeanDefinition(BeanDefinitionRegistry registry, String contextId, Class<?> beanType,
-			Class<?> factoryBeanType) {
+	private void registerOptionsBeanDefinition(BeanDefinitionRegistry registry, String contextId) {
 		if (isClientRefreshEnabled()) {
-			String beanName = beanType.getCanonicalName() + "-" + contextId;
-			BeanDefinitionBuilder definitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(factoryBeanType);
+			String beanName = Request.Options.class.getCanonicalName() + "-" + contextId;
+			BeanDefinitionBuilder definitionBuilder = BeanDefinitionBuilder
+					.genericBeanDefinition(OptionsFactoryBean.class);
 			definitionBuilder.setScope("refresh");
 			definitionBuilder.addPropertyValue("contextId", contextId);
 			BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(definitionBuilder.getBeanDefinition(),
@@ -494,7 +440,7 @@ class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLo
 	}
 
 	private boolean isClientRefreshEnabled() {
-		return environment.getProperty("spring.cloud.openfeign.client.refresh-enabled", Boolean.class, false);
+		return environment.getProperty("feign.client.refresh-enabled", Boolean.class, false);
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/FeignContext.java

@@ -16,14 +16,11 @@
 
 package org.springframework.cloud.openfeign;
 
-import java.util.HashMap;
 import java.util.Map;
 
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.cloud.context.named.NamedContextFactory;
-import org.springframework.context.ApplicationContextInitializer;
-import org.springframework.context.support.GenericApplicationContext;
 import org.springframework.lang.Nullable;
 
 /**
@@ -34,18 +31,11 @@ import org.springframework.lang.Nullable;
  * @author Dave Syer
  * @author Matt King
  * @author Jasbir Singh
- * @author Olga Maciaszek-Sharma
  */
-public class FeignClientFactory extends NamedContextFactory<FeignClientSpecification> {
+public class FeignContext extends NamedContextFactory<FeignClientSpecification> {
 
-	public FeignClientFactory() {
-		this(new HashMap<>());
-	}
-
-	public FeignClientFactory(
-			Map<String, ApplicationContextInitializer<GenericApplicationContext>> applicationContextInitializers) {
-		super(FeignClientsConfiguration.class, "spring.cloud.openfeign", "spring.cloud.openfeign.client.name",
-				applicationContextInitializers);
+	public FeignContext() {
+		super(FeignClientsConfiguration.class, "feign", "feign.client.name");
 	}
 
 	@Nullable
@@ -67,14 +57,4 @@ public class FeignClientFactory extends NamedContextFactory<FeignClientSpecifica
 		return getContext(contextName).getBean(beanName, type);
 	}
 
-	@SuppressWarnings("unchecked")
-	public FeignClientFactory withApplicationContextInitializers(Map<String, Object> applicationContextInitializers) {
-		Map<String, ApplicationContextInitializer<GenericApplicationContext>> convertedInitializers = new HashMap<>();
-		applicationContextInitializers.keySet()
-				.forEach(contextId -> convertedInitializers.put(contextId,
-						(ApplicationContextInitializer<GenericApplicationContext>) applicationContextInitializers
-								.get(contextId)));
-		return new FeignClientFactory(convertedInitializers);
-	}
-
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/HttpClient5DisabledConditions.java

@@ -16,27 +16,27 @@
 
 package org.springframework.cloud.openfeign;
 
-import feign.Capability;
-import feign.InvocationHandlerFactory;
-
-import org.springframework.cache.interceptor.CacheInterceptor;
+import org.springframework.boot.autoconfigure.condition.AnyNestedCondition;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 
 /**
- * Allows Spring's @Cache* annotations to be declared on the feign client's methods.
- *
- * @author Sam Kruglov
+ * @author Nguyen Ky Thanh
  */
-public class CachingCapability implements Capability {
+public class HttpClient5DisabledConditions extends AnyNestedCondition {
 
-	private final CacheInterceptor cacheInterceptor;
+	public HttpClient5DisabledConditions() {
+		super(ConfigurationPhase.PARSE_CONFIGURATION);
+	}
+
+	@ConditionalOnMissingClass("feign.hc5.ApacheHttp5Client")
+	static class ApacheHttp5ClientClassMissing {
 
-	public CachingCapability(CacheInterceptor cacheInterceptor) {
-		this.cacheInterceptor = cacheInterceptor;
 	}
 
-	@Override
-	public InvocationHandlerFactory enrich(InvocationHandlerFactory invocationHandlerFactory) {
-		return new FeignCachingInvocationHandlerFactory(invocationHandlerFactory, cacheInterceptor);
+	@ConditionalOnProperty(value = "feign.httpclient.hc5.enabled", havingValue = "false", matchIfMissing = true)
+	static class HttpClient5Disabled {
+
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/OptionsFactoryBean.java

@@ -51,7 +51,7 @@ public class OptionsFactoryBean implements FactoryBean<Request.Options>, Applica
 	}
 
 	@Override
-	public Request.Options getObject() {
+	public Request.Options getObject() throws Exception {
 		if (options != null) {
 			return options;
 		}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/PropertyBasedTarget.java

@@ -1,49 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign;
-
-import feign.Target;
-
-/**
- * A {@link HardCodedTarget} implementation that resolves url from properties when the
- * initial call is made. Using it allows specifying the url at runtime in an AOT-packaged
- * application or a native image by setting the value of the
- * `spring.cloud.openfeign.client.config.[clientId].url`.
- *
- * @author Olga Maciaszek-Sharma
- * @see FeignClientProperties.FeignClientConfiguration#getUrl()
- */
-public class PropertyBasedTarget<T> extends Target.HardCodedTarget<T> {
-
-	private String url;
-
-	private final FeignClientProperties.FeignClientConfiguration config;
-
-	public PropertyBasedTarget(Class<T> type, String name, FeignClientProperties.FeignClientConfiguration config) {
-		super(type, name, config.getUrl());
-		this.config = config;
-	}
-
-	@Override
-	public String url() {
-		if (url == null) {
-			url = config.getUrl();
-		}
-		return url;
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/RefreshableHardCodedTarget.java

@@ -1,42 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign;
-
-import feign.Target;
-
-/**
- * This target provides url wrapped under {@link Target}.
- *
- * @author Jasbir Singh
- * @since 4.0.0
- */
-public class RefreshableHardCodedTarget<T> extends Target.HardCodedTarget<T> {
-
-	private final RefreshableUrl refreshableUrl;
-
-	@SuppressWarnings("unchecked")
-	public RefreshableHardCodedTarget(Class type, String name, RefreshableUrl refreshableUrl) {
-		super(type, name, refreshableUrl.getUrl());
-		this.refreshableUrl = refreshableUrl;
-	}
-
-	@Override
-	public String url() {
-		return refreshableUrl.getUrl();
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/RefreshableUrl.java

@@ -1,38 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign;
-
-/**
- * This class wraps url inside an object so that relevant proxy instance can be created
- * using {@link RefreshableUrlFactoryBean}.
- *
- * @author Jasbir Singh
- * @since 4.0.0
- */
-public class RefreshableUrl {
-
-	private final String url;
-
-	public RefreshableUrl(String url) {
-		this.url = url;
-	}
-
-	public String getUrl() {
-		return url;
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/RefreshableUrlFactoryBean.java

@@ -1,75 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign;
-
-import java.util.Objects;
-
-import org.springframework.beans.BeansException;
-import org.springframework.beans.factory.FactoryBean;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.ApplicationContextAware;
-import org.springframework.util.StringUtils;
-
-/**
- * This factory bean creates {@link RefreshableUrl} instance as per the applicable
- * configurations.
- *
- * @author Jasbir Singh
- * @since 4.0.0
- */
-public class RefreshableUrlFactoryBean implements FactoryBean<RefreshableUrl>, ApplicationContextAware {
-
-	private ApplicationContext applicationContext;
-
-	private String contextId;
-
-	private RefreshableUrl refreshableUrl;
-
-	@Override
-	public Class<?> getObjectType() {
-		return RefreshableUrl.class;
-	}
-
-	@Override
-	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
-		this.applicationContext = applicationContext;
-	}
-
-	@Override
-	public RefreshableUrl getObject() {
-		if (refreshableUrl != null) {
-			return refreshableUrl;
-		}
-
-		FeignClientProperties properties = applicationContext.getBean(FeignClientProperties.class);
-		if (Objects.isNull(properties.getConfig())) {
-			return new RefreshableUrl(null);
-		}
-		FeignClientProperties.FeignClientConfiguration configuration = properties.getConfig().get(contextId);
-		if (Objects.isNull(configuration) || !StringUtils.hasText(configuration.getUrl())) {
-			return new RefreshableUrl(null);
-		}
-
-		refreshableUrl = new RefreshableUrl(FeignClientsRegistrar.getUrl(configuration.getUrl()));
-		return refreshableUrl;
-	}
-
-	public void setContextId(String contextId) {
-		this.contextId = contextId;
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/SpringQueryMap.java

@@ -21,6 +21,10 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import feign.QueryMap;
+
+import org.springframework.core.annotation.AliasFor;
+
 /**
  * Spring MVC equivalent of OpenFeign's {@link feign.QueryMap} parameter annotation.
  *
@@ -32,4 +36,18 @@ import java.lang.annotation.Target;
 @Target({ ElementType.PARAMETER })
 public @interface SpringQueryMap {
 
+	/**
+	 * @see QueryMap#encoded()
+	 * @return alias for {@link #encoded()}.
+	 */
+	@AliasFor("encoded")
+	boolean value() default false;
+
+	/**
+	 * @see QueryMap#encoded()
+	 * @return Specifies whether parameter names and values are already encoded.
+	 */
+	@AliasFor("value")
+	boolean encoded() default false;
+
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/Targeter.java

@@ -24,7 +24,7 @@ import feign.Target;
  */
 public interface Targeter {
 
-	<T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignClientFactory context,
+	<T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
 			Target.HardCodedTarget<T> target);
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/annotation/CookieValueParameterProcessor.java

@@ -1,69 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.annotation;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
-import java.util.Collections;
-
-import feign.MethodMetadata;
-
-import org.springframework.cloud.openfeign.AnnotatedParameterProcessor;
-import org.springframework.http.HttpHeaders;
-import org.springframework.web.bind.annotation.CookieValue;
-
-import static feign.Util.checkState;
-import static feign.Util.emptyToNull;
-
-/**
- * {@link CookieValue} annotation processor.
- *
- * @author Gong Yi
- * @author Olga Maciaszek-Sharma
- *
- */
-public class CookieValueParameterProcessor implements AnnotatedParameterProcessor {
-
-	private static final Class<CookieValue> ANNOTATION = CookieValue.class;
-
-	@Override
-	public Class<? extends Annotation> getAnnotationType() {
-		return ANNOTATION;
-	}
-
-	@Override
-	public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) {
-		int parameterIndex = context.getParameterIndex();
-		MethodMetadata data = context.getMethodMetadata();
-		CookieValue cookie = ANNOTATION.cast(annotation);
-		String name = cookie.value().trim();
-		checkState(emptyToNull(name) != null, "Cookie.name() was empty on parameter %s", parameterIndex);
-		context.setParameterName(name);
-		String cookieExpression = data.template().headers()
-				.getOrDefault(HttpHeaders.COOKIE, Collections.singletonList("")).stream().findFirst().orElse("");
-		if (cookieExpression.length() == 0) {
-			cookieExpression = String.format("%s={%s}", name, name);
-		}
-		else {
-			cookieExpression += String.format("; %s={%s}", name, name);
-		}
-		data.template().removeHeader(HttpHeaders.COOKIE);
-		data.template().header(HttpHeaders.COOKIE, cookieExpression);
-		return true;
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/annotation/MatrixVariableParameterProcessor.java

@@ -69,7 +69,6 @@ public class MatrixVariableParameterProcessor implements AnnotatedParameterProce
 		return true;
 	}
 
-	@SuppressWarnings("unchecked")
 	private String expandMap(Object object) {
 		Map<String, Object> paramMap = (Map) object;
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/annotation/PathVariableParameterProcessor.java

@@ -34,7 +34,6 @@ import static feign.Util.emptyToNull;
  *
  * @author Jakub Narloch
  * @author Abhijit Sarkar
- * @author Yanming Zhou
  * @see AnnotatedParameterProcessor
  */
 public class PathVariableParameterProcessor implements AnnotatedParameterProcessor {
@@ -55,15 +54,14 @@ public class PathVariableParameterProcessor implements AnnotatedParameterProcess
 
 		MethodMetadata data = context.getMethodMetadata();
 		String varName = '{' + name + '}';
-		String varNameRegex = ".*\\{" + name + "(:[^}]+)?\\}.*";
-		if (!data.template().url().matches(varNameRegex) && !containsMapValues(data.template().queries(), varName)
-				&& !containsMapValues(data.template().headers(), varName)) {
+		if (!data.template().url().contains(varName) && !searchMapValues(data.template().queries(), varName)
+				&& !searchMapValues(data.template().headers(), varName)) {
 			data.formParams().add(name);
 		}
 		return true;
 	}
 
-	private <K, V> boolean containsMapValues(Map<K, Collection<V>> map, V search) {
+	private <K, V> boolean searchMapValues(Map<K, Collection<V>> map, V search) {
 		Collection<Collection<V>> values = map.values();
 		if (values == null) {
 			return false;

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/annotation/QueryMapParameterProcessor.java

@@ -28,7 +28,6 @@ import org.springframework.cloud.openfeign.SpringQueryMap;
  * {@link SpringQueryMap} parameter processor.
  *
  * @author Aram Peres
- * @author Olga Maciaszek-Sharma
  * @see AnnotatedParameterProcessor
  */
 public class QueryMapParameterProcessor implements AnnotatedParameterProcessor {
@@ -46,6 +45,7 @@ public class QueryMapParameterProcessor implements AnnotatedParameterProcessor {
 		MethodMetadata metadata = context.getMethodMetadata();
 		if (metadata.queryMapIndex() == null) {
 			metadata.queryMapIndex(paramIndex);
+			metadata.queryMapEncoded(SpringQueryMap.class.cast(annotation).encoded());
 		}
 		return true;
 	}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/aot/FeignChildContextInitializer.java

@@ -1,126 +0,0 @@
-/*
- * Copyright 2022-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.aot;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import javax.lang.model.element.Modifier;
-
-import org.springframework.aot.generate.GeneratedMethod;
-import org.springframework.aot.generate.GenerationContext;
-import org.springframework.beans.factory.BeanFactory;
-import org.springframework.beans.factory.aot.BeanRegistrationAotContribution;
-import org.springframework.beans.factory.aot.BeanRegistrationAotProcessor;
-import org.springframework.beans.factory.aot.BeanRegistrationCode;
-import org.springframework.beans.factory.support.RegisteredBean;
-import org.springframework.cloud.openfeign.FeignClientFactory;
-import org.springframework.cloud.openfeign.FeignClientSpecification;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.ConfigurableApplicationContext;
-import org.springframework.context.aot.ApplicationContextAotGenerator;
-import org.springframework.context.support.GenericApplicationContext;
-import org.springframework.javapoet.ClassName;
-import org.springframework.util.Assert;
-
-/**
- * A {@link BeanRegistrationAotProcessor} that creates an
- * {@link BeanRegistrationAotContribution} for Feign child contexts.
- *
- * @author Olga Maciaszek-Sharma
- * @since 4.0.0
- */
-public class FeignChildContextInitializer implements BeanRegistrationAotProcessor {
-
-	private final ApplicationContext applicationContext;
-
-	private final FeignClientFactory feignClientFactory;
-
-	public FeignChildContextInitializer(ApplicationContext applicationContext, FeignClientFactory feignClientFactory) {
-		this.applicationContext = applicationContext;
-		this.feignClientFactory = feignClientFactory;
-	}
-
-	@Override
-	public BeanRegistrationAotContribution processAheadOfTime(RegisteredBean registeredBean) {
-		Assert.isInstanceOf(ConfigurableApplicationContext.class, applicationContext);
-		ConfigurableApplicationContext context = ((ConfigurableApplicationContext) applicationContext);
-		BeanFactory applicationBeanFactory = context.getBeanFactory();
-		if (!((registeredBean.getBeanClass().equals(FeignClientFactory.class))
-				&& registeredBean.getBeanFactory().equals(applicationBeanFactory))) {
-			return null;
-		}
-		Set<String> contextIds = new HashSet<>(getContextIdsFromConfig());
-		Map<String, GenericApplicationContext> childContextAotContributions = contextIds.stream()
-				.map(contextId -> Map.entry(contextId, buildChildContext(contextId)))
-				.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-		return new AotContribution(childContextAotContributions);
-	}
-
-	private GenericApplicationContext buildChildContext(String contextId) {
-		GenericApplicationContext childContext = feignClientFactory.buildContext(contextId);
-		feignClientFactory.registerBeans(contextId, childContext);
-		return childContext;
-	}
-
-	private Collection<String> getContextIdsFromConfig() {
-		Map<String, FeignClientSpecification> configurations = feignClientFactory.getConfigurations();
-		return configurations.keySet().stream().filter(key -> !key.startsWith("default.")).collect(Collectors.toSet());
-	}
-
-	private static class AotContribution implements BeanRegistrationAotContribution {
-
-		private final Map<String, GenericApplicationContext> childContexts;
-
-		AotContribution(Map<String, GenericApplicationContext> childContexts) {
-			this.childContexts = childContexts.entrySet().stream().filter(entry -> entry.getValue() != null)
-					.map(entry -> Map.entry(entry.getKey(), entry.getValue()))
-					.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-		}
-
-		@Override
-		public void applyTo(GenerationContext generationContext, BeanRegistrationCode beanRegistrationCode) {
-			Map<String, ClassName> generatedInitializerClassNames = childContexts.entrySet().stream().map(entry -> {
-				String name = entry.getValue().getDisplayName();
-				name = name.replaceAll("[-]", "_");
-				GenerationContext childGenerationContext = generationContext.withName(name);
-				ClassName initializerClassName = new ApplicationContextAotGenerator()
-						.processAheadOfTime(entry.getValue(), childGenerationContext);
-				return Map.entry(entry.getKey(), initializerClassName);
-			}).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-			GeneratedMethod postProcessorMethod = beanRegistrationCode.getMethods()
-					.add("addFeignChildContextInitializer", method -> {
-						method.addJavadoc("Use AOT child context management initialization")
-								.addModifiers(Modifier.PRIVATE, Modifier.STATIC)
-								.addParameter(RegisteredBean.class, "registeredBean")
-								.addParameter(FeignClientFactory.class, "instance").returns(FeignClientFactory.class)
-								.addStatement("$T<String, Object> initializers = new $T<>()", Map.class, HashMap.class);
-						generatedInitializerClassNames.keySet()
-								.forEach(contextId -> method.addStatement("initializers.put($S, new $L())", contextId,
-										generatedInitializerClassNames.get(contextId)));
-						method.addStatement("return instance.withApplicationContextInitializers(initializers)");
-					});
-			beanRegistrationCode.addInstancePostProcessor(postProcessorMethod.toMethodReference());
-		}
-
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/aot/FeignClientBeanFactoryInitializationAotProcessor.java

@@ -1,215 +0,0 @@
-/*
- * Copyright 2022-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.aot;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Parameter;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import javax.lang.model.element.Modifier;
-
-import org.springframework.aot.generate.GenerationContext;
-import org.springframework.aot.generate.MethodReference;
-import org.springframework.aot.hint.BindingReflectionHintsRegistrar;
-import org.springframework.aot.hint.ReflectionHints;
-import org.springframework.aot.hint.RuntimeHints;
-import org.springframework.beans.MutablePropertyValues;
-import org.springframework.beans.factory.BeanFactory;
-import org.springframework.beans.factory.FactoryBean;
-import org.springframework.beans.factory.aot.BeanFactoryInitializationAotContribution;
-import org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor;
-import org.springframework.beans.factory.aot.BeanFactoryInitializationCode;
-import org.springframework.beans.factory.aot.BeanRegistrationExcludeFilter;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.beans.factory.config.BeanDefinitionHolder;
-import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
-import org.springframework.beans.factory.support.AbstractBeanDefinition;
-import org.springframework.beans.factory.support.BeanDefinitionBuilder;
-import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
-import org.springframework.beans.factory.support.BeanDefinitionRegistry;
-import org.springframework.beans.factory.support.DefaultListableBeanFactory;
-import org.springframework.beans.factory.support.GenericBeanDefinition;
-import org.springframework.beans.factory.support.RegisteredBean;
-import org.springframework.cloud.openfeign.FeignClientFactory;
-import org.springframework.cloud.openfeign.FeignClientFactoryBean;
-import org.springframework.cloud.openfeign.FeignClientSpecification;
-import org.springframework.context.support.GenericApplicationContext;
-import org.springframework.core.MethodParameter;
-import org.springframework.javapoet.MethodSpec;
-import org.springframework.util.Assert;
-import org.springframework.util.ClassUtils;
-
-/**
- * A {@link BeanFactoryInitializationAotProcessor} that creates an
- * {@link BeanFactoryInitializationAotContribution} that registers bean definitions and
- * proxy and reflection hints for Feign client beans.
- *
- * @author Olga Maciaszek-Sharma
- * @since 4.0.0
- */
-public class FeignClientBeanFactoryInitializationAotProcessor
-		implements BeanRegistrationExcludeFilter, BeanFactoryInitializationAotProcessor {
-
-	private final GenericApplicationContext context;
-
-	private final Map<String, BeanDefinition> feignClientBeanDefinitions;
-
-	private final BindingReflectionHintsRegistrar bindingRegistrar = new BindingReflectionHintsRegistrar();
-
-	public FeignClientBeanFactoryInitializationAotProcessor(GenericApplicationContext context,
-			FeignClientFactory feignClientFactory) {
-		this.context = context;
-		this.feignClientBeanDefinitions = getFeignClientBeanDefinitions(feignClientFactory);
-	}
-
-	@Override
-	public boolean isExcludedFromAotProcessing(RegisteredBean registeredBean) {
-		return registeredBean.getBeanClass().equals(FeignClientFactoryBean.class)
-				|| feignClientBeanDefinitions.containsKey(registeredBean.getBeanClass().getName());
-	}
-
-	private Map<String, BeanDefinition> getFeignClientBeanDefinitions(FeignClientFactory feignClientFactory) {
-		Map<String, FeignClientSpecification> configurations = feignClientFactory.getConfigurations();
-		return configurations.values().stream().map(FeignClientSpecification::getClassName).filter(Objects::nonNull)
-				.filter(className -> !className.equals("default"))
-				.map(className -> Map.entry(className, context.getBeanDefinition(className)))
-				.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-	}
-
-	@SuppressWarnings("NullableProblems")
-	@Override
-	public BeanFactoryInitializationAotContribution processAheadOfTime(ConfigurableListableBeanFactory beanFactory) {
-		BeanFactory applicationBeanFactory = context.getBeanFactory();
-		if (feignClientBeanDefinitions.isEmpty() || !beanFactory.equals(applicationBeanFactory)) {
-			return null;
-		}
-		return new AotContribution(feignClientBeanDefinitions);
-	}
-
-	private void registerMethodHints(ReflectionHints hints, Class<?> clazz) {
-		for (Method method : clazz.getDeclaredMethods()) {
-			registerMethodHints(hints, method);
-		}
-	}
-
-	private void registerMethodHints(ReflectionHints hints, Method method) {
-		for (Parameter parameter : method.getParameters()) {
-			bindingRegistrar.registerReflectionHints(hints,
-					MethodParameter.forParameter(parameter).getGenericParameterType());
-		}
-		MethodParameter returnTypeParameter = MethodParameter.forExecutable(method, -1);
-		if (!void.class.equals(returnTypeParameter.getParameterType())) {
-			bindingRegistrar.registerReflectionHints(hints, returnTypeParameter.getGenericParameterType());
-		}
-
-	}
-
-	// Visible for tests
-	final class AotContribution implements BeanFactoryInitializationAotContribution {
-
-		private final Map<String, BeanDefinition> feignClientBeanDefinitions;
-
-		private AotContribution(Map<String, BeanDefinition> feignClientBeanDefinitions) {
-			this.feignClientBeanDefinitions = feignClientBeanDefinitions;
-		}
-
-		@Override
-		public void applyTo(GenerationContext generationContext,
-				BeanFactoryInitializationCode beanFactoryInitializationCode) {
-			RuntimeHints hints = generationContext.getRuntimeHints();
-			Set<String> feignClientRegistrationMethods = feignClientBeanDefinitions.values().stream()
-					.map(beanDefinition -> {
-						Assert.notNull(beanDefinition, "beanDefinition cannot be null");
-						Assert.isInstanceOf(GenericBeanDefinition.class, beanDefinition);
-						GenericBeanDefinition registeredBeanDefinition = (GenericBeanDefinition) beanDefinition;
-						MutablePropertyValues feignClientProperties = registeredBeanDefinition.getPropertyValues();
-						String className = (String) feignClientProperties.get("type");
-						Assert.notNull(className, "className cannot be null");
-						Class<?> clazz = ClassUtils.resolveClassName(className, null);
-						hints.proxies().registerJdkProxy(clazz);
-						registerMethodHints(hints.reflection(), clazz);
-						return beanFactoryInitializationCode.getMethods()
-								.add(buildMethodName(className), method -> generateFeignClientRegistrationMethod(method,
-										feignClientProperties, registeredBeanDefinition))
-								.getName();
-					}).collect(Collectors.toSet());
-			MethodReference initializerMethod = beanFactoryInitializationCode.getMethods()
-					.add("initialize", method -> generateInitializerMethod(method, feignClientRegistrationMethods))
-					.toMethodReference();
-			beanFactoryInitializationCode.addInitializer(initializerMethod);
-		}
-
-		private String buildMethodName(String clientName) {
-			return "register" + clientName + "FeignClient";
-		}
-
-		private void generateInitializerMethod(MethodSpec.Builder method, Set<String> feignClientRegistrationMethods) {
-			method.addModifiers(Modifier.PUBLIC);
-			method.addParameter(DefaultListableBeanFactory.class, "registry");
-			feignClientRegistrationMethods.forEach(feignClientRegistrationMethod -> method.addStatement("$N(registry)",
-					feignClientRegistrationMethod));
-		}
-
-		private void generateFeignClientRegistrationMethod(MethodSpec.Builder method,
-				MutablePropertyValues feignClientPropertyValues, GenericBeanDefinition registeredBeanDefinition) {
-			Object feignQualifiers = feignClientPropertyValues.get("qualifiers");
-			Assert.notNull(feignQualifiers, "Feign qualifiers cannot be null");
-			String qualifiers = "{\"" + String.join("\",\"", (String[]) feignQualifiers) + "\"}";
-			method.addJavadoc("register Feign Client: $L", feignClientPropertyValues.get("type"))
-					.addModifiers(Modifier.PUBLIC, Modifier.STATIC)
-					.addParameter(BeanDefinitionRegistry.class, "registry")
-					.addStatement("Class clazz = $T.resolveClassName(\"$L\", null)", ClassUtils.class,
-							feignClientPropertyValues.get("type"))
-					.addStatement("$T definition = $T.genericBeanDefinition($T.class)", BeanDefinitionBuilder.class,
-							BeanDefinitionBuilder.class, FeignClientFactoryBean.class)
-					.addStatement("definition.addPropertyValue(\"name\",\"$L\")", feignClientPropertyValues.get("name"))
-					.addStatement("definition.addPropertyValue(\"contextId\", \"$L\")",
-							feignClientPropertyValues.get("contextId"))
-					.addStatement("definition.addPropertyValue(\"type\", clazz)")
-					.addStatement("definition.addPropertyValue(\"url\", \"$L\")", feignClientPropertyValues.get("url"))
-					.addStatement("definition.addPropertyValue(\"path\", \"$L\")",
-							feignClientPropertyValues.get("path"))
-					.addStatement("definition.addPropertyValue(\"dismiss404\", $L)",
-							feignClientPropertyValues.get("dismiss404"))
-					.addStatement("definition.addPropertyValue(\"fallback\", $T.class)",
-							feignClientPropertyValues.get("fallback"))
-					.addStatement("definition.addPropertyValue(\"fallbackFactory\", $T.class)",
-							feignClientPropertyValues.get("fallbackFactory"))
-					.addStatement("definition.setAutowireMode($L)", registeredBeanDefinition.getAutowireMode())
-					.addStatement("definition.setLazyInit($L)",
-							registeredBeanDefinition.getLazyInit() != null ? registeredBeanDefinition.getLazyInit()
-									: false)
-					.addStatement("$T beanDefinition = definition.getBeanDefinition()", AbstractBeanDefinition.class)
-					.addStatement("beanDefinition.setAttribute(\"$L\", clazz)", FactoryBean.OBJECT_TYPE_ATTRIBUTE)
-					.addStatement("beanDefinition.setPrimary($L)", registeredBeanDefinition.isPrimary())
-					.addStatement("$T holder = new $T(beanDefinition, \"$L\",  new String[]$L)",
-							BeanDefinitionHolder.class, BeanDefinitionHolder.class,
-							feignClientPropertyValues.get("type"), qualifiers)
-					.addStatement("$T.registerBeanDefinition(holder, registry) ", BeanDefinitionReaderUtils.class);
-		}
-
-		// Visible for tests
-		Map<String, BeanDefinition> getFeignClientBeanDefinitions() {
-			return feignClientBeanDefinitions;
-		}
-
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/clientconfig/Http2ClientFeignConfiguration.java

@@ -1,45 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.clientconfig;
-
-import java.net.http.HttpClient;
-import java.time.Duration;
-
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-/**
- * Default configuration for {@link HttpClient}.
- *
- * @author changjin wei(魏昌进)
- */
-@Configuration(proxyBeanMethods = false)
-@ConditionalOnMissingBean(HttpClient.class)
-public class Http2ClientFeignConfiguration {
-
-	@Bean
-	public HttpClient httpClient(FeignHttpClientProperties httpClientProperties) {
-		return HttpClient.newBuilder()
-				.followRedirects(httpClientProperties.isFollowRedirects() ? HttpClient.Redirect.ALWAYS
-						: HttpClient.Redirect.NEVER)
-				.version(HttpClient.Version.valueOf(httpClientProperties.getHttp2().getVersion()))
-				.connectTimeout(Duration.ofMillis(httpClientProperties.getConnectionTimeout())).build();
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/clientconfig/HttpClient5FeignConfiguration.java

@@ -19,14 +19,15 @@ package org.springframework.cloud.openfeign.clientconfig;
 import java.security.KeyManagementException;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
+import java.security.cert.CertificateException;
 import java.security.cert.X509Certificate;
 import java.util.concurrent.TimeUnit;
 
+import javax.annotation.PreDestroy;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.X509TrustManager;
 
-import jakarta.annotation.PreDestroy;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.hc.client5.http.config.RequestConfig;
@@ -35,7 +36,6 @@ import org.apache.hc.client5.http.impl.classic.HttpClients;
 import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
 import org.apache.hc.client5.http.io.HttpClientConnectionManager;
 import org.apache.hc.client5.http.socket.LayeredConnectionSocketFactory;
-import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
 import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactoryBuilder;
 import org.apache.hc.core5.http.io.SocketConfig;
 import org.apache.hc.core5.http.ssl.TLS;
@@ -55,7 +55,6 @@ import org.springframework.context.annotation.Configuration;
  * Default configuration for {@link CloseableHttpClient}.
  *
  * @author Nguyen Ky Thanh
- * @author changjin wei(魏昌进)
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnMissingBean(CloseableHttpClient.class)
@@ -91,11 +90,7 @@ public class HttpClient5FeignConfiguration {
 				.setDefaultRequestConfig(RequestConfig.custom()
 						.setConnectTimeout(
 								Timeout.of(httpClientProperties.getConnectionTimeout(), TimeUnit.MILLISECONDS))
-						.setRedirectsEnabled(httpClientProperties.isFollowRedirects())
-						.setConnectionRequestTimeout(
-								Timeout.of(httpClientProperties.getHc5().getConnectionRequestTimeout(),
-										httpClientProperties.getHc5().getConnectionRequestTimeoutUnit()))
-						.build())
+						.setRedirectsEnabled(httpClientProperties.isFollowRedirects()).build())
 				.build();
 		return httpClient5;
 	}
@@ -116,9 +111,11 @@ public class HttpClient5FeignConfiguration {
 				final SSLContext sslContext = SSLContext.getInstance("SSL");
 				sslContext.init(null, new TrustManager[] { new DisabledValidationTrustManager() }, new SecureRandom());
 				sslConnectionSocketFactoryBuilder.setSslContext(sslContext);
-				sslConnectionSocketFactoryBuilder.setHostnameVerifier(NoopHostnameVerifier.INSTANCE);
 			}
-			catch (NoSuchAlgorithmException | KeyManagementException e) {
+			catch (NoSuchAlgorithmException e) {
+				LOG.warn("Error creating SSLContext", e);
+			}
+			catch (KeyManagementException e) {
 				LOG.warn("Error creating SSLContext", e);
 			}
 		}
@@ -134,10 +131,10 @@ public class HttpClient5FeignConfiguration {
 		DisabledValidationTrustManager() {
 		}
 
-		public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {
+		public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
 		}
 
-		public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {
+		public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
 		}
 
 		public X509Certificate[] getAcceptedIssuers() {

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/clientconfig/HttpClientFeignConfiguration.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2013-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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.openfeign.clientconfig;
+
+import java.io.IOException;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import javax.annotation.PreDestroy;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.config.RegistryBuilder;
+import org.apache.http.conn.HttpClientConnectionManager;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.cloud.commons.httpclient.ApacheHttpClientConnectionManagerFactory;
+import org.springframework.cloud.commons.httpclient.ApacheHttpClientFactory;
+import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Default configuration for {@link CloseableHttpClient}.
+ *
+ * @author Ryan Baxter
+ * @author Marcin Grzejszczak
+ * @author Spencer Gibb
+ * @author Olga Maciaszek-Sharma
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnMissingBean(CloseableHttpClient.class)
+public class HttpClientFeignConfiguration {
+
+	private static final Log LOG = LogFactory.getLog(HttpClientFeignConfiguration.class);
+
+	private final Timer connectionManagerTimer = new Timer("FeignApacheHttpClientConfiguration.connectionManagerTimer",
+			true);
+
+	private CloseableHttpClient httpClient;
+
+	@Autowired(required = false)
+	private RegistryBuilder registryBuilder;
+
+	@Bean
+	@ConditionalOnMissingBean(HttpClientConnectionManager.class)
+	public HttpClientConnectionManager connectionManager(
+			ApacheHttpClientConnectionManagerFactory connectionManagerFactory,
+			FeignHttpClientProperties httpClientProperties) {
+		final HttpClientConnectionManager connectionManager = connectionManagerFactory.newConnectionManager(
+				httpClientProperties.isDisableSslValidation(), httpClientProperties.getMaxConnections(),
+				httpClientProperties.getMaxConnectionsPerRoute(), httpClientProperties.getTimeToLive(),
+				httpClientProperties.getTimeToLiveUnit(), this.registryBuilder);
+		this.connectionManagerTimer.schedule(new TimerTask() {
+			@Override
+			public void run() {
+				connectionManager.closeExpiredConnections();
+			}
+		}, 30000, httpClientProperties.getConnectionTimerRepeat());
+		return connectionManager;
+	}
+
+	@Bean
+	@ConditionalOnProperty(value = "feign.compression.response.enabled", havingValue = "true")
+	public CloseableHttpClient customHttpClient(HttpClientConnectionManager httpClientConnectionManager,
+			FeignHttpClientProperties httpClientProperties) {
+		HttpClientBuilder builder = HttpClientBuilder.create().disableCookieManagement().useSystemProperties();
+		this.httpClient = createClient(builder, httpClientConnectionManager, httpClientProperties);
+		return this.httpClient;
+	}
+
+	@Bean
+	@ConditionalOnProperty(value = "feign.compression.response.enabled", havingValue = "false", matchIfMissing = true)
+	public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory,
+			HttpClientConnectionManager httpClientConnectionManager, FeignHttpClientProperties httpClientProperties) {
+		this.httpClient = createClient(httpClientFactory.createBuilder(), httpClientConnectionManager,
+				httpClientProperties);
+		return this.httpClient;
+	}
+
+	private CloseableHttpClient createClient(HttpClientBuilder builder,
+			HttpClientConnectionManager httpClientConnectionManager, FeignHttpClientProperties httpClientProperties) {
+		RequestConfig defaultRequestConfig = RequestConfig.custom()
+				.setConnectTimeout(httpClientProperties.getConnectionTimeout())
+				.setRedirectsEnabled(httpClientProperties.isFollowRedirects()).build();
+		CloseableHttpClient httpClient = builder.setDefaultRequestConfig(defaultRequestConfig)
+				.setConnectionManager(httpClientConnectionManager).build();
+		return httpClient;
+	}
+
+	@PreDestroy
+	public void destroy() {
+		this.connectionManagerTimer.cancel();
+		if (this.httpClient != null) {
+			try {
+				this.httpClient.close();
+			}
+			catch (IOException e) {
+				if (LOG.isErrorEnabled()) {
+					LOG.error("Could not correctly close httpClient.");
+				}
+			}
+		}
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/clientconfig/OkHttpFeignConfiguration.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2013-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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.openfeign.clientconfig;
+
+import java.util.concurrent.TimeUnit;
+
+import javax.annotation.PreDestroy;
+
+import okhttp3.ConnectionPool;
+import okhttp3.OkHttpClient;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.cloud.commons.httpclient.OkHttpClientConnectionPoolFactory;
+import org.springframework.cloud.commons.httpclient.OkHttpClientFactory;
+import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Defualt configuration for {@link OkHttpClient}.
+ *
+ * @author Ryan Baxter
+ * @author Marcin Grzejszczak
+ * @author Spencer Gibb
+ * @author Olga Maciaszek-Sharma
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
+public class OkHttpFeignConfiguration {
+
+	private okhttp3.OkHttpClient okHttpClient;
+
+	@Bean
+	@ConditionalOnMissingBean(ConnectionPool.class)
+	public ConnectionPool httpClientConnectionPool(FeignHttpClientProperties httpClientProperties,
+			OkHttpClientConnectionPoolFactory connectionPoolFactory) {
+		Integer maxTotalConnections = httpClientProperties.getMaxConnections();
+		Long timeToLive = httpClientProperties.getTimeToLive();
+		TimeUnit ttlUnit = httpClientProperties.getTimeToLiveUnit();
+		return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
+	}
+
+	@Bean
+	public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory, ConnectionPool connectionPool,
+			FeignHttpClientProperties httpClientProperties) {
+		Boolean followRedirects = httpClientProperties.isFollowRedirects();
+		Integer connectTimeout = httpClientProperties.getConnectionTimeout();
+		this.okHttpClient = httpClientFactory.createBuilder(httpClientProperties.isDisableSslValidation())
+				.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).followRedirects(followRedirects)
+				.connectionPool(connectionPool).build();
+		return this.okHttpClient;
+	}
+
+	@PreDestroy
+	public void destroy() {
+		if (this.okHttpClient != null) {
+			this.okHttpClient.dispatcher().executorService().shutdown();
+			this.okHttpClient.connectionPool().evictAll();
+		}
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/encoding/FeignAcceptGzipEncodingAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2023 the original author or authors.
+ * Copyright 2013-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.
@@ -22,28 +22,27 @@ import feign.Feign;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.openfeign.FeignAutoConfiguration;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
 
 /**
  * Configures the Feign response compression.
  *
  * @author Jakub Narloch
- * @author Olga Maciaszek-Sharma
  * @see FeignAcceptGzipEncodingInterceptor
  */
 @Configuration(proxyBeanMethods = false)
 @EnableConfigurationProperties(FeignClientEncodingProperties.class)
 @ConditionalOnClass(Feign.class)
 @ConditionalOnBean(Client.class)
-@ConditionalOnProperty("spring.cloud.openfeign.compression.response.enabled")
+@ConditionalOnProperty(value = "feign.compression.response.enabled", matchIfMissing = false)
 // The OK HTTP client uses "transparent" compression.
-// If the accept-encoding header is present, it disables transparent compression.
-@Conditional(OkHttpFeignClientBeanMissingCondition.class)
+// If the accept-encoding header is present it disable transparent compression
+@ConditionalOnMissingBean(type = "okhttp3.OkHttpClient")
 @AutoConfigureAfter(FeignAutoConfiguration.class)
 public class FeignAcceptGzipEncodingAutoConfiguration {
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/encoding/FeignClientEncodingProperties.java

@@ -26,7 +26,7 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
  *
  * @author Jakub Narloch
  */
-@ConfigurationProperties("spring.cloud.openfeign.compression.request")
+@ConfigurationProperties("feign.compression.request")
 public class FeignClientEncodingProperties {
 
 	/**
@@ -40,7 +40,7 @@ public class FeignClientEncodingProperties {
 	private int minRequestSize = 2048;
 
 	public String[] getMimeTypes() {
-		return mimeTypes;
+		return this.mimeTypes;
 	}
 
 	public void setMimeTypes(String[] mimeTypes) {
@@ -48,7 +48,7 @@ public class FeignClientEncodingProperties {
 	}
 
 	public int getMinRequestSize() {
-		return minRequestSize;
+		return this.minRequestSize;
 	}
 
 	public void setMinRequestSize(int minRequestSize) {
@@ -64,19 +64,20 @@ public class FeignClientEncodingProperties {
 			return false;
 		}
 		FeignClientEncodingProperties that = (FeignClientEncodingProperties) o;
-		return Arrays.equals(mimeTypes, that.mimeTypes) && Objects.equals(minRequestSize, that.minRequestSize);
+		return Arrays.equals(this.mimeTypes, that.mimeTypes)
+				&& Objects.equals(this.minRequestSize, that.minRequestSize);
 	}
 
 	@Override
 	public int hashCode() {
-		return Objects.hash(Arrays.hashCode(mimeTypes), minRequestSize);
+		return Objects.hash(this.mimeTypes, this.minRequestSize);
 	}
 
 	@Override
 	public String toString() {
 		return new StringBuilder("FeignClientEncodingProperties{").append("mimeTypes=")
-				.append(Arrays.toString(mimeTypes)).append(", ").append("minRequestSize=").append(minRequestSize)
-				.append("}").toString();
+				.append(Arrays.toString(this.mimeTypes)).append(", ").append("minRequestSize=")
+				.append(this.minRequestSize).append("}").toString();
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/encoding/FeignContentGzipEncodingAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2023 the original author or authors.
+ * Copyright 2013-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.
@@ -20,27 +20,26 @@ import feign.Feign;
 
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.openfeign.FeignAutoConfiguration;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
 
 /**
  * Configures the Feign request compression.
  *
  * @author Jakub Narloch
- * @author Olga Maciaszek-Sharma
  * @see FeignContentGzipEncodingInterceptor
  */
 @Configuration(proxyBeanMethods = false)
 @EnableConfigurationProperties(FeignClientEncodingProperties.class)
 @ConditionalOnClass(Feign.class)
 // The OK HTTP client uses "transparent" compression.
-// If the content-encoding header is present, it disables transparent compression.
-@Conditional(OkHttpFeignClientBeanMissingCondition.class)
-@ConditionalOnProperty("spring.cloud.openfeign.compression.request.enabled")
+// If the content-encoding header is present it disable transparent compression
+@ConditionalOnMissingBean(type = "okhttp3.OkHttpClient")
+@ConditionalOnProperty("feign.compression.request.enabled")
 @AutoConfigureAfter(FeignAutoConfiguration.class)
 public class FeignContentGzipEncodingAutoConfiguration {
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/encoding/FeignContentGzipEncodingInterceptor.java

@@ -83,7 +83,7 @@ public class FeignContentGzipEncodingInterceptor extends BaseRequestInterceptor
 	}
 
 	/**
-	 * Returns whether the content mime types matches the configured mime types.
+	 * Returns whether the content mime types matches the configures mime types.
 	 * @param contentTypes the content types
 	 * @return true if any specified content type matches the request content types
 	 */

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/encoding/OkHttpFeignClientBeanMissingCondition.java

@@ -1,51 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.encoding;
-
-import feign.Client;
-import feign.okhttp.OkHttpClient;
-
-import org.springframework.boot.autoconfigure.condition.AnyNestedCondition;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.context.annotation.Condition;
-
-/**
- * A {@link Condition} that verifies whether the conditions for creating Feign
- * {@link Client} beans that either are of type {@link OkHttpClient} or have a delegate of
- * type {@link OkHttpClient} are not met.
- *
- * @author Olga Maciaszek-Sharma
- * @since 4.0.2
- */
-public class OkHttpFeignClientBeanMissingCondition extends AnyNestedCondition {
-
-	public OkHttpFeignClientBeanMissingCondition() {
-		super(ConfigurationPhase.REGISTER_BEAN);
-	}
-
-	@ConditionalOnMissingClass("feign.okhttp.OkHttpClient")
-	static class FeignOkHttpClientPresent {
-
-	}
-
-	@ConditionalOnProperty(value = "spring.cloud.openfeign.okhttp.enabled", havingValue = "false")
-	static class FeignOkHttpClientEnabled {
-
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/hateoas/FeignHalAutoConfiguration.java

@@ -16,18 +16,26 @@
 
 package org.springframework.cloud.openfeign.hateoas;
 
+import java.util.Collections;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
 import org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration;
 import org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration;
 import org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration;
-import org.springframework.cloud.openfeign.support.HttpMessageConverterCustomizer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.hateoas.config.HateoasConfiguration;
-import org.springframework.hateoas.config.WebConverters;
+import org.springframework.hateoas.RepresentationModel;
+import org.springframework.hateoas.mediatype.hal.HalMediaTypeConfiguration;
+import org.springframework.hateoas.server.mvc.TypeConstrainedMappingJackson2HttpMessageConverter;
+
+import static org.springframework.hateoas.MediaTypes.HAL_JSON;
 
 /**
  * @author Hector Espert
@@ -35,15 +43,23 @@ import org.springframework.hateoas.config.WebConverters;
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnWebApplication
-@ConditionalOnClass(WebConverters.class)
+@ConditionalOnClass(RepresentationModel.class)
 @AutoConfigureAfter({ JacksonAutoConfiguration.class, HttpMessageConvertersAutoConfiguration.class,
-		RepositoryRestMvcAutoConfiguration.class, HateoasConfiguration.class })
+		RepositoryRestMvcAutoConfiguration.class })
 public class FeignHalAutoConfiguration {
 
 	@Bean
-	@ConditionalOnBean(WebConverters.class)
-	HttpMessageConverterCustomizer webConvertersCustomizer(WebConverters webConverters) {
-		return new WebConvertersCustomizer(webConverters);
+	@ConditionalOnBean(HalMediaTypeConfiguration.class)
+	@ConditionalOnMissingBean
+	public TypeConstrainedMappingJackson2HttpMessageConverter halJacksonHttpMessageConverter(
+			ObjectProvider<ObjectMapper> objectMapper, HalMediaTypeConfiguration halConfiguration) {
+		ObjectMapper mapper = objectMapper.getIfAvailable(ObjectMapper::new).copy();
+		halConfiguration.configureObjectMapper(mapper);
+		TypeConstrainedMappingJackson2HttpMessageConverter converter = new TypeConstrainedMappingJackson2HttpMessageConverter(
+				RepresentationModel.class);
+		converter.setSupportedMediaTypes(Collections.singletonList(HAL_JSON));
+		converter.setObjectMapper(mapper);
+		return converter;
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/hateoas/WebConvertersCustomizer.java

@@ -1,41 +0,0 @@
-/*
- * Copyright 2016-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.hateoas;
-
-import java.util.List;
-
-import org.springframework.cloud.openfeign.support.HttpMessageConverterCustomizer;
-import org.springframework.hateoas.config.WebConverters;
-import org.springframework.http.converter.HttpMessageConverter;
-
-/**
- * @author Olga Maciaszek-Sharma
- */
-public class WebConvertersCustomizer implements HttpMessageConverterCustomizer {
-
-	private final WebConverters webConverters;
-
-	public WebConvertersCustomizer(WebConverters webConverters) {
-		this.webConverters = webConverters;
-	}
-
-	@Override
-	public void accept(List<HttpMessageConverter<?>> httpMessageConverters) {
-		webConverters.augmentClient(httpMessageConverters);
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/DefaultFeignLoadBalancerConfiguration.java

@@ -16,8 +16,6 @@
 
 package org.springframework.cloud.openfeign.loadbalancer;
 
-import java.util.List;
-
 import feign.Client;
 
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
@@ -27,7 +25,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
-import org.springframework.cloud.client.loadbalancer.LoadBalancerClientsProperties;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerProperties;
 import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
@@ -38,21 +36,19 @@ import org.springframework.context.annotation.Configuration;
  * that uses {@link Client.Default} under the hood.
  *
  * @author Olga Maciaszek-Sharma
- * @author changjin wei(魏昌进)
  * @since 2.2.0
  */
 @Configuration(proxyBeanMethods = false)
-@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
+@EnableConfigurationProperties(LoadBalancerProperties.class)
 class DefaultFeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
 	@Conditional(OnRetryNotEnabledCondition.class)
-	public Client feignClient(LoadBalancerClient loadBalancerClient,
-			LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
-		return new FeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient,
-				loadBalancerClientFactory, transformers);
+	public Client feignClient(LoadBalancerClient loadBalancerClient, LoadBalancerProperties properties,
+			LoadBalancerClientFactory loadBalancerClientFactory) {
+		return new FeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient, properties,
+				loadBalancerClientFactory);
 	}
 
 	@Bean
@@ -62,10 +58,10 @@ class DefaultFeignLoadBalancerConfiguration {
 	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
 			matchIfMissing = true)
 	public Client feignRetryClient(LoadBalancerClient loadBalancerClient,
-			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
+			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerProperties properties,
+			LoadBalancerClientFactory loadBalancerClientFactory) {
 		return new RetryableFeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient,
-				loadBalancedRetryFactory, loadBalancerClientFactory, transformers);
+				loadBalancedRetryFactory, properties, loadBalancerClientFactory);
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/FeignBlockingLoadBalancerClient.java

@@ -19,8 +19,6 @@ package org.springframework.cloud.openfeign.loadbalancer;
 import java.io.IOException;
 import java.net.URI;
 import java.nio.charset.StandardCharsets;
-import java.util.Collections;
-import java.util.List;
 import java.util.Set;
 
 import feign.Client;
@@ -51,7 +49,6 @@ import static org.springframework.cloud.openfeign.loadbalancer.LoadBalancerUtils
  * {@link ServiceInstance} to use while resolving the request host.
  *
  * @author Olga Maciaszek-Sharma
- * @author changjin wei(魏昌进)
  * @since 2.2.0
  */
 @SuppressWarnings({ "unchecked", "rawtypes" })
@@ -63,43 +60,16 @@ public class FeignBlockingLoadBalancerClient implements Client {
 
 	private final LoadBalancerClient loadBalancerClient;
 
-	private final LoadBalancerClientFactory loadBalancerClientFactory;
+	private final LoadBalancerProperties properties;
 
-	private final List<LoadBalancerFeignRequestTransformer> transformers;
+	private final LoadBalancerClientFactory loadBalancerClientFactory;
 
-	/**
-	 * @deprecated in favour of
-	 * {@link FeignBlockingLoadBalancerClient#FeignBlockingLoadBalancerClient(Client, LoadBalancerClient, LoadBalancerClientFactory, List)}
-	 */
-	@Deprecated
 	public FeignBlockingLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient,
 			LoadBalancerProperties properties, LoadBalancerClientFactory loadBalancerClientFactory) {
 		this.delegate = delegate;
 		this.loadBalancerClient = loadBalancerClient;
+		this.properties = properties;
 		this.loadBalancerClientFactory = loadBalancerClientFactory;
-		this.transformers = Collections.emptyList();
-	}
-
-	/**
-	 * @deprecated in favour of
-	 * {@link FeignBlockingLoadBalancerClient#FeignBlockingLoadBalancerClient(Client, LoadBalancerClient, LoadBalancerClientFactory, List)}
-	 */
-	@Deprecated
-	public FeignBlockingLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient,
-			LoadBalancerClientFactory loadBalancerClientFactory) {
-		this.delegate = delegate;
-		this.loadBalancerClient = loadBalancerClient;
-		this.loadBalancerClientFactory = loadBalancerClientFactory;
-		this.transformers = Collections.emptyList();
-	}
-
-	public FeignBlockingLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient,
-			LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
-		this.delegate = delegate;
-		this.loadBalancerClient = loadBalancerClient;
-		this.loadBalancerClientFactory = loadBalancerClientFactory;
-		this.transformers = transformers;
 	}
 
 	@Override
@@ -130,7 +100,7 @@ public class FeignBlockingLoadBalancerClient implements Client {
 					.body(message, StandardCharsets.UTF_8).build();
 		}
 		String reconstructedUrl = loadBalancerClient.reconstructURI(instance, originalUri).toString();
-		Request newRequest = buildRequest(request, reconstructedUrl, instance);
+		Request newRequest = buildRequest(request, reconstructedUrl);
 		return executeWithLoadBalancerLifecycleProcessing(delegate, options, newRequest, lbRequest, lbResponse,
 				supportedLifecycleProcessors);
 	}
@@ -140,23 +110,12 @@ public class FeignBlockingLoadBalancerClient implements Client {
 				request.charset(), request.requestTemplate());
 	}
 
-	protected Request buildRequest(Request request, String reconstructedUrl, ServiceInstance instance) {
-		Request newRequest = buildRequest(request, reconstructedUrl);
-		if (transformers != null) {
-			for (LoadBalancerFeignRequestTransformer transformer : transformers) {
-				newRequest = transformer.transformRequest(newRequest, instance);
-			}
-		}
-		return newRequest;
-	}
-
 	// Visible for Sleuth instrumentation
 	public Client getDelegate() {
 		return delegate;
 	}
 
 	private String getHint(String serviceId) {
-		LoadBalancerProperties properties = loadBalancerClientFactory.getProperties(serviceId);
 		String defaultHint = properties.getHint().getOrDefault("default", "default");
 		String hintPropertyValue = properties.getHint().get(serviceId);
 		return hintPropertyValue != null ? hintPropertyValue : defaultHint;

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/FeignLoadBalancerAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2023 the original author or authors.
+ * Copyright 2013-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,7 +23,6 @@ import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.AutoConfigureBefore;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
@@ -31,7 +30,6 @@ import org.springframework.cloud.loadbalancer.config.BlockingLoadBalancerClientA
 import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
 import org.springframework.cloud.openfeign.FeignAutoConfiguration;
 import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
-import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 
@@ -41,7 +39,6 @@ import org.springframework.context.annotation.Import;
  *
  * @author Olga Maciaszek-Sharma
  * @author Nguyen Ky Thanh
- * @author changjin wei(魏昌进)
  * @since 2.2.0
  */
 @ConditionalOnClass(Feign.class)
@@ -53,15 +50,8 @@ import org.springframework.context.annotation.Import;
 // Order is important here, last should be the default, first should be optional
 // see
 // https://github.com/spring-cloud/spring-cloud-netflix/issues/2086#issuecomment-316281653
-@Import({ OkHttpFeignLoadBalancerConfiguration.class, HttpClient5FeignLoadBalancerConfiguration.class,
-		Http2ClientFeignLoadBalancerConfiguration.class, DefaultFeignLoadBalancerConfiguration.class })
+@Import({ HttpClientFeignLoadBalancerConfiguration.class, OkHttpFeignLoadBalancerConfiguration.class,
+		HttpClient5FeignLoadBalancerConfiguration.class, DefaultFeignLoadBalancerConfiguration.class })
 public class FeignLoadBalancerAutoConfiguration {
 
-	@Bean
-	@ConditionalOnBean(LoadBalancerClientFactory.class)
-	@ConditionalOnMissingBean(XForwardedHeadersTransformer.class)
-	public XForwardedHeadersTransformer xForwarderHeadersFeignTransformer(LoadBalancerClientFactory factory) {
-		return new XForwardedHeadersTransformer(factory);
-	}
-
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/HttpClient5FeignLoadBalancerConfiguration.java

@@ -16,8 +16,6 @@
 
 package org.springframework.cloud.openfeign.loadbalancer;
 
-import java.util.List;
-
 import feign.Client;
 import feign.hc5.ApacheHttp5Client;
 import org.apache.hc.client5.http.classic.HttpClient;
@@ -29,7 +27,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
-import org.springframework.cloud.client.loadbalancer.LoadBalancerClientsProperties;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerProperties;
 import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
 import org.springframework.cloud.openfeign.clientconfig.HttpClient5FeignConfiguration;
 import org.springframework.context.annotation.Bean;
@@ -42,27 +40,22 @@ import org.springframework.context.annotation.Import;
  * that uses {@link ApacheHttp5Client} under the hood.
  *
  * @author Nguyen Ky Thanh
- * @author changjin wei(魏昌进)
- * @author Olga Maciaszek-Sharma
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnClass(ApacheHttp5Client.class)
 @ConditionalOnBean({ LoadBalancerClient.class, LoadBalancerClientFactory.class })
-@ConditionalOnProperty(value = "spring.cloud.openfeign.httpclient.hc5.enabled", havingValue = "true",
-		matchIfMissing = true)
+@ConditionalOnProperty(value = "feign.httpclient.hc5.enabled", havingValue = "true")
 @Import(HttpClient5FeignConfiguration.class)
-@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
+@EnableConfigurationProperties(LoadBalancerProperties.class)
 class HttpClient5FeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
 	@Conditional(OnRetryNotEnabledCondition.class)
 	public Client feignClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient5,
-			LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
+			LoadBalancerProperties properties, LoadBalancerClientFactory loadBalancerClientFactory) {
 		Client delegate = new ApacheHttp5Client(httpClient5);
-		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancerClientFactory,
-				transformers);
+		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, properties, loadBalancerClientFactory);
 	}
 
 	@Bean
@@ -72,11 +65,11 @@ class HttpClient5FeignLoadBalancerConfiguration {
 	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
 			matchIfMissing = true)
 	public Client feignRetryClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient5,
-			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
+			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerProperties properties,
+			LoadBalancerClientFactory loadBalancerClientFactory) {
 		Client delegate = new ApacheHttp5Client(httpClient5);
 		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancedRetryFactory,
-				loadBalancerClientFactory, transformers);
+				properties, loadBalancerClientFactory);
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/HttpClientFeignLoadBalancerConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2023 the original author or authors.
+ * Copyright 2013-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.
@@ -16,11 +16,9 @@
 
 package org.springframework.cloud.openfeign.loadbalancer;
 
-import java.net.http.HttpClient;
-import java.util.List;
-
 import feign.Client;
-import feign.http2client.Http2Client;
+import feign.httpclient.ApacheHttpClient;
+import org.apache.http.client.HttpClient;
 
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
@@ -29,34 +27,39 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
-import org.springframework.cloud.client.loadbalancer.LoadBalancerClientsProperties;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerProperties;
 import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
+import org.springframework.cloud.openfeign.HttpClient5DisabledConditions;
+import org.springframework.cloud.openfeign.clientconfig.HttpClientFeignConfiguration;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
 
 /**
  * Configuration instantiating a {@link LoadBalancerClient}-based {@link Client} object
- * that uses {@link Http2Client} under the hood.
+ * that uses {@link ApacheHttpClient} under the hood.
  *
- * @author changjin wei(魏昌进)
+ * @author Olga Maciaszek-Sharma
+ * @author Nguyen Ky Thanh
+ * @since 2.2.0
  */
 @Configuration(proxyBeanMethods = false)
-@ConditionalOnClass({ Http2Client.class, HttpClient.class })
+@ConditionalOnClass(ApacheHttpClient.class)
 @ConditionalOnBean({ LoadBalancerClient.class, LoadBalancerClientFactory.class })
-@ConditionalOnProperty("spring.cloud.openfeign.http2client.enabled")
-@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
-class Http2ClientFeignLoadBalancerConfiguration {
+@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
+@Conditional(HttpClient5DisabledConditions.class)
+@Import(HttpClientFeignConfiguration.class)
+@EnableConfigurationProperties(LoadBalancerProperties.class)
+class HttpClientFeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
 	@Conditional(OnRetryNotEnabledCondition.class)
 	public Client feignClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient,
-			LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
-		Client delegate = new Http2Client(httpClient);
-		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancerClientFactory,
-				transformers);
+			LoadBalancerProperties properties, LoadBalancerClientFactory loadBalancerClientFactory) {
+		ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
+		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, properties, loadBalancerClientFactory);
 	}
 
 	@Bean
@@ -66,11 +69,11 @@ class Http2ClientFeignLoadBalancerConfiguration {
 	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
 			matchIfMissing = true)
 	public Client feignRetryClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient,
-			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
-		Client delegate = new Http2Client(httpClient);
+			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerProperties properties,
+			LoadBalancerClientFactory loadBalancerClientFactory) {
+		ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
 		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancedRetryFactory,
-				loadBalancerClientFactory, transformers);
+				properties, loadBalancerClientFactory);
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/LoadBalancerFeignRequestTransformer.java

@@ -1,47 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.loadbalancer;
-
-import feign.Request;
-
-import org.springframework.cloud.client.ServiceInstance;
-import org.springframework.core.annotation.Order;
-
-/**
- * Allows applications to transform the load-balanced {@link Request} given the chosen
- * {@link org.springframework.cloud.client.ServiceInstance}.
- *
- * @author changjin wei(魏昌进)
- */
-@Order(LoadBalancerFeignRequestTransformer.DEFAULT_ORDER)
-public interface LoadBalancerFeignRequestTransformer {
-
-	/**
-	 * Order for the {@link LoadBalancerFeignRequestTransformer}.
-	 */
-	int DEFAULT_ORDER = 0;
-
-	/**
-	 * Allows transforming load-balanced requests based on the provided
-	 * {@link ServiceInstance}.
-	 * @param request Original request.
-	 * @param instance ServiceInstance returned from LoadBalancer.
-	 * @return New request or original request
-	 */
-	Request transformRequest(Request request, ServiceInstance instance);
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/LoadBalancerUtils.java

@@ -33,7 +33,7 @@ import org.springframework.cloud.client.loadbalancer.RequestData;
 import org.springframework.cloud.client.loadbalancer.ResponseData;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
-import org.springframework.http.HttpStatusCode;
+import org.springframework.http.HttpStatus;
 
 /**
  * @author Olga Maciaszek-Sharma
@@ -73,14 +73,14 @@ final class LoadBalancerUtils {
 	static ResponseData buildResponseData(Response response) {
 		HttpHeaders responseHeaders = new HttpHeaders();
 		response.headers().forEach((key, value) -> responseHeaders.put(key, new ArrayList<>(value)));
-		return new ResponseData(HttpStatusCode.valueOf(response.status()), responseHeaders, null,
+		return new ResponseData(HttpStatus.resolve(response.status()), responseHeaders, null,
 				buildRequestData(response.request()));
 	}
 
 	static RequestData buildRequestData(Request request) {
 		HttpHeaders requestHeaders = new HttpHeaders();
 		request.headers().forEach((key, value) -> requestHeaders.put(key, new ArrayList<>(value)));
-		return new RequestData(HttpMethod.valueOf(request.httpMethod().name()), URI.create(request.url()),
+		return new RequestData(HttpMethod.resolve(request.httpMethod().name()), URI.create(request.url()),
 				requestHeaders, null, new HashMap<>());
 	}
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/OkHttpFeignLoadBalancerConfiguration.java

@@ -16,8 +16,6 @@
 
 package org.springframework.cloud.openfeign.loadbalancer;
 
-import java.util.List;
-
 import feign.Client;
 import feign.okhttp.OkHttpClient;
 
@@ -28,36 +26,36 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
-import org.springframework.cloud.client.loadbalancer.LoadBalancerClientsProperties;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerProperties;
 import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
+import org.springframework.cloud.openfeign.clientconfig.OkHttpFeignConfiguration;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
 
 /**
  * Configuration instantiating a {@link LoadBalancerClient}-based {@link Client} object
  * that uses {@link OkHttpClient} under the hood.
  *
  * @author Olga Maciaszek-Sharma
- * @author changjin wei(魏昌进)
  * @since 2.2.0
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnClass(OkHttpClient.class)
-@ConditionalOnProperty("spring.cloud.openfeign.okhttp.enabled")
+@ConditionalOnProperty("feign.okhttp.enabled")
 @ConditionalOnBean({ LoadBalancerClient.class, LoadBalancerClientFactory.class })
-@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
+@Import(OkHttpFeignConfiguration.class)
+@EnableConfigurationProperties(LoadBalancerProperties.class)
 class OkHttpFeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
 	@Conditional(OnRetryNotEnabledCondition.class)
 	public Client feignClient(okhttp3.OkHttpClient okHttpClient, LoadBalancerClient loadBalancerClient,
-			LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
+			LoadBalancerProperties properties, LoadBalancerClientFactory loadBalancerClientFactory) {
 		OkHttpClient delegate = new OkHttpClient(okHttpClient);
-		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancerClientFactory,
-				transformers);
+		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, properties, loadBalancerClientFactory);
 	}
 
 	@Bean
@@ -67,11 +65,11 @@ class OkHttpFeignLoadBalancerConfiguration {
 	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
 			matchIfMissing = true)
 	public Client feignRetryClient(LoadBalancerClient loadBalancerClient, okhttp3.OkHttpClient okHttpClient,
-			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
+			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerProperties properties,
+			LoadBalancerClientFactory loadBalancerClientFactory) {
 		OkHttpClient delegate = new OkHttpClient(okHttpClient);
 		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancedRetryFactory,
-				loadBalancerClientFactory, transformers);
+				properties, loadBalancerClientFactory);
 	}
 
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/RetryableFeignBlockingLoadBalancerClient.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2023 the original author or authors.
+ * Copyright 2013-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.
@@ -20,7 +20,6 @@ import java.io.IOException;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -66,9 +65,6 @@ import static org.springframework.cloud.openfeign.loadbalancer.LoadBalancerUtils
  * load-balanced with Spring Cloud LoadBalancer.
  *
  * @author Olga Maciaszek-Sharma
- * @author changjin wei(魏昌进)
- * @author Wonsik Cheung
- * @author Andriy Pikozh
  * @since 2.2.6
  */
 @SuppressWarnings({ "rawtypes", "unchecked" })
@@ -82,47 +78,18 @@ public class RetryableFeignBlockingLoadBalancerClient implements Client {
 
 	private final LoadBalancedRetryFactory loadBalancedRetryFactory;
 
-	private final LoadBalancerClientFactory loadBalancerClientFactory;
+	private final LoadBalancerProperties properties;
 
-	private final List<LoadBalancerFeignRequestTransformer> transformers;
+	private final LoadBalancerClientFactory loadBalancerClientFactory;
 
-	/**
-	 * @deprecated in favour of
-	 * {@link RetryableFeignBlockingLoadBalancerClient#RetryableFeignBlockingLoadBalancerClient(Client, LoadBalancerClient, LoadBalancedRetryFactory, LoadBalancerClientFactory, List)}
-	 */
-	@Deprecated
 	public RetryableFeignBlockingLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient,
 			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerProperties properties,
 			LoadBalancerClientFactory loadBalancerClientFactory) {
 		this.delegate = delegate;
 		this.loadBalancerClient = loadBalancerClient;
 		this.loadBalancedRetryFactory = loadBalancedRetryFactory;
+		this.properties = properties;
 		this.loadBalancerClientFactory = loadBalancerClientFactory;
-		this.transformers = Collections.emptyList();
-	}
-
-	/**
-	 * @deprecated in favour of
-	 * {@link RetryableFeignBlockingLoadBalancerClient#RetryableFeignBlockingLoadBalancerClient(Client, LoadBalancerClient, LoadBalancedRetryFactory, LoadBalancerClientFactory, List)}
-	 */
-	@Deprecated
-	public RetryableFeignBlockingLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient,
-			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory) {
-		this.delegate = delegate;
-		this.loadBalancerClient = loadBalancerClient;
-		this.loadBalancedRetryFactory = loadBalancedRetryFactory;
-		this.loadBalancerClientFactory = loadBalancerClientFactory;
-		this.transformers = Collections.emptyList();
-	}
-
-	public RetryableFeignBlockingLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient,
-			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancerFeignRequestTransformer> transformers) {
-		this.delegate = delegate;
-		this.loadBalancerClient = loadBalancerClient;
-		this.loadBalancedRetryFactory = loadBalancedRetryFactory;
-		this.loadBalancerClientFactory = loadBalancerClientFactory;
-		this.transformers = transformers;
 	}
 
 	@Override
@@ -145,9 +112,10 @@ public class RetryableFeignBlockingLoadBalancerClient implements Client {
 					new RetryableRequestContext(null, buildRequestData(request), hint));
 			// On retries the policy will choose the server and set it in the context
 			// and extract the server and update the request being made
-			if (context instanceof LoadBalancedRetryContext lbContext) {
-				retrievedServiceInstance = lbContext.getServiceInstance();
-				if (retrievedServiceInstance == null) {
+			if (context instanceof LoadBalancedRetryContext) {
+				LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext) context;
+				ServiceInstance serviceInstance = lbContext.getServiceInstance();
+				if (serviceInstance == null) {
 					if (LOG.isDebugEnabled()) {
 						LOG.debug("Service instance retrieved from LoadBalancedRetryContext: was null. "
 								+ "Reattempting service instance selection");
@@ -180,12 +148,11 @@ public class RetryableFeignBlockingLoadBalancerClient implements Client {
 					}
 					String reconstructedUrl = loadBalancerClient.reconstructURI(retrievedServiceInstance, originalUri)
 							.toString();
-					feignRequest = buildRequest(request, reconstructedUrl, retrievedServiceInstance);
+					feignRequest = buildRequest(request, reconstructedUrl);
 				}
 			}
 			org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(
 					retrievedServiceInstance);
-			LoadBalancerProperties loadBalancerProperties = loadBalancerClientFactory.getProperties(serviceId);
 			Response response = LoadBalancerUtils.executeWithLoadBalancerLifecycleProcessing(delegate, options,
 					feignRequest, lbRequest, lbResponse, supportedLifecycleProcessors,
 					retrievedServiceInstance != null);
@@ -214,16 +181,6 @@ public class RetryableFeignBlockingLoadBalancerClient implements Client {
 				request.charset(), request.requestTemplate());
 	}
 
-	protected Request buildRequest(Request request, String reconstructedUrl, ServiceInstance instance) {
-		Request newRequest = buildRequest(request, reconstructedUrl);
-		if (transformers != null) {
-			for (LoadBalancerFeignRequestTransformer transformer : transformers) {
-				newRequest = transformer.transformRequest(newRequest, instance);
-			}
-		}
-		return newRequest;
-	}
-
 	private RetryTemplate buildRetryTemplate(String serviceId, Request request, LoadBalancedRetryPolicy retryPolicy) {
 		RetryTemplate retryTemplate = new RetryTemplate();
 		BackOffPolicy backOffPolicy = this.loadBalancedRetryFactory.createBackOffPolicy(serviceId);
@@ -233,10 +190,8 @@ public class RetryableFeignBlockingLoadBalancerClient implements Client {
 			retryTemplate.setListeners(retryListeners);
 		}
 
-		retryTemplate.setRetryPolicy(
-				!loadBalancerClientFactory.getProperties(serviceId).getRetry().isEnabled() || retryPolicy == null
-						? new NeverRetryPolicy() : new InterceptorRetryPolicy(toHttpRequest(request), retryPolicy,
-								loadBalancerClient, serviceId));
+		retryTemplate.setRetryPolicy(retryPolicy == null ? new NeverRetryPolicy()
+				: new InterceptorRetryPolicy(toHttpRequest(request), retryPolicy, loadBalancerClient, serviceId));
 		return retryTemplate;
 	}
 
@@ -249,7 +204,12 @@ public class RetryableFeignBlockingLoadBalancerClient implements Client {
 		return new HttpRequest() {
 			@Override
 			public HttpMethod getMethod() {
-				return HttpMethod.valueOf(request.httpMethod().name());
+				return HttpMethod.resolve(request.httpMethod().name());
+			}
+
+			@Override
+			public String getMethodValue() {
+				return getMethod().name();
 			}
 
 			@Override
@@ -272,7 +232,6 @@ public class RetryableFeignBlockingLoadBalancerClient implements Client {
 	}
 
 	private String getHint(String serviceId) {
-		LoadBalancerProperties properties = loadBalancerClientFactory.getProperties(serviceId);
 		String defaultHint = properties.getHint().getOrDefault("default", "default");
 		String hintPropertyValue = properties.getHint().get(serviceId);
 		return hintPropertyValue != null ? hintPropertyValue : defaultHint;

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/loadbalancer/XForwardedHeadersTransformer.java

@@ -1,63 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.loadbalancer;
-
-import java.net.URI;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-import feign.Request;
-
-import org.springframework.cloud.client.ServiceInstance;
-import org.springframework.cloud.client.loadbalancer.LoadBalancerProperties;
-import org.springframework.cloud.client.loadbalancer.reactive.ReactiveLoadBalancer;
-
-/**
- * To add X-Forwarded-Host and X-Forwarded-Proto Headers.
- *
- * @author changjin wei(魏昌进)
- */
-public class XForwardedHeadersTransformer implements LoadBalancerFeignRequestTransformer {
-
-	private final ReactiveLoadBalancer.Factory<ServiceInstance> factory;
-
-	public XForwardedHeadersTransformer(ReactiveLoadBalancer.Factory<ServiceInstance> factory) {
-		this.factory = factory;
-	}
-
-	@Override
-	public Request transformRequest(Request request, ServiceInstance instance) {
-		if (instance == null) {
-			return request;
-		}
-		LoadBalancerProperties.XForwarded xForwarded = factory.getProperties(instance.getServiceId()).getXForwarded();
-		if (xForwarded.isEnabled()) {
-			Map<String, Collection<String>> headers = new HashMap<>(request.headers());
-			URI uri = URI.create(request.url());
-			String xForwardedHost = uri.getHost();
-			String xForwardedProto = uri.getScheme();
-			headers.put("X-Forwarded-Host", Collections.singleton(xForwardedHost));
-			headers.put("X-Forwarded-Proto", Collections.singleton(xForwardedProto));
-			request = Request.create(request.httpMethod(), request.url(), headers, request.body(), request.charset(),
-					request.requestTemplate());
-		}
-		return request;
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/security/OAuth2AccessTokenInterceptor.java

@@ -1,144 +0,0 @@
-/*
- * Copyright 2015-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.security;
-
-import java.net.URI;
-import java.util.Optional;
-
-import feign.RequestInterceptor;
-import feign.RequestTemplate;
-import feign.Target;
-
-import org.springframework.security.authentication.AnonymousAuthenticationToken;
-import org.springframework.security.core.Authentication;
-import org.springframework.security.core.authority.AuthorityUtils;
-import org.springframework.security.core.context.SecurityContextHolder;
-import org.springframework.security.oauth2.client.OAuth2AuthorizeRequest;
-import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
-import org.springframework.security.oauth2.client.OAuth2AuthorizedClientManager;
-import org.springframework.security.oauth2.core.OAuth2AccessToken;
-import org.springframework.util.Assert;
-import org.springframework.util.StringUtils;
-
-/**
- * A {@link RequestInterceptor} for OAuth2 Feign Requests. By default, it uses the
- * {@link OAuth2AuthorizedClientManager } to get {@link OAuth2AuthorizedClient } that
- * holds an {@link OAuth2AccessToken }. If the user has specified an OAuth2
- * {@code clientRegistrationId} using the
- * {@code spring.cloud.openfeign.oauth2.clientRegistrationId} property, it will be used to
- * retrieve the token. If the token is not retrieved or the {@code clientRegistrationId}
- * has not been specified, the {@code serviceId} retrieved from the {@code url} host
- * segment will be used. This approach is convenient for load-balanced Feign clients. For
- * non-load-balanced ones, the property-based {@code clientRegistrationId} is a suitable
- * approach.
- *
- * @author Dangzhicairang(小水牛)
- * @author Olga Maciaszek-Sharma
- * @since 4.0.0
- */
-public class OAuth2AccessTokenInterceptor implements RequestInterceptor {
-
-	/**
-	 * The name of the token.
-	 */
-	public static final String BEARER = "Bearer";
-
-	/**
-	 * The name of the header.
-	 */
-	public static final String AUTHORIZATION = "Authorization";
-
-	private final String tokenType;
-
-	private final String header;
-
-	private final String clientRegistrationId;
-
-	private final OAuth2AuthorizedClientManager authorizedClientManager;
-
-	private static final Authentication ANONYMOUS_AUTHENTICATION = new AnonymousAuthenticationToken("anonymous",
-			"anonymousUser", AuthorityUtils.createAuthorityList("ROLE_ANONYMOUS"));
-
-	public OAuth2AccessTokenInterceptor(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
-		this(null, oAuth2AuthorizedClientManager);
-	}
-
-	public OAuth2AccessTokenInterceptor(String clientRegistrationId,
-			OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
-		this(BEARER, AUTHORIZATION, clientRegistrationId, oAuth2AuthorizedClientManager);
-	}
-
-	public OAuth2AccessTokenInterceptor(String tokenType, String header, String clientRegistrationId,
-			OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
-		this.tokenType = tokenType;
-		this.header = header;
-		this.clientRegistrationId = clientRegistrationId;
-		this.authorizedClientManager = oAuth2AuthorizedClientManager;
-	}
-
-	@Override
-	public void apply(RequestTemplate template) {
-		OAuth2AccessToken token = getToken(template);
-		String extractedToken = String.format("%s %s", tokenType, token.getTokenValue());
-		template.header(header);
-		template.header(header, extractedToken);
-	}
-
-	public OAuth2AccessToken getToken(RequestTemplate template) {
-		// If specified, try to use them to get token.
-		if (StringUtils.hasText(clientRegistrationId)) {
-			OAuth2AccessToken token = getToken(clientRegistrationId);
-			if (token != null) {
-				return token;
-			}
-		}
-
-		// If not specified use host (synonymous with serviceId for load-balanced
-		// requests; non-load-balanced requests should use the method above).
-		OAuth2AccessToken token = getToken(getServiceId(template));
-		if (token != null) {
-			return token;
-		}
-		throw new IllegalStateException("OAuth2 token has not been successfully acquired.");
-	}
-
-	protected OAuth2AccessToken getToken(String clientRegistrationId) {
-		if (!StringUtils.hasText(clientRegistrationId)) {
-			return null;
-		}
-
-		Authentication principal = SecurityContextHolder.getContext().getAuthentication();
-		if (principal == null) {
-			principal = ANONYMOUS_AUTHENTICATION;
-		}
-
-		OAuth2AuthorizeRequest authorizeRequest = OAuth2AuthorizeRequest.withClientRegistrationId(clientRegistrationId)
-				.principal(principal).build();
-		OAuth2AuthorizedClient authorizedClient = authorizedClientManager.authorize(authorizeRequest);
-		return Optional.ofNullable(authorizedClient).map(OAuth2AuthorizedClient::getAccessToken).orElse(null);
-	}
-
-	private static String getServiceId(RequestTemplate template) {
-		Target<?> feignTarget = template.feignTarget();
-		Assert.notNull(feignTarget, "FeignTarget may not be null.");
-		String url = feignTarget.url();
-		Assert.hasLength(url, "Url may not be empty.");
-		final URI originalUri = URI.create(url);
-		return originalUri.getHost();
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/security/OAuth2FeignRequestInterceptor.java

@@ -0,0 +1,183 @@
+/*
+ * Copyright 2015-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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.openfeign.security;
+
+import java.util.Arrays;
+
+import feign.RequestInterceptor;
+import feign.RequestTemplate;
+
+import org.springframework.security.oauth2.client.OAuth2ClientContext;
+import org.springframework.security.oauth2.client.http.AccessTokenRequiredException;
+import org.springframework.security.oauth2.client.resource.OAuth2ProtectedResourceDetails;
+import org.springframework.security.oauth2.client.resource.UserRedirectRequiredException;
+import org.springframework.security.oauth2.client.token.AccessTokenProvider;
+import org.springframework.security.oauth2.client.token.AccessTokenProviderChain;
+import org.springframework.security.oauth2.client.token.AccessTokenRequest;
+import org.springframework.security.oauth2.client.token.grant.client.ClientCredentialsAccessTokenProvider;
+import org.springframework.security.oauth2.client.token.grant.code.AuthorizationCodeAccessTokenProvider;
+import org.springframework.security.oauth2.client.token.grant.implicit.ImplicitAccessTokenProvider;
+import org.springframework.security.oauth2.client.token.grant.password.ResourceOwnerPasswordAccessTokenProvider;
+import org.springframework.security.oauth2.common.OAuth2AccessToken;
+
+/**
+ * Pre-defined custom RequestInterceptor for Feign Requests. It uses the
+ * {@link OAuth2ClientContext OAuth2ClientContext} provided from the environment and
+ * construct a new header on the request before it is made by Feign.
+ *
+ * @author Joao Pedro Evangelista
+ * @author Tim Ysewyn
+ * @since 3.0.0
+ */
+@Deprecated // spring-security-oauth2 reached EOL
+public class OAuth2FeignRequestInterceptor implements RequestInterceptor {
+
+	/**
+	 * The name of the token.
+	 */
+	public static final String BEARER = "Bearer";
+
+	/**
+	 * The name of the header.
+	 */
+	public static final String AUTHORIZATION = "Authorization";
+
+	private final OAuth2ClientContext oAuth2ClientContext;
+
+	private final OAuth2ProtectedResourceDetails resource;
+
+	private final String tokenType;
+
+	private final String header;
+
+	private AccessTokenProvider accessTokenProvider = new AccessTokenProviderChain(Arrays.<AccessTokenProvider>asList(
+			new AuthorizationCodeAccessTokenProvider(), new ImplicitAccessTokenProvider(),
+			new ResourceOwnerPasswordAccessTokenProvider(), new ClientCredentialsAccessTokenProvider()));
+
+	/**
+	 * Default constructor which uses the provided OAuth2ClientContext and Bearer tokens
+	 * within Authorization header.
+	 * @param oAuth2ClientContext provided context
+	 * @param resource type of resource to be accessed
+	 */
+	public OAuth2FeignRequestInterceptor(OAuth2ClientContext oAuth2ClientContext,
+			OAuth2ProtectedResourceDetails resource) {
+		this(oAuth2ClientContext, resource, BEARER, AUTHORIZATION);
+	}
+
+	/**
+	 * Fully customizable constructor for changing token type and header name, in cases of
+	 * Bearer and Authorization is not the default such as "bearer", "authorization".
+	 * @param oAuth2ClientContext current oAuth2 Context
+	 * @param resource type of resource to be accessed
+	 * @param tokenType type of token e.g. "token", "Bearer"
+	 * @param header name of the header e.g. "Authorization", "authorization"
+	 */
+	public OAuth2FeignRequestInterceptor(OAuth2ClientContext oAuth2ClientContext,
+			OAuth2ProtectedResourceDetails resource, String tokenType, String header) {
+		this.oAuth2ClientContext = oAuth2ClientContext;
+		this.resource = resource;
+		this.tokenType = tokenType;
+		this.header = header;
+	}
+
+	/**
+	 * Create a template with the header of provided name and extracted extract.
+	 *
+	 * @see RequestInterceptor#apply(RequestTemplate)
+	 */
+	@Override
+	public void apply(RequestTemplate template) {
+		template.header(header); // Clears out the header, no "clear" method available.
+		template.header(header, extract(tokenType));
+	}
+
+	/**
+	 * Extracts the token extract id the access token exists or returning an empty extract
+	 * if there is no one on the context it may occasionally causes Unauthorized response
+	 * since the token extract is empty.
+	 * @param tokenType type name of token
+	 * @return token value from context if it exists otherwise empty String
+	 */
+	protected String extract(String tokenType) {
+		OAuth2AccessToken accessToken = getToken();
+		return String.format("%s %s", tokenType, accessToken.getValue());
+	}
+
+	/**
+	 * Extract the access token within the request or try to acquire a new one by
+	 * delegating it to {@link #acquireAccessToken()}.
+	 * @return valid token
+	 */
+	public OAuth2AccessToken getToken() {
+
+		OAuth2AccessToken accessToken = oAuth2ClientContext.getAccessToken();
+		if (accessToken == null || accessToken.isExpired()) {
+			try {
+				accessToken = acquireAccessToken();
+			}
+			catch (UserRedirectRequiredException e) {
+				oAuth2ClientContext.setAccessToken(null);
+				String stateKey = e.getStateKey();
+				if (stateKey != null) {
+					Object stateToPreserve = e.getStateToPreserve();
+					if (stateToPreserve == null) {
+						stateToPreserve = "NONE";
+					}
+					oAuth2ClientContext.setPreservedState(stateKey, stateToPreserve);
+				}
+				throw e;
+			}
+		}
+		return accessToken;
+	}
+
+	/**
+	 * Try to acquire the token using a access token provider.
+	 * @return valid access token
+	 * @throws UserRedirectRequiredException in case the user needs to be redirected to an
+	 * approval page or login page
+	 */
+	protected OAuth2AccessToken acquireAccessToken() throws UserRedirectRequiredException {
+		AccessTokenRequest tokenRequest = oAuth2ClientContext.getAccessTokenRequest();
+		if (tokenRequest == null) {
+			throw new AccessTokenRequiredException(
+					"Cannot find valid context on request for resource '" + resource.getId() + "'.", resource);
+		}
+		String stateKey = tokenRequest.getStateKey();
+		if (stateKey != null) {
+			tokenRequest.setPreservedState(oAuth2ClientContext.removePreservedState(stateKey));
+		}
+		OAuth2AccessToken existingToken = oAuth2ClientContext.getAccessToken();
+		if (existingToken != null) {
+			oAuth2ClientContext.setAccessToken(existingToken);
+		}
+		OAuth2AccessToken obtainableAccessToken;
+		obtainableAccessToken = accessTokenProvider.obtainAccessToken(resource, tokenRequest);
+		if (obtainableAccessToken == null || obtainableAccessToken.getValue() == null) {
+			throw new IllegalStateException(
+					" Access token provider returned a null token, which is illegal according to the contract.");
+		}
+		oAuth2ClientContext.setAccessToken(obtainableAccessToken);
+		return obtainableAccessToken;
+	}
+
+	public void setAccessTokenProvider(AccessTokenProvider accessTokenProvider) {
+		this.accessTokenProvider = accessTokenProvider;
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/AbstractFormWriter.java

@@ -17,7 +17,6 @@
 package org.springframework.cloud.openfeign.support;
 
 import java.io.IOException;
-import java.lang.reflect.Array;
 import java.util.Iterator;
 import java.util.function.Predicate;
 
@@ -33,7 +32,6 @@ import static feign.form.ContentProcessor.CRLF;
 
 /**
  * @author Darren Foong
- * @author Wu Daifu
  */
 public abstract class AbstractFormWriter extends AbstractWriter {
 
@@ -63,18 +61,13 @@ public abstract class AbstractFormWriter extends AbstractWriter {
 	protected abstract String writeAsString(Object object) throws IOException;
 
 	private boolean isTypeOrCollection(Object object, Predicate<Object> isType) {
-		if (object == null) {
-			return false;
-		}
 		if (object.getClass().isArray()) {
-			int len = Array.getLength(object);
-			if (len > 0) {
-				Object one = Array.get(object, 0);
-				return len > 1 && one != null && isType.test(one);
-			}
-			return false;
+			Object[] array = (Object[]) object;
+
+			return array.length > 1 && isType.test(array[0]);
 		}
-		else if (object instanceof Iterable<?> iterable) {
+		else if (object instanceof Iterable) {
+			Iterable<?> iterable = (Iterable<?>) object;
 			Iterator<?> iterator = iterable.iterator();
 
 			return iterator.hasNext() && isType.test(iterator.next());

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/DefaultGzipDecoder.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2013-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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.openfeign.support;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.zip.GZIPInputStream;
+
+import feign.FeignException;
+import feign.Response;
+import feign.codec.Decoder;
+
+import org.springframework.cloud.openfeign.encoding.HttpEncoding;
+
+/**
+ * When response is compressed as gzip, this decompresses and uses {@link SpringDecoder}
+ * to decode.
+ *
+ * @author Jaesik Kim
+ */
+public class DefaultGzipDecoder implements Decoder {
+
+	private Decoder decoder;
+
+	public DefaultGzipDecoder(Decoder decoder) {
+		this.decoder = decoder;
+	}
+
+	@Override
+	public Object decode(final Response response, Type type) throws IOException, FeignException {
+		Collection<String> encoding = response.headers().containsKey(HttpEncoding.CONTENT_ENCODING_HEADER)
+				? response.headers().get(HttpEncoding.CONTENT_ENCODING_HEADER) : null;
+
+		if (encoding != null) {
+			if (encoding.contains(HttpEncoding.GZIP_ENCODING)) {
+				String decompressedBody = decompress(response);
+				if (decompressedBody != null) {
+					Response decompressedResponse = response.toBuilder().body(decompressedBody.getBytes()).build();
+					return decoder.decode(decompressedResponse, type);
+				}
+			}
+		}
+		return decoder.decode(response, type);
+	}
+
+	private String decompress(Response response) throws IOException {
+		if (response.body() == null) {
+			return null;
+		}
+		try (GZIPInputStream gzipInputStream = new GZIPInputStream(response.body().asInputStream());
+				BufferedReader reader = new BufferedReader(
+						new InputStreamReader(gzipInputStream, StandardCharsets.UTF_8))) {
+			String outputString = "";
+			String line;
+			while ((line = reader.readLine()) != null) {
+				outputString += line;
+			}
+			return outputString;
+		}
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/DefaultGzipDecoderConfiguration.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2013-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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.openfeign.support;
+
+import feign.codec.Decoder;
+import feign.optionals.OptionalDecoder;
+
+import org.springframework.beans.factory.ObjectFactory;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
+import org.springframework.cloud.openfeign.FeignAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Configures Default Gzip Decoder.
+ *
+ * @author Jaesik Kim
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnProperty("feign.compression.response.enabled")
+// The OK HTTP client uses "transparent" compression.
+// If the accept-encoding header is present, it disables transparent compression
+@ConditionalOnMissingBean(type = "okhttp3.OkHttpClient")
+@AutoConfigureAfter(FeignAutoConfiguration.class)
+public class DefaultGzipDecoderConfiguration {
+
+	private ObjectFactory<HttpMessageConverters> messageConverters;
+
+	public DefaultGzipDecoderConfiguration(ObjectFactory<HttpMessageConverters> messageConverters) {
+		this.messageConverters = messageConverters;
+	}
+
+	@Bean
+	@ConditionalOnMissingBean
+	@ConditionalOnProperty("feign.compression.response.useGzipDecoder")
+	public Decoder defaultGzipDecoder() {
+		return new OptionalDecoder(
+				new ResponseEntityDecoder(new DefaultGzipDecoder(new SpringDecoder(messageConverters))));
+	}
+
+}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/EmptyObjectProvider.java

@@ -1,54 +0,0 @@
-/*
- * Copyright 2013-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.support;
-
-import java.util.function.Consumer;
-
-import org.springframework.beans.BeansException;
-import org.springframework.beans.factory.ObjectProvider;
-
-/**
- * @author Olga Maciaszek-Sharma
- */
-class EmptyObjectProvider<T> implements ObjectProvider<T> {
-
-	@Override
-	public T getObject(Object... args) throws BeansException {
-		return null;
-	}
-
-	@Override
-	public T getIfAvailable() throws BeansException {
-		return null;
-	}
-
-	@Override
-	public T getIfUnique() throws BeansException {
-		return null;
-	}
-
-	@Override
-	public T getObject() throws BeansException {
-		return null;
-	}
-
-	@Override
-	public void forEach(Consumer action) {
-		// do nothing
-	}
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/FeignEncoderProperties.java

@@ -24,7 +24,7 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
  * @author Olga Maciaszek-Sharma
  * @since 2.2.8
  */
-@ConfigurationProperties("spring.cloud.openfeign.encoder")
+@ConfigurationProperties("feign.encoder")
 public class FeignEncoderProperties {
 
 	/**

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/FeignHttpClientProperties.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2023 the original author or authors.
+ * Copyright 2013-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.
@@ -16,24 +16,15 @@
 
 package org.springframework.cloud.openfeign.support;
 
-import java.net.http.HttpClient;
-import java.time.Duration;
-import java.util.List;
 import java.util.concurrent.TimeUnit;
 
-import feign.http2client.Http2Client;
-import feign.okhttp.OkHttpClient;
-import okhttp3.Protocol;
-
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
 /**
  * @author Ryan Baxter
  * @author Nguyen Ky Thanh
- * @author Olga Maciaszek-Sharma
- * @author changjin wei(魏昌进)
  */
-@ConfigurationProperties(prefix = "spring.cloud.openfeign.httpclient")
+@ConfigurationProperties(prefix = "feign.httpclient")
 public class FeignHttpClientProperties {
 
 	/**
@@ -97,18 +88,8 @@ public class FeignHttpClientProperties {
 	 */
 	private Hc5Properties hc5 = new Hc5Properties();
 
-	/**
-	 * Additional {@link OkHttpClient}-specific properties.
-	 */
-	private OkHttp okHttp = new OkHttp();
-
-	/**
-	 * Additional {@link Http2Client}-specific properties.
-	 */
-	private Http2Properties http2 = new Http2Properties();
-
 	public int getConnectionTimerRepeat() {
-		return connectionTimerRepeat;
+		return this.connectionTimerRepeat;
 	}
 
 	public void setConnectionTimerRepeat(int connectionTimerRepeat) {
@@ -116,7 +97,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public boolean isDisableSslValidation() {
-		return disableSslValidation;
+		return this.disableSslValidation;
 	}
 
 	public void setDisableSslValidation(boolean disableSslValidation) {
@@ -124,7 +105,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public int getMaxConnections() {
-		return maxConnections;
+		return this.maxConnections;
 	}
 
 	public void setMaxConnections(int maxConnections) {
@@ -132,7 +113,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public int getMaxConnectionsPerRoute() {
-		return maxConnectionsPerRoute;
+		return this.maxConnectionsPerRoute;
 	}
 
 	public void setMaxConnectionsPerRoute(int maxConnectionsPerRoute) {
@@ -140,7 +121,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public long getTimeToLive() {
-		return timeToLive;
+		return this.timeToLive;
 	}
 
 	public void setTimeToLive(long timeToLive) {
@@ -148,7 +129,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public TimeUnit getTimeToLiveUnit() {
-		return timeToLiveUnit;
+		return this.timeToLiveUnit;
 	}
 
 	public void setTimeToLiveUnit(TimeUnit timeToLiveUnit) {
@@ -156,7 +137,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public boolean isFollowRedirects() {
-		return followRedirects;
+		return this.followRedirects;
 	}
 
 	public void setFollowRedirects(boolean followRedirects) {
@@ -164,7 +145,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public int getConnectionTimeout() {
-		return connectionTimeout;
+		return this.connectionTimeout;
 	}
 
 	public void setConnectionTimeout(int connectionTimeout) {
@@ -179,22 +160,6 @@ public class FeignHttpClientProperties {
 		this.hc5 = hc5;
 	}
 
-	public OkHttp getOkHttp() {
-		return okHttp;
-	}
-
-	public void setOkHttp(OkHttp okHttp) {
-		this.okHttp = okHttp;
-	}
-
-	public Http2Properties getHttp2() {
-		return http2;
-	}
-
-	public void setHttp2(Http2Properties http2) {
-		this.http2 = http2;
-	}
-
 	public static class Hc5Properties {
 
 		/**
@@ -217,16 +182,6 @@ public class FeignHttpClientProperties {
 		 */
 		public static final TimeUnit DEFAULT_SOCKET_TIMEOUT_UNIT = TimeUnit.SECONDS;
 
-		/**
-		 * Default value for connection request timeout.
-		 */
-		public static final int DEFAULT_CONNECTION_REQUEST_TIMEOUT = 3;
-
-		/**
-		 * Default value for connection request timeout unit.
-		 */
-		public static final TimeUnit DEFAULT_CONNECTION_REQUEST_TIMEOUT_UNIT = TimeUnit.MINUTES;
-
 		/**
 		 * Pool concurrency policies.
 		 */
@@ -247,18 +202,8 @@ public class FeignHttpClientProperties {
 		 */
 		private TimeUnit socketTimeoutUnit = DEFAULT_SOCKET_TIMEOUT_UNIT;
 
-		/**
-		 * Default value for connection request timeout.
-		 */
-		private int connectionRequestTimeout = DEFAULT_CONNECTION_REQUEST_TIMEOUT;
-
-		/**
-		 * Default value for connection request timeout unit.
-		 */
-		private TimeUnit connectionRequestTimeoutUnit = DEFAULT_CONNECTION_REQUEST_TIMEOUT_UNIT;
-
 		public PoolConcurrencyPolicy getPoolConcurrencyPolicy() {
-			return poolConcurrencyPolicy;
+			return this.poolConcurrencyPolicy;
 		}
 
 		public void setPoolConcurrencyPolicy(PoolConcurrencyPolicy poolConcurrencyPolicy) {
@@ -289,22 +234,6 @@ public class FeignHttpClientProperties {
 			this.socketTimeout = socketTimeout;
 		}
 
-		public int getConnectionRequestTimeout() {
-			return connectionRequestTimeout;
-		}
-
-		public void setConnectionRequestTimeout(int connectionRequestTimeout) {
-			this.connectionRequestTimeout = connectionRequestTimeout;
-		}
-
-		public TimeUnit getConnectionRequestTimeoutUnit() {
-			return connectionRequestTimeoutUnit;
-		}
-
-		public void setConnectionRequestTimeoutUnit(TimeUnit connectionRequestTimeoutUnit) {
-			this.connectionRequestTimeoutUnit = connectionRequestTimeoutUnit;
-		}
-
 		/**
 		 * Enumeration of pool concurrency policies.
 		 */
@@ -343,59 +272,4 @@ public class FeignHttpClientProperties {
 
 	}
 
-	/**
-	 * {@link OkHttpClient}-specific properties.
-	 */
-	public static class OkHttp {
-
-		/**
-		 * {@link OkHttpClient} read timeout; defaults to 60 seconds.
-		 */
-		private Duration readTimeout = Duration.ofSeconds(60);
-
-		/**
-		 * Configure the protocols used by this client to communicate with remote servers.
-		 * Uses {@link String} values of {@link Protocol}.
-		 */
-		private List<String> protocols = List.of("HTTP_2", "HTTP_1_1");
-
-		public Duration getReadTimeout() {
-			return readTimeout;
-		}
-
-		public void setReadTimeout(Duration readTimeout) {
-			this.readTimeout = readTimeout;
-		}
-
-		public List<String> getProtocols() {
-			return protocols;
-		}
-
-		public void setProtocols(List<String> protocols) {
-			this.protocols = protocols;
-		}
-
-	}
-
-	/**
-	 * {@link Http2Client}-specific properties.
-	 */
-	public static class Http2Properties {
-
-		/**
-		 * Configure the protocols used by this client to communicate with remote servers.
-		 * Uses {@link String} value of {@link HttpClient.Version}.
-		 */
-		private String version = "HTTP_2";
-
-		public String getVersion() {
-			return version;
-		}
-
-		public void setVersion(String version) {
-			this.version = version;
-		}
-
-	}
-
 }

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/FeignUtils.java

@@ -18,6 +18,8 @@ package org.springframework.cloud.openfeign.support;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 
 import org.springframework.http.HttpHeaders;
@@ -42,6 +44,16 @@ public final class FeignUtils {
 		return httpHeaders;
 	}
 
+	static Map<String, Collection<String>> getHeaders(HttpHeaders httpHeaders) {
+		LinkedHashMap<String, Collection<String>> headers = new LinkedHashMap<>();
+
+		for (Map.Entry<String, List<String>> entry : httpHeaders.entrySet()) {
+			headers.put(entry.getKey(), entry.getValue());
+		}
+
+		return headers;
+	}
+
 	static Collection<String> addTemplateParameter(Collection<String> possiblyNull, String paramName) {
 		Collection<String> params = ofNullable(possiblyNull).map(ArrayList::new).orElse(new ArrayList<>());
 		params.add(String.format("{%s}", paramName));

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/HttpMessageConverterCustomizer.java

@@ -1,33 +0,0 @@
-/*
- * Copyright 2016-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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.openfeign.support;
-
-import java.util.List;
-import java.util.function.Consumer;
-
-import org.springframework.http.converter.HttpMessageConverter;
-
-/**
- * Allows customising {@link HttpMessageConverter} objects passed via {@link Consumer}
- * parameter.
- *
- * @author Olga Maciaszek-Sharma
- * @since 3.1.0
- */
-public interface HttpMessageConverterCustomizer extends Consumer<List<HttpMessageConverter<?>>> {
-
-}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/PageableSpringEncoder.java

@@ -32,7 +32,6 @@ import org.springframework.data.domain.Sort;
  * Provides support for encoding spring Pageable via composition.
  *
  * @author Pascal Büttiker
- * @author Yanming Zhou
  */
 public class PageableSpringEncoder implements Encoder {
 
@@ -79,18 +78,20 @@ public class PageableSpringEncoder implements Encoder {
 	public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException {
 
 		if (supports(object)) {
-			if (object instanceof Pageable pageable) {
+			if (object instanceof Pageable) {
+				Pageable pageable = (Pageable) object;
 
 				if (pageable.isPaged()) {
-					template.query(pageParameter, String.valueOf(pageable.getPageNumber()));
-					template.query(sizeParameter, String.valueOf(pageable.getPageSize()));
+					template.query(pageParameter, pageable.getPageNumber() + "");
+					template.query(sizeParameter, pageable.getPageSize() + "");
 				}
 
 				if (pageable.getSort() != null) {
 					applySort(template, pageable.getSort());
 				}
 			}
-			else if (object instanceof Sort sort) {
+			else if (object instanceof Sort) {
+				Sort sort = (Sort) object;
 				applySort(template, sort);
 			}
 		}

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/PageableSpringQueryMapEncoder.java

@@ -31,55 +31,29 @@ import org.springframework.data.domain.Sort;
  * {@link org.springframework.cloud.openfeign.SpringQueryMap}.
  *
  * @author Hyeonmin Park
- * @author Yanming Zhou
  * @since 2.2.8
  */
 public class PageableSpringQueryMapEncoder extends BeanQueryMapEncoder {
 
-	/**
-	 * Page index parameter name.
-	 */
-	private String pageParameter = "page";
-
-	/**
-	 * Page size parameter name.
-	 */
-	private String sizeParameter = "size";
-
-	/**
-	 * Sort parameter name.
-	 */
-	private String sortParameter = "sort";
-
-	public void setPageParameter(String pageParameter) {
-		this.pageParameter = pageParameter;
-	}
-
-	public void setSizeParameter(String sizeParameter) {
-		this.sizeParameter = sizeParameter;
-	}
-
-	public void setSortParameter(String sortParameter) {
-		this.sortParameter = sortParameter;
-	}
-
 	@Override
 	public Map<String, Object> encode(Object object) {
 		if (supports(object)) {
 			Map<String, Object> queryMap = new HashMap<>();
 
-			if (object instanceof Pageable pageable) {
+			if (object instanceof Pageable) {
+				Pageable pageable = (Pageable) object;
 
 				if (pageable.isPaged()) {
-					queryMap.put(pageParameter, pageable.getPageNumber());
-					queryMap.put(sizeParameter, pageable.getPageSize());
+					queryMap.put("page", pageable.getPageNumber());
+					queryMap.put("size", pageable.getPageSize());
 				}
 
 				if (pageable.getSort() != null) {
 					applySort(queryMap, pageable.getSort());
 				}
 			}
-			else if (object instanceof Sort sort) {
+			else if (object instanceof Sort) {
+				Sort sort = (Sort) object;
 				applySort(queryMap, sort);
 			}
 			return queryMap;
@@ -95,7 +69,7 @@ public class PageableSpringQueryMapEncoder extends BeanQueryMapEncoder {
 			sortQueries.add(order.getProperty() + "%2C" + order.getDirection());
 		}
 		if (!sortQueries.isEmpty()) {
-			queryMap.put(sortParameter, sortQueries);
+			queryMap.put("sort", sortQueries);
 		}
 	}
 

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/ResponseEntityDecoder.java

@@ -39,7 +39,7 @@ import org.springframework.http.ResponseEntity;
  */
 public class ResponseEntityDecoder implements Decoder {
 
-	private final Decoder decoder;
+	private Decoder decoder;
 
 	public ResponseEntityDecoder(Decoder decoder) {
 		this.decoder = decoder;
@@ -70,7 +70,8 @@ public class ResponseEntityDecoder implements Decoder {
 	}
 
 	private boolean isHttpEntity(Type type) {
-		if (type instanceof Class c) {
+		if (type instanceof Class) {
+			Class c = (Class) type;
 			return HttpEntity.class.isAssignableFrom(c);
 		}
 		return false;

spring-cloud-openfeign-core/src/main/java/org/springframework/cloud/openfeign/support/SpringDecoder.java

@@ -21,7 +21,6 @@ import java.io.InputStream;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.WildcardType;
-import java.util.List;
 
 import feign.FeignException;
 import feign.Response;
@@ -29,48 +28,31 @@ import feign.codec.DecodeException;
 import feign.codec.Decoder;
 
 import org.springframework.beans.factory.ObjectFactory;
-import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.client.ClientHttpResponse;
-import org.springframework.http.converter.HttpMessageConverter;
 import org.springframework.web.client.HttpMessageConverterExtractor;
 
 import static org.springframework.cloud.openfeign.support.FeignUtils.getHttpHeaders;
 
 /**
  * @author Spencer Gibb
- * @author Olga Maciaszek-Sharma
  */
 public class SpringDecoder implements Decoder {
 
-	private final ObjectFactory<HttpMessageConverters> messageConverters;
+	private ObjectFactory<HttpMessageConverters> messageConverters;
 
-	private final ObjectProvider<HttpMessageConverterCustomizer> customizers;
-
-	/**
-	 * @deprecated in favour of
-	 * {@link SpringDecoder#SpringDecoder(ObjectFactory, ObjectProvider)}
-	 */
-	@Deprecated
 	public SpringDecoder(ObjectFactory<HttpMessageConverters> messageConverters) {
-		this(messageConverters, new EmptyObjectProvider<>());
-	}
-
-	public SpringDecoder(ObjectFactory<HttpMessageConverters> messageConverters,
-			ObjectProvider<HttpMessageConverterCustomizer> customizers) {
 		this.messageConverters = messageConverters;
-		this.customizers = customizers;
 	}
 
 	@Override
 	public Object decode(final Response response, Type type) throws IOException, FeignException {
 		if (type instanceof Class || type instanceof ParameterizedType || type instanceof WildcardType) {
-			List<HttpMessageConverter<?>> converters = messageConverters.getObject().getConverters();
-			customizers.forEach(customizer -> customizer.accept(converters));
 			@SuppressWarnings({ "unchecked", "rawtypes" })
-			HttpMessageConverterExtractor<?> extractor = new HttpMessageConverterExtractor(type, converters);
+			HttpMessageConverterExtractor<?> extractor = new HttpMessageConverterExtractor(type,
+					this.messageConverters.getObject().getConverters());
 
 			return extractor.extractData(new FeignResponseAdapter(response));
 		}
@@ -87,24 +69,24 @@ public class SpringDecoder implements Decoder {
 		}
 
 		@Override
-		public HttpStatus getStatusCode() {
-			return HttpStatus.valueOf(response.status());
+		public HttpStatus getStatusCode() throws IOException {
+			return HttpStatus.valueOf(this.response.status());
 		}
 
 		@Override
-		public int getRawStatusCode() {
-			return response.status();
+		public int getRawStatusCode() throws IOException {
+			return this.response.status();
 		}
 
 		@Override
-		public String getStatusText() {
-			return response.reason();
+		public String getStatusText() throws IOException {
+			return this.response.reason();
 		}
 
 		@Override
 		public void close() {
 			try {
-				response.body().close();
+				this.response.body().close();
 			}
 			catch (IOException ex) {
 				// Ignore exception on close...
@@ -113,12 +95,12 @@ public class SpringDecoder implements Decoder {
 
 		@Override
 		public InputStream getBody() throws IOException {
-			return response.body().asInputStream();
+			return this.response.body().asInputStream();
 		}
 
 		@Override
 		public HttpHeaders getHeaders() {
-			return getHttpHeaders(response.headers());
+			return getHttpHeaders(this.response.headers());
 		}
 
 	}