Bumping versions

I found a typo in the latest release.
It should be `@FeignClient(url = "http://localhost:8080")`

.github/workflows/maven.yml

@@ -5,9 +5,9 @@ name: Build
 
 on:
   push:
-    branches: [ 2.2.x ]
+    branches: [ main ]
   pull_request:
-    branches: [ 2.2.x ]
+    branches: [ main ]
 
 jobs:
   build:
@@ -16,20 +16,18 @@ jobs:
 
     strategy:
       matrix:
-        java: ["8", "11", "16"]
+        java: ["17"]
 
     steps:
       - uses: actions/checkout@v2
-      - name: Set up JDK 1.8
+      - name: Set up JDK ${{ matrix.java }}
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v2
         with:
-          java-version: 1.8
+          distribution: 'zulu'
-      - name: Cache local Maven repository
+          java-version: ${{ matrix.java }}
-        uses: actions/cache@v2
+          cache: 'maven'
-        with:
-          path: ~/.m2/repository
-          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
-          restore-keys: |
-            ${{ runner.os }}-maven-
       - name: Build with Maven
-        run: ./mvnw clean install -B -U
+        run: ./mvnw clean install -B -U -P sonar
+      - uses: codecov/codecov-action@v1
+        with:
+          fail_ci_if_error: true

.gitignore

@@ -20,5 +20,4 @@ _site/
 *.swo
 .vscode/
 .flattened-pom.xml
-.sdkmanrc
 

.sdkmanrc

@@ -0,0 +1,3 @@
+# 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

@@ -5,7 +5,7 @@ Edit the files in the src/main/asciidoc/ directory instead.
 ////
 
 
-image::https://github.com/spring-cloud/spring-cloud-openfeign/workflows/Build/badge.svg?branch=2.2.x&style=svg["Build",link="https://github.com/spring-cloud/spring-cloud-openfeign/actions"]
+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://codecov.io/gh/spring-cloud/spring-cloud-openfeign"]
 
@@ -40,7 +40,8 @@ and binding to the Spring Environment and other Spring programming model idioms.
 
 == Building
 
-:jdkversion: 1.8
+
+:jdkversion: 17
 
 === Basic Compile and Test
 
@@ -66,23 +67,9 @@ the `.mvn` configuration, so if you find you have to do it to make a
 build succeed, please raise a ticket to get the settings added to
 source control.
 
-For hints on how to build the project look in `.travis.yml` if there
+The projects that require middleware (i.e. Redis) for testing generally
-is one. There should be a "script" and maybe "install" command. Also
+require that a local instance of [Docker](https://www.docker.com/get-started) is installed and running.
-look at the "services" section to see if any services need to be
-running locally (e.g. mongo or rabbit).  Ignore the git-related bits
-that you might find in "before_install" since they're related to setting git
-credentials and you already have those.
 
-The projects that require middleware generally include a
-`docker-compose.yml`, so consider using
-https://docs.docker.com/compose/[Docker Compose] to run the middeware servers
-in Docker containers. See the README in the
-https://github.com/spring-cloud-samples/scripts[scripts demo
-repository] for specific instructions about the common cases of mongo,
-rabbit and redis.
-
-NOTE: If all else fails, build with the command from `.travis.yml` (usually
-`./mvnw install`).
 
 === Documentation
 
@@ -317,6 +304,57 @@ Go to `File` -> `Settings` -> `Other settings` -> `Checkstyle`. There click on t
 
 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
 
 The project license file is available https://raw.githubusercontent.com/spring-cloud/spring-cloud-openfeign/main/LICENSE.txt[here].

docs/pom.xml

@@ -6,10 +6,10 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.2.9.RELEASE</version>
+		<version>4.0.0-SNAPSHOT</version>
 	</parent>
 	<artifactId>spring-cloud-openfeign-docs</artifactId>
-	<packaging>pom</packaging>
+	<packaging>jar</packaging>
 	<name>Spring Cloud OpenFeign Docs</name>
 	<description>Spring Cloud Docs</description>
 	<properties>
@@ -17,6 +17,8 @@
 		<main.basedir>${basedir}/..</main.basedir>
 		<configprops.inclusionPattern>feign.*</configprops.inclusionPattern>
 		<upload-docs-zip.phase>deploy</upload-docs-zip.phase>
+		<!-- Don't upload docs jar to central / repo.spring.io -->
+		<maven-deploy-plugin-default.phase>none</maven-deploy-plugin-default.phase>
 	</properties>
 	<dependencies>
 		<dependency>
@@ -24,6 +26,9 @@
 			<artifactId>spring-cloud-starter-openfeign</artifactId>
 		</dependency>
 	</dependencies>
+	<build>
+		<sourceDirectory>src/main/asciidoc</sourceDirectory>
+	</build>
 	<profiles>
 		<profile>
 			<id>docs</id>
@@ -34,9 +39,11 @@
 						<artifactId>git-commit-id-plugin</artifactId>
 					</plugin>
 					<plugin>
+						<groupId>org.apache.maven.plugins</groupId>
 						<artifactId>maven-dependency-plugin</artifactId>
 					</plugin>
 					<plugin>
+						<groupId>org.apache.maven.plugins</groupId>
 						<artifactId>maven-resources-plugin</artifactId>
 					</plugin>
 					<plugin>
@@ -48,6 +55,7 @@
 						<artifactId>asciidoctor-maven-plugin</artifactId>
 					</plugin>
 					<plugin>
+						<groupId>org.apache.maven.plugins</groupId>
 						<artifactId>maven-antrun-plugin</artifactId>
 					</plugin>
 					<plugin>

docs/src/main/asciidoc/README.adoc

@@ -1,4 +1,4 @@
-image::https://github.com/spring-cloud/spring-cloud-openfeign/workflows/Build/badge.svg?branch=2.2.x&style=svg["Build",link="https://github.com/spring-cloud/spring-cloud-openfeign/actions"]
+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://codecov.io/gh/spring-cloud/spring-cloud-openfeign"]
 

docs/src/main/asciidoc/_configprops.adoc

@@ -1,33 +1,37 @@
 |===
 |Name | Default | Description
 
-|feign.autoconfiguration.jackson.enabled | `false` | If true, PageJacksonModule and SortJacksonModule bean will be provided for Jackson page decoding.
+|spring.cloud.openfeign.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.
+|spring.cloud.openfeign.circuitbreaker.enabled | `false` | If true, an OpenFeign client will be wrapped with a Spring Cloud CircuitBreaker circuit breaker.
-|feign.client.config |  | 
+|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.
-|feign.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.config |  | 
-|feign.client.default-config | `default` | 
+|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`.
-|feign.client.default-to-properties | `true` | 
+|spring.cloud.openfeign.client.default-config | `default` | 
-|feign.compression.request.enabled | `false` | Enables the request sent by Feign to be compressed.
+|spring.cloud.openfeign.client.default-to-properties | `true` | 
-|feign.compression.request.mime-types | `[text/xml, application/xml, application/json]` | The list of supported mime types.
+|spring.cloud.openfeign.client.refresh-enabled | `false` | Enables options value refresh capability for Feign.
-|feign.compression.request.min-request-size | `2048` | The minimum threshold content size.
+|spring.cloud.openfeign.compression.request.enabled | `false` | Enables the request sent by Feign to be compressed.
-|feign.compression.response.enabled | `false` | Enables the response from Feign to be compressed.
+|spring.cloud.openfeign.compression.request.mime-types | `[text/xml, application/xml, application/json]` | The list of supported mime types.
-|feign.compression.response.useGzipDecoder | `false` | Enables the default gzip decoder to be used.
+|spring.cloud.openfeign.compression.request.min-request-size | `2048` | The minimum threshold content size.
-|feign.encoder.charset-from-content-type | `false` | Indicates whether the charset should be derived from the {@code Content-Type} header.
+|spring.cloud.openfeign.compression.response.enabled | `false` | Enables the response from Feign to be compressed.
-|feign.httpclient.connection-timeout | `2000` | 
+|spring.cloud.openfeign.encoder.charset-from-content-type | `false` | Indicates whether the charset should be derived from the {@code Content-Type} header.
-|feign.httpclient.connection-timer-repeat | `3000` | 
+|spring.cloud.openfeign.httpclient.connection-timeout | `2000` | 
-|feign.httpclient.disable-ssl-validation | `false` | 
+|spring.cloud.openfeign.httpclient.connection-timer-repeat | `3000` | 
-|feign.httpclient.enabled | `true` | Enables the use of the Apache HTTP Client by Feign.
+|spring.cloud.openfeign.httpclient.disable-ssl-validation | `false` | 
-|feign.httpclient.follow-redirects | `true` | 
+|spring.cloud.openfeign.httpclient.enabled | `true` | Enables the use of the Apache HTTP Client by Feign.
-|feign.httpclient.hc5.enabled | `false` | Enables the use of the Apache HTTP Client 5 by Feign.
+|spring.cloud.openfeign.httpclient.follow-redirects | `true` | 
-|feign.httpclient.hc5.pool-concurrency-policy |  | Pool concurrency policies.
+|spring.cloud.openfeign.httpclient.hc5.enabled | `false` | Enables the use of the Apache HTTP Client 5 by Feign.
-|feign.httpclient.hc5.pool-reuse-policy |  | Pool connection re-use policies.
+|spring.cloud.openfeign.httpclient.hc5.pool-concurrency-policy |  | Pool concurrency policies.
-|feign.httpclient.hc5.socket-timeout | `5` | Default value for socket timeout.
+|spring.cloud.openfeign.httpclient.hc5.pool-reuse-policy |  | Pool connection re-use policies.
-|feign.httpclient.hc5.socket-timeout-unit |  | Default value for socket timeout unit.
+|spring.cloud.openfeign.httpclient.hc5.socket-timeout | `5` | Default value for socket timeout.
-|feign.httpclient.max-connections | `200` | 
+|spring.cloud.openfeign.httpclient.hc5.socket-timeout-unit |  | Default value for socket timeout unit.
-|feign.httpclient.max-connections-per-route | `50` | 
+|spring.cloud.openfeign.httpclient.max-connections | `200` | 
-|feign.httpclient.time-to-live | `900` | 
+|spring.cloud.openfeign.httpclient.max-connections-per-route | `50` | 
-|feign.httpclient.time-to-live-unit |  | 
+|spring.cloud.openfeign.httpclient.ok-http.read-timeout | `60s` | {@link OkHttpClient} read timeout; defaults to 60 seconds.
-|feign.hystrix.enabled | `false` | If true, an OpenFeign client will be wrapped with a Hystrix circuit breaker.
+|spring.cloud.openfeign.httpclient.time-to-live | `900` | 
-|feign.okhttp.enabled | `false` | Enables the use of the OK HTTP Client by Feign.
+|spring.cloud.openfeign.httpclient.time-to-live-unit |  | 
+|spring.cloud.openfeign.metrics.enabled | `true` | Enables metrics capability for Feign.
+|spring.cloud.openfeign.oauth2.enabled | `false` | Enables feign interceptor for managing oauth2 access token.
+|spring.cloud.openfeign.oauth2.load-balanced | `false` | Enables load balancing for oauth2 access token provider.
+|spring.cloud.openfeign.okhttp.enabled | `false` | Enables the use of the OK HTTP Client by Feign.
 
 |===

docs/src/main/asciidoc/index.adoc

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

docs/src/main/asciidoc/index.adoc

@@ -0,0 +1 @@
+include::spring-cloud-openfeign.adoc[]

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

@@ -15,7 +15,7 @@ To use Feign create an interface and annotate it.
 It has pluggable annotation support including Feign annotations and JAX-RS annotations.
 Feign also supports pluggable encoders and decoders.
 Spring Cloud adds support for Spring MVC annotations and for using the same `HttpMessageConverters` used by default in Spring Web.
-Spring Cloud integrates Ribbon and Eureka, Spring Cloud CircuitBreaker, as well as Spring Cloud LoadBalancer to provide a load-balanced http client when using Feign.
+Spring Cloud integrates Eureka, Spring Cloud CircuitBreaker, as well as Spring Cloud LoadBalancer to provide a load-balanced http client when using Feign.
 
 [[netflix-feign-starter]]
 === How to Include Feign
@@ -52,10 +52,13 @@ 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);
 }
 ----
 
-In the `@FeignClient` annotation the String value ("stores" above) is an arbitrary client name, which is used to create either a https://github.com/Netflix/ribbon[Ribbon] load-balancer (see <<spring-cloud-ribbon,below for details of Ribbon support>> and <<spring-cloud-circuitbreaker,below for details of Spring Cloud CircuitBreaker support>>) or https://github.com/spring-cloud/spring-cloud-commons/blob/main/spring-cloud-commons/src/main/java/org/springframework/cloud/client/loadbalancer/reactive/ReactiveLoadBalancer.java[Spring Cloud LoadBalancer].
+In the `@FeignClient` annotation the String value ("stores" above) is an arbitrary client name, which is used to create a https://github.com/spring-cloud/spring-cloud-commons/blob/main/spring-cloud-loadbalancer/src/main/java/org/springframework/cloud/loadbalancer/blocking/client/BlockingLoadBalancerClient.java[Spring Cloud LoadBalancer client].
 You can also specify a URL using the `url` attribute
 (absolute value or just a hostname). The name of the bean in the
 application context is the fully qualified name of the interface.
@@ -65,12 +68,15 @@ of the `@FeignClient` annotation.
 The load-balancer client above will want to discover the physical addresses
 for the "stores" service. If your application is a Eureka client then
 it will resolve the service in the Eureka service registry. If you
-don't want to use Eureka, you can simply configure a list of servers
+don't want to use Eureka, you can configure a list of servers
-in your external configuration using https://cloud.spring.io/spring-cloud-static/spring-cloud-commons/current/reference/html/#simplediscoveryclient[`SimpleDiscoveryClient`].
+in your external configuration using https://docs.spring.io/spring-cloud-commons/docs/current/reference/html/#simplediscoveryclient[`SimpleDiscoveryClient`].
 
-WARNING: In order to maintain backward compatibility, is used as the default load-balancer implementation.
+Spring Cloud OpenFeign supports all the features available for the blocking mode of Spring Cloud LoadBalancer. You can read more about them in the https://docs.spring.io/spring-cloud-commons/docs/current/reference/html/#spring-cloud-loadbalancer[project documentation].
-However, Spring Cloud Netflix Ribbon is now in maintenance mode, so we recommend using Spring Cloud LoadBalancer instead.
+
-To do this, set the value of `spring.cloud.loadbalancer.ribbon.enabled` to `false`.
+TIP: To use `@EnableFeignClients` annotation on `@Configuration`-annotated-classes, make sure to specify where the clients are located, for example:
+`@EnableFeignClients(basePackages = "com.example.clients")`
+or list them explicitly:
+`@EnableFeignClients(clients = InventoryServiceFeignClient.class)`
 
 [[spring-cloud-feign-overriding-defaults]]
 === Overriding Feign Defaults
@@ -94,8 +100,6 @@ In this case the client is composed from the components already in `FeignClients
 
 NOTE: `FooConfiguration` does not need to be annotated with `@Configuration`. However, if it is, then take care to exclude it from any `@ComponentScan` that would otherwise include this configuration as it will become the default source for `feign.Decoder`, `feign.Encoder`, `feign.Contract`, etc., when specified. This can be avoided by putting it in a separate, non-overlapping package from any `@ComponentScan` or `@SpringBootApplication`, or it can be explicitly excluded in `@ComponentScan`.
 
-NOTE: The `serviceId` attribute is now deprecated in favor of the `name` attribute.
-
 NOTE: Using `contextId` attribute of the `@FeignClient` annotation in addition to changing the name of
 the `ApplicationContext` ensemble, it will override the alias of the client name
 and it will be used as part of the name of the configuration bean created for that client.
@@ -117,15 +121,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`
+* `MicrometerCapability` micrometerCapability: If `feign-micrometer` is on the classpath and `MeterRegistry` is available
+* `CachingCapability` cachingCapability: If `@EnableCaching` annotation is used. Can be disabled via `spring.cloud.openfeign.cache.enabled`.
 * `Contract` feignContract: `SpringMvcContract`
-* `Feign.Builder` feignBuilder: `HystrixFeign.Builder`
 * `Feign.Builder` feignBuilder: `FeignCircuitBreaker.Builder`
-* `Client` feignClient: if Ribbon is in the classpath and is enabled it is a `LoadBalancerFeignClient`, otherwise if Spring Cloud LoadBalancer is in the classpath, `FeignBlockingLoadBalancerClient` is used.
+* `Client` feignClient: If Spring Cloud LoadBalancer is on the classpath, `FeignBlockingLoadBalancerClient` is used.
-If none of them is in the classpath, the default feign client is used.
+If none of them is on the classpath, the default feign client is used.
 
-NOTE: `spring-cloud-starter-openfeign` supports both `spring-cloud-starter-netflix-ribbon` and `spring-cloud-starter-loadbalancer`. However, as they are optional dependencies, you need to make sure the one you want to use has been added to your project.
+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.
 
-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.
+The OkHttpClient and ApacheHttpClient and ApacheHC5 feign clients can be used by setting `spring.cloud.openfeign.okhttp.enabled` or `spring.cloud.openfeign.httpclient.enabled` or `spring.cloud.openfeign.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:
@@ -137,6 +142,7 @@ Spring Cloud OpenFeign _does not_ provide the following beans by default for fei
 * `Collection<RequestInterceptor>`
 * `SetterFactory`
 * `QueryMapEncoder`
+* `Capability` (`MicrometerCapability` and `CachingCapability` are 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,
@@ -167,7 +173,9 @@ This replaces the `SpringMvcContract` with `feign.Contract.Default` and adds a `
 application.yml
 [source,yaml]
 ----
-feign:
+spring:
+	cloud:
+		openfeign:
 			client:
 				config:
 					feignName:
@@ -187,18 +195,25 @@ feign:
 						encoder: com.example.SimpleEncoder
 						decoder: com.example.SimpleDecoder
 						contract: com.example.SimpleContract
+						capabilities:
+							- com.example.FooCapability
+							- com.example.BarCapability
+						queryMapEncoder: com.example.SimpleQueryMapEncoder
+						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 configured all `@FeignClient`, you can create configuration properties with `default` feign name.
+If you prefer using configuration properties to configure all `@FeignClient`, you can create configuration properties with `default` feign name.
 
-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`.
+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`.
 
 application.yml
 [source,yaml]
 ----
-feign:
+spring:
+	cloud:
+		openfeign:
 			client:
 				config:
 					default:
@@ -209,27 +224,7 @@ feign:
 
 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 `feign.client.default-to-properties` to `false`.
+you can change `spring.cloud.openfeign.client.default-to-properties` to `false`.
-
-NOTE: If you need to use `ThreadLocal` bound variables in your `RequestInterceptor`s you will need to either set the
-thread isolation strategy for Hystrix to `SEMAPHORE` or disable Hystrix in Feign.
-
-application.yml
-[source,yaml]
-----
-# To disable Hystrix in Feign
-feign:
-  hystrix:
-    enabled: false
-
-# To set thread isolation to SEMAPHORE
-hystrix:
-  command:
-    default:
-      execution:
-        isolation:
-          strategy: SEMAPHORE
-----
 
 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
@@ -275,13 +270,13 @@ public FeignClientConfigurer feignClientConfigurer() {
 }
 ----
 
-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`.
+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`.
 
 ==== `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 `feign.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 `spring.cloud.openfeign.encoder.charset-from-content-type` to `true`.
 
 [[timeout-handling]]
 === Timeout Handling
@@ -293,32 +288,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.
 
-When Hystrix <<spring-cloud-openfeign#spring-cloud-feign-hystrix,is enabled>>, its timeout configuration link:https://github.com/Netflix/Hystrix/wiki/Configuration#execution.isolation.thread.timeoutInMilliseconds[defaults] to 1000 milliseconds. Hence, it might occur before the client timeout that we configured earlier. Increasing this timeout prevents it from happening.
-
-[source,yaml]
-----
-feign:
-  client:
-    config:
-      default:
-        connectTimeout: 5000
-        readTimeout: 5000
-  hystrix:
-    enabled: true
-
-hystrix:
-  command:
-    default:
-      execution:
-        timeout:
-          enabled: true
-        isolation:
-          thread:
-            timeoutInMilliseconds: 60000
-----
-
-NOTE: When the Hystrix timeout is enabled and its timeout is set longer than that of a feign client, `HystrixTimeoutException` wraps a feign exception. Otherwise, the only difference is the cause of the exception. The purpose of `HystrixTimeoutException` is to wrap any runtime exception that occurs first and throw an instance of itself.
-
 === Creating Feign Clients Manually
 
 In some cases it might be necessary to customize your Feign Clients in a way that is not
@@ -337,11 +306,12 @@ class FooController {
 	private FooClient adminClient;
 
 	@Autowired
-	public FooController(Decoder decoder, Encoder encoder, Client client, Contract contract) {
+	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(micrometerCapability)
 				.requestInterceptor(new BasicAuthRequestInterceptor("user", "user"))
 				.target(FooClient.class, "https://PROD-SVC");
 
@@ -349,6 +319,7 @@ class FooController {
 				.encoder(encoder)
 				.decoder(decoder)
 				.contract(contract)
+				.addCapability(micrometerCapability)
 				.requestInterceptor(new BasicAuthRequestInterceptor("admin", "admin"))
 				.target(FooClient.class, "https://PROD-SVC");
 	}
@@ -367,80 +338,10 @@ the default Feign native annotations.
 You can also use the `Builder`to configure FeignClient not to inherit beans from the parent context.
 You can do this by overriding calling `inheritParentContext(false)` on the `Builder`.
 
-[[spring-cloud-feign-hystrix]]
-=== Feign Hystrix Support
-
-If Hystrix is on the classpath and `feign.hystrix.enabled=true`, Feign will wrap all methods with a circuit breaker. Returning a `com.netflix.hystrix.HystrixCommand` is also available. This lets you use reactive patterns (with a call to `.toObservable()` or `.observe()` or asynchronous use (with a call to `.queue()`).
-
-To disable Hystrix support on a per-client basis create a vanilla `Feign.Builder` with the "prototype" scope, e.g.:
-
-[source,java,indent=0]
-----
-@Configuration
-public class FooConfiguration {
-    	@Bean
-	@Scope("prototype")
-	public Feign.Builder feignBuilder() {
-		return Feign.builder();
-	}
-}
-----
-
-WARNING:  Prior to the Spring Cloud Dalston release, if Hystrix was on the classpath Feign would have wrapped
-all methods in a circuit breaker by default.  This default behavior was changed in Spring Cloud Dalston in
-favor for an opt-in approach.
-
-[[spring-cloud-feign-hystrix-fallback]]
-=== Feign Hystrix Fallbacks
-
-Hystrix supports the notion of a fallback: a default code path that is executed when the circuit is open or there is an error. To enable fallbacks for a given `@FeignClient` set the `fallback` attribute to the class name that implements the fallback. You also need to declare your implementation as a Spring bean.
-
-[source,java,indent=0]
-----
-@FeignClient(name = "hello", fallback = HystrixClientFallback.class)
-protected interface HystrixClient {
-    @RequestMapping(method = RequestMethod.GET, value = "/hello")
-    Hello iFailSometimes();
-}
-
-static class HystrixClientFallback implements HystrixClient {
-    @Override
-    public Hello iFailSometimes() {
-        return new Hello("fallback");
-    }
-}
-----
-
-If one needs access to the cause that made the fallback trigger, one can use the `fallbackFactory` attribute inside `@FeignClient`.
-
-[source,java,indent=0]
-----
-@FeignClient(name = "hello", fallbackFactory = HystrixClientFallbackFactory.class)
-protected interface HystrixClient {
-	@RequestMapping(method = RequestMethod.GET, value = "/hello")
-	Hello iFailSometimes();
-}
-
-@Component
-static class HystrixClientFallbackFactory implements FallbackFactory<HystrixClient> {
-	@Override
-	public HystrixClient create(Throwable cause) {
-		return new HystrixClient() {
-			@Override
-			public Hello iFailSometimes() {
-				return new Hello("fallback; reason was: " + cause.getMessage());
-			}
-		};
-	}
-}
-----
-
-WARNING: There is a limitation with the implementation of fallbacks in Feign and how Hystrix fallbacks work. Fallbacks are currently not supported for methods that return `com.netflix.hystrix.HystrixCommand` and `rx.Observable`.
-
 [[spring-cloud-feign-circuitbreaker]]
 === Feign Spring Cloud CircuitBreaker Support
 
-If Spring Cloud CircuitBreaker is on the classpath and `feign.circuitbreaker.enabled=true`, Feign will wrap all methods with a circuit breaker.
+If Spring Cloud CircuitBreaker is on the classpath and `spring.cloud.openfeign.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.:
 
@@ -456,7 +357,64 @@ public class FooConfiguration {
 }
 ----
 
-The circuit breaker name follows this pattern `<feignClientName>#<calledMethod>`. When calling a `@FeignClient` with name `foo` and the called interface method is `bar` then the circuit breaker name will be `foo_bar`.
+The circuit breaker name follows this pattern `<feignClientClassName>#<calledMethod>(<parameterTypes>)`. When calling a `@FeignClient` with `FooClient` interface and the called interface method that has no parameters is `bar` then the circuit breaker name will be `FooClient#bar()`.
+
+NOTE: As of 2020.0.2, the circuit breaker name pattern has changed from `<feignClientName>_<calledMethod>`.
+Using `CircuitBreakerNameResolver` introduced in 2020.0.4, circuit breaker names can retain the old pattern.
+
+Providing a bean of `CircuitBreakerNameResolver`, you can change the circuit breaker name pattern.
+[source,java,indent=0]
+----
+@Configuration
+public class FooConfiguration {
+	@Bean
+	public CircuitBreakerNameResolver circuitBreakerNameResolver() {
+		return (String feignClientName, Target<?> target, Method method) -> feignClientName + "_" + method.getName();
+	}
+}
+----
+
+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
+
+[source,yaml,indent=0]
+----
+feign:
+  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
@@ -465,19 +423,77 @@ Spring Cloud CircuitBreaker supports the notion of a fallback: a default code pa
 
 [source,java,indent=0]
 ----
-include::{core_path}/src/test/java/org/springframework/cloud/openfeign/circuitbreaker/CircuitBreakerTests.java[tags=client_with_fallback, indent=0]
+@FeignClient(name = "test", url = "http://localhost:${server.port}/", fallback = Fallback.class)
+	protected interface TestClient {
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hello")
+		Hello getHello();
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hellonotfound")
+		String getException();
+
+	}
+
+	@Component
+	static class Fallback implements TestClient {
+
+		@Override
+		public Hello getHello() {
+			throw new NoFallbackAvailableException("Boom!", new RuntimeException());
+		}
+
+		@Override
+		public String getException() {
+			return "Fixed response";
+		}
+
+	}
 ----
 
 If one needs access to the cause that made the fallback trigger, one can use the `fallbackFactory` attribute inside `@FeignClient`.
 
 [source,java,indent=0]
 ----
-include::{core_path}/src/test/java/org/springframework/cloud/openfeign/circuitbreaker/CircuitBreakerTests.java[tags=client_with_fallback_factory, indent=0]
+@FeignClient(name = "testClientWithFactory", url = "http://localhost:${server.port}/",
+			fallbackFactory = TestFallbackFactory.class)
+	protected interface TestClientWithFactory {
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hello")
+		Hello getHello();
+
+		@RequestMapping(method = RequestMethod.GET, value = "/hellonotfound")
+		String getException();
+
+	}
+
+	@Component
+	static class TestFallbackFactory implements FallbackFactory<FallbackWithFactory> {
+
+		@Override
+		public FallbackWithFactory create(Throwable cause) {
+			return new FallbackWithFactory();
+		}
+
+	}
+
+	static class FallbackWithFactory implements TestClientWithFactory {
+
+		@Override
+		public Hello getHello() {
+			throw new NoFallbackAvailableException("Boom!", new RuntimeException());
+		}
+
+		@Override
+		public String getException() {
+			return "Fixed response";
+		}
+
+	}
 ----
 
 === Feign and `@Primary`
 
-When using Feign with Hystrix 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.
+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.
 
 [source,java,indent=0]
 ----
@@ -523,10 +539,7 @@ public interface UserClient extends UserService {
 }
 ----
 
-NOTE: It is generally not advisable to share an interface between a
+WARNING: `@FeignClient` interfaces should not be shared between server and client and annotating `@FeignClient` interfaces with `@RequestMapping` on class level is no longer supported.
-server and a client. It introduces tight coupling, and also actually
-doesn't work with Spring MVC in its current form (method parameter
-mapping is not inherited).
 
 === Feign request/response compression
 
@@ -535,29 +548,21 @@ Feign requests. You can do this by enabling one of the properties:
 
 [source,java]
 ----
-feign.compression.request.enabled=true
+spring.cloud.openfeign.compression.request.enabled=true
-feign.compression.response.enabled=true
+spring.cloud.openfeign.compression.response.enabled=true
 ----
 
 Feign request compression gives you settings similar to what you may set for your web server:
 
 [source,java]
 ----
-feign.compression.request.enabled=true
+spring.cloud.openfeign.compression.request.enabled=true
-feign.compression.request.mime-types=text/xml,application/xml,application/json
+spring.cloud.openfeign.compression.request.mime-types=text/xml,application/xml,application/json
-feign.compression.request.min-request-size=2048
+spring.cloud.openfeign.compression.request.min-request-size=2048
 ----
 
 These properties allow you to be selective about the compressed media types and minimum request threshold length.
 
-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
 
 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.
@@ -589,6 +594,75 @@ public class FooConfiguration {
 }
 ----
 
+=== 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 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.
+
+[source,java,indent=0]
+----
+@Configuration
+public class FooConfiguration {
+	@Bean
+	Capability customCapability() {
+		return new CustomCapability();
+	}
+}
+----
+
+=== Feign metrics
+
+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 `MeterRegistry` bean is available
+* feign metrics properties are set to `true` (by default)
+	- `spring.cloud.openfeign.metrics.enabled=true` (for all clients)
+	- `spring.cloud.openfeign.client.config.feignName.metrics.enabled=true` (for a single client)
+
+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 metrics properties to `false`
+	- `spring.cloud.openfeign.metrics.enabled=false`
+	- `spring.cloud.openfeign.client.config.feignName.metrics.enabled=false`
+
+NOTE: `spring.cloud.openfeign.metrics.enabled=false` disables metrics support for *all* Feign clients regardless of the value of the client-level flags: `spring.cloud.openfeign.client.config.feignName.metrics.enabled`.
+If you want to enable or disable merics per client, don't set `spring.cloud.openfeign.metrics.enabled` and use `spring.cloud.openfeign.client.config.feignName.metrics.enabled`.
+
+You can also customize the `MicrometerCapability` by registering your own bean:
+
+[source,java,indent=0]
+----
+@Configuration
+public class FooConfiguration {
+	@Bean
+	public MicrometerCapability micrometerCapability(MeterRegistry meterRegistry) {
+		return new MicrometerCapability(meterRegistry);
+	}
+}
+----
+
+=== 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
 
 The OpenFeign `@QueryMap` annotation provides support for POJOs to be used as
@@ -676,26 +750,27 @@ public interface DemoTemplate {
 ----
 
 === Feign `CollectionFormat` support
-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.
+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.
 
 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 PageableFeignClient {
+protected interface PageableFeignClient {
 
     @CollectionFormat(feign.CollectionFormat.CSV)
     @GetMapping(path = "/page")
     ResponseEntity performRequest(Pageable page);
 
-	}
+}
 ----
 
 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.
+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.
 
@@ -707,17 +782,66 @@ To work around this problem you can use an `ObjectProvider` when autowiring your
 [source,java,indent=0]
 ----
 @Autowired
-ObjectProvider<TestFeginClient> testFeginClient;
+ObjectProvider<TestFeignClient> testFeignClient;
 ----
 
 === Spring Data Support
+
 You may consider enabling Jackson Modules for the support `org.springframework.data.domain.Page` and `org.springframework.data.domain.Sort` decoding.
 
 [source,java]
 ----
-feign.autoconfiguration.jackson.enabled=true
+spring.cloud.openfeign.autoconfiguration.jackson.enabled=true
 ----
 
+=== 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 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
+----
+TIP: DO NOT annotate the `@FeignClient` interface with the `@RefreshScope` annotation.
+
+=== 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 `OAuth2FeignRequestInterceptor` is created. Before each request, the interceptor resolves the required access token and includes it as a header.
+Sometimes, when load balancing is enabled for Feign clients, you may want to use load balancing for fetching access tokens, too. To do so, you should ensure that the load balancer is on the classpath (spring-cloud-starter-loadbalancer) and explicitly enable load balancing for OAuth2FeignRequestInterceptor by setting the following flag:
+----
+spring.cloud.openfeign.oauth2.load-balanced=true
+----
+
+=== 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.
+
 == Configuration properties
 
 To see the list of all Spring Cloud OpenFeign related configuration properties please check link:appendix.html[the Appendix page].

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>2.2.9.RELEASE</version>
+	<version>4.0.0-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>2.3.5.RELEASE</version>
+		<version>4.0.0-SNAPSHOT</version>
 		<relativePath/>
 	</parent>
 	<scm>
@@ -26,8 +26,7 @@
 	<properties>
 		<main.basedir>${basedir}</main.basedir>
 		<jackson.version>2.11.3</jackson.version>
-		<spring-cloud-commons.version>2.2.9.RELEASE</spring-cloud-commons.version>
+		<spring-cloud-commons.version>4.0.0-SNAPSHOT</spring-cloud-commons.version>
-		<spring-cloud-netflix.version>2.2.9.RELEASE</spring-cloud-netflix.version>
 
 		<!-- Plugin versions -->
 		<maven-eclipse-plugin.version>2.10</maven-eclipse-plugin.version>
@@ -65,13 +64,6 @@
 					</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>
@@ -80,6 +72,15 @@
 				<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>
 
@@ -94,13 +95,6 @@
 
 	<dependencyManagement>
 		<dependencies>
-			<dependency>
-				<groupId>org.springframework.cloud</groupId>
-				<artifactId>spring-cloud-netflix-dependencies</artifactId>
-				<version>${spring-cloud-netflix.version}</version>
-				<type>pom</type>
-				<scope>import</scope>
-			</dependency>
 			<dependency>
 				<groupId>org.springframework.cloud</groupId>
 				<artifactId>spring-cloud-commons-dependencies</artifactId>
@@ -141,7 +135,7 @@
 				<repository>
 					<id>spring-snapshots</id>
 					<name>Spring Snapshots</name>
-					<url>https://repo.spring.io/libs-snapshot-local</url>
+					<url>https://repo.spring.io/snapshot</url>
 					<snapshots>
 						<enabled>true</enabled>
 					</snapshots>
@@ -152,7 +146,7 @@
 				<repository>
 					<id>spring-milestones</id>
 					<name>Spring Milestones</name>
-					<url>https://repo.spring.io/libs-milestone-local</url>
+					<url>https://repo.spring.io/milestone</url>
 					<snapshots>
 						<enabled>false</enabled>
 					</snapshots>
@@ -170,7 +164,7 @@
 				<pluginRepository>
 					<id>spring-snapshots</id>
 					<name>Spring Snapshots</name>
-					<url>https://repo.spring.io/libs-snapshot-local</url>
+					<url>https://repo.spring.io/snapshot</url>
 					<snapshots>
 						<enabled>true</enabled>
 					</snapshots>
@@ -181,7 +175,7 @@
 				<pluginRepository>
 					<id>spring-milestones</id>
 					<name>Spring Milestones</name>
-					<url>https://repo.spring.io/libs-milestone-local</url>
+					<url>https://repo.spring.io/milestone</url>
 					<snapshots>
 						<enabled>false</enabled>
 					</snapshots>
@@ -189,7 +183,7 @@
 				<pluginRepository>
 					<id>spring-releases</id>
 					<name>Spring Releases</name>
-					<url>https://repo.spring.io/libs-release-local</url>
+					<url>https://repo.spring.io/release</url>
 					<snapshots>
 						<enabled>false</enabled>
 					</snapshots>

spring-cloud-openfeign-core/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>org.springframework.cloud</groupId>
 		<artifactId>spring-cloud-openfeign</artifactId>
-		<version>2.2.9.RELEASE</version>
+		<version>4.0.0-SNAPSHOT</version>
 		<relativePath>..</relativePath> <!-- lookup parent from repository -->
 	</parent>
 	<artifactId>spring-cloud-openfeign-core</artifactId>
@@ -21,10 +21,6 @@
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-autoconfigure</artifactId>
 		</dependency>
-		<dependency>
-			<groupId>org.springframework.cloud</groupId>
-			<artifactId>spring-cloud-netflix-ribbon</artifactId>
-		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-actuator</artifactId>
@@ -65,15 +61,16 @@
 			<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>
@@ -89,11 +86,6 @@
 			<artifactId>spring-cloud-context</artifactId>
 			<optional>true</optional>
 		</dependency>
-		<dependency>
-			<groupId>com.netflix.ribbon</groupId>
-			<artifactId>ribbon-loadbalancer</artifactId>
-			<optional>true</optional>
-		</dependency>
 		<dependency>
 			<groupId>io.github.openfeign</groupId>
 			<artifactId>feign-core</artifactId>
@@ -102,6 +94,13 @@
 		<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>
+			</exclusions>
 		</dependency>
 		<dependency>
 			<groupId>io.github.openfeign</groupId>
@@ -110,7 +109,7 @@
 		</dependency>
 		<dependency>
 			<groupId>io.github.openfeign</groupId>
-			<artifactId>feign-hc5</artifactId>
+			<artifactId>feign-micrometer</artifactId>
 			<optional>true</optional>
 		</dependency>
 		<dependency>
@@ -120,7 +119,7 @@
 		</dependency>
 		<dependency>
 			<groupId>io.github.openfeign</groupId>
-			<artifactId>feign-hystrix</artifactId>
+			<artifactId>feign-hc5</artifactId>
 			<optional>true</optional>
 		</dependency>
 		<dependency>
@@ -128,46 +127,30 @@
 			<artifactId>feign-okhttp</artifactId>
 			<optional>true</optional>
 		</dependency>
-		<dependency>
-			<groupId>com.netflix.hystrix</groupId>
-			<artifactId>hystrix-core</artifactId>
-			<optional>true</optional>
-		</dependency>
-		<dependency>
-			<groupId>com.netflix.hystrix</groupId>
-			<artifactId>hystrix-serialization</artifactId>
-			<optional>true</optional>
-		</dependency>
-		<dependency>
-			<groupId>com.netflix.hystrix</groupId>
-			<artifactId>hystrix-metrics-event-stream</artifactId>
-			<optional>true</optional>
-		</dependency>
-		<dependency>
-			<groupId>com.netflix.hystrix</groupId>
-			<artifactId>hystrix-javanica</artifactId>
-			<optional>true</optional>
-		</dependency>
-		<dependency>
-			<groupId>com.netflix.ribbon</groupId>
-			<artifactId>ribbon-core</artifactId>
-			<optional>true</optional>
-		</dependency>
-		<dependency>
-			<groupId>com.netflix.ribbon</groupId>
-			<artifactId>ribbon-httpclient</artifactId>
-			<optional>true</optional>
-		</dependency>
-		<dependency>
-			<groupId>io.reactivex</groupId>
-			<artifactId>rxjava</artifactId>
-			<optional>true</optional>
-		</dependency>
 		<dependency>
 			<groupId>com.squareup.okhttp3</groupId>
 			<artifactId>okhttp</artifactId>
 			<optional>true</optional>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework.security.oauth.boot</groupId>
+			<artifactId>spring-security-oauth2-autoconfigure</artifactId>
+			<optional>true</optional>
+			<exclusions>
+				<exclusion>
+					<groupId>javax.xml.bind</groupId>
+					<artifactId>jaxb-api</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>javax.activation</groupId>
+					<artifactId>javax.activation-api</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>com.sun.activation</groupId>
+					<artifactId>jakarta.activation</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-autoconfigure-processor</artifactId>
@@ -198,16 +181,6 @@
 			<artifactId>reactor-test</artifactId>
 			<scope>test</scope>
 		</dependency>
-		<dependency>
-			<groupId>com.netflix.ribbon</groupId>
-			<artifactId>ribbon</artifactId>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.cloud</groupId>
-			<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
-			<scope>test</scope>
-		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-data-rest</artifactId>
@@ -222,13 +195,13 @@
 		<dependency>
 			<groupId>com.google.protobuf</groupId>
 			<artifactId>protobuf-java</artifactId>
-			<version>3.14.0</version>
+			<version>3.19.3</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>io.vavr</groupId>
 			<artifactId>vavr</artifactId>
-			<version>0.10.3</version>
+			<version>0.10.4</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
@@ -236,6 +209,12 @@
 			<artifactId>spring-cloud-loadbalancer</artifactId>
 			<optional>true</optional>
 		</dependency>
+		<dependency>
+			<groupId>commons-io</groupId>
+			<artifactId>commons-io</artifactId>
+			<version>2.11.0</version>
+			<scope>test</scope>
+		</dependency>
 	</dependencies>
 	<profiles>
 		<profile>

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -43,8 +43,7 @@ public interface AnnotatedParameterProcessor {
 	 * @param method the method that contains the annotation
 	 * @return whether the parameter is http
 	 */
-	boolean processArgument(AnnotatedParameterContext context, Annotation annotation,
+	boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method);
-			Method method);
 
 	/**
 	 * Specifies the parameter context.

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

@@ -0,0 +1,42 @@
+/*
+ * 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.Capability;
+import feign.InvocationHandlerFactory;
+
+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 CachingCapability implements Capability {
+
+	private final CacheInterceptor cacheInterceptor;
+
+	public CachingCapability(CacheInterceptor cacheInterceptor) {
+		this.cacheInterceptor = cacheInterceptor;
+	}
+
+	@Override
+	public InvocationHandlerFactory enrich(InvocationHandlerFactory invocationHandlerFactory) {
+		return new FeignCachingInvocationHandlerFactory(invocationHandlerFactory, cacheInterceptor);
+	}
+
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -14,22 +14,21 @@
  * limitations under the License.
  */
 
-package org.springframework.cloud.openfeign.hystrix.security.app;
+package org.springframework.cloud.openfeign;
 
-import org.springframework.web.bind.annotation.RequestHeader;
+import java.lang.reflect.Method;
-import org.springframework.web.bind.annotation.RequestMapping;
+
-import org.springframework.web.bind.annotation.RestController;
+import feign.Target;
 
 /**
- * @author Daniel Lavoie
+ * Used to resolve a circuitbreaker name which will be used in
+ * {@link org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory}.
+ *
+ * @author Kwangyong Kim
+ * @since 2020.0.4
  */
-@RestController
+public interface CircuitBreakerNameResolver {
-@RequestMapping("/username")
-public class UsernameController {
 
-	@RequestMapping
+	String resolveCircuitBreakerName(String feignClientName, Target<?> target, Method method);
-	public String getUsername(@RequestHeader String username) {
-		return username;
-	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -25,9 +25,10 @@ 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)
+@Target({ ElementType.METHOD, ElementType.TYPE })
 @Retention(RetentionPolicy.RUNTIME)
 public @interface CollectionFormat {
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 the original author or authors.
+ * 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.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -25,8 +25,8 @@ import feign.Target;
 class DefaultTargeter implements Targeter {
 
 	@Override
-	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
+	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
-			FeignContext context, Target.HardCodedTarget<T> target) {
+			Target.HardCodedTarget<T> target) {
 		return feign.target(target);
 	}
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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.
@@ -17,20 +17,24 @@
 package org.springframework.cloud.openfeign;
 
 import java.io.IOException;
+import java.lang.reflect.Method;
+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 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.httpclient.ApacheHttpClient;
 import feign.okhttp.OkHttpClient;
+import jakarta.annotation.PreDestroy;
 import okhttp3.ConnectionPool;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -41,21 +45,24 @@ import org.apache.http.conn.HttpClientConnectionManager;
 import org.apache.http.impl.client.CloseableHttpClient;
 
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.AllNestedConditions;
+import org.springframework.beans.factory.annotation.Value;
 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.ConditionalOnMissingClass;
 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.client.loadbalancer.LoadBalancerInterceptor;
+import org.springframework.cloud.client.loadbalancer.RetryLoadBalancerInterceptor;
 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.support.DefaultGzipDecoderConfiguration;
+import org.springframework.cloud.openfeign.security.OAuth2FeignRequestInterceptor;
+import org.springframework.cloud.openfeign.security.OAuth2FeignRequestInterceptorConfigurer;
 import org.springframework.cloud.openfeign.support.FeignEncoderProperties;
 import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
 import org.springframework.cloud.openfeign.support.PageJacksonModule;
@@ -66,6 +73,10 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Sort;
+import org.springframework.security.oauth2.client.OAuth2ClientContext;
+import org.springframework.security.oauth2.client.resource.OAuth2ProtectedResourceDetails;
+
+import static org.springframework.cloud.openfeign.security.OAuth2FeignRequestInterceptorBuilder.buildWithConfigurers;
 
 /**
  * @author Spencer Gibb
@@ -75,12 +86,15 @@ import org.springframework.data.domain.Sort;
  * @author Tim Peeters
  * @author Olga Maciaszek-Sharma
  * @author Nguyen Ky Thanh
+ * @author Andrii Bohutskyi
+ * @author Kwangyong Kim
+ * @author Sam Kruglov
+ * @author Wojciech Mąka
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnClass(Feign.class)
-@EnableConfigurationProperties({ FeignClientProperties.class,
+@EnableConfigurationProperties({ FeignClientProperties.class, FeignHttpClientProperties.class,
-		FeignHttpClientProperties.class, FeignEncoderProperties.class })
+		FeignEncoderProperties.class })
-@Import(DefaultGzipDecoderConfiguration.class)
 public class FeignAutoConfiguration {
 
 	private static final Log LOG = LogFactory.getLog(FeignAutoConfiguration.class);
@@ -100,10 +114,16 @@ public class FeignAutoConfiguration {
 		return context;
 	}
 
+	@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 = "feign.autoconfiguration.jackson.enabled",
+	@ConditionalOnProperty(value = "spring.cloud.openfeign.autoconfiguration.jackson.enabled", havingValue = "true")
-			havingValue = "true")
 	protected static class FeignJacksonConfiguration {
 
 		@Bean
@@ -121,7 +141,7 @@ public class FeignAutoConfiguration {
 	}
 
 	@Configuration(proxyBeanMethods = false)
-	@Conditional(DefaultFeignTargeterConditions.class)
+	@Conditional(FeignCircuitBreakerDisabledConditions.class)
 	protected static class DefaultFeignTargeterConfiguration {
 
 		@Bean
@@ -133,44 +153,70 @@ public class FeignAutoConfiguration {
 	}
 
 	@Configuration(proxyBeanMethods = false)
-	@Conditional(FeignCircuitBreakerDisabledConditions.class)
+	@ConditionalOnClass(CircuitBreaker.class)
-	@ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
+	@ConditionalOnProperty(value = "spring.cloud.openfeign.circuitbreaker.enabled", havingValue = "true")
-	@ConditionalOnProperty(value = "feign.hystrix.enabled", havingValue = "true",
+	protected static class CircuitBreakerPresentFeignTargeterConfiguration {
-			matchIfMissing = true)
-	protected static class HystrixFeignTargeterConfiguration {
 
 		@Bean
-		@ConditionalOnMissingBean
+		@ConditionalOnMissingBean(CircuitBreakerFactory.class)
-		public Targeter feignTargeter() {
+		public Targeter defaultFeignTargeter() {
-			return new HystrixTargeter();
+			return new DefaultTargeter();
 		}
 
+		@Bean
+		@ConditionalOnMissingBean(CircuitBreakerNameResolver.class)
+		@ConditionalOnProperty(value = "spring.cloud.openfeign.circuitbreaker.alphanumeric-ids.enabled",
+				havingValue = "false")
+		public CircuitBreakerNameResolver circuitBreakerNameResolver() {
+			return new DefaultCircuitBreakerNameResolver();
 		}
 
-	@Configuration(proxyBeanMethods = false)
+		@Bean
-	@ConditionalOnClass(CircuitBreaker.class)
+		@ConditionalOnMissingBean(CircuitBreakerNameResolver.class)
-	@ConditionalOnProperty(value = "feign.circuitbreaker.enabled", havingValue = "true")
+		@ConditionalOnProperty(value = "spring.cloud.openfeign.circuitbreaker.alphanumeric-ids.enabled",
-	protected static class CircuitBreakerPresentFeignTargeterConfiguration {
+				havingValue = "true", matchIfMissing = true)
+		public CircuitBreakerNameResolver alphanumericCircuitBreakerNameResolver() {
+			return new AlphanumericCircuitBreakerNameResolver();
+		}
 
 		@Bean
 		@ConditionalOnMissingBean
 		@ConditionalOnBean(CircuitBreakerFactory.class)
-		public Targeter circuitBreakerFeignTargeter(
+		public Targeter circuitBreakerFeignTargeter(CircuitBreakerFactory circuitBreakerFactory,
-				CircuitBreakerFactory circuitBreakerFactory) {
+				@Value("${spring.cloud.openfeign.circuitbreaker.group.enabled:false}") boolean circuitBreakerGroupEnabled,
-			return new FeignCircuitBreakerTargeter(circuitBreakerFactory);
+				CircuitBreakerNameResolver circuitBreakerNameResolver) {
+			return new FeignCircuitBreakerTargeter(circuitBreakerFactory, circuitBreakerGroupEnabled,
+					circuitBreakerNameResolver);
+		}
+
+		static class DefaultCircuitBreakerNameResolver implements CircuitBreakerNameResolver {
+
+			@Override
+			public String resolveCircuitBreakerName(String feignClientName, Target<?> target, Method method) {
+				return Feign.configKey(target.type(), method);
+			}
+
+		}
+
+		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
-	// ribbon is not on the class path.
+	// SC loadbalancer is not on the class path.
-	// see corresponding configurations in FeignRibbonClientAutoConfiguration
+	// see corresponding configurations in FeignLoadBalancerAutoConfiguration
-	// for load balanced ribbon clients.
+	// for load-balanced clients.
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(ApacheHttpClient.class)
-	@ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
 	@ConditionalOnMissingBean(CloseableHttpClient.class)
-	@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
+	@ConditionalOnProperty(value = "spring.cloud.openfeign.httpclient.enabled", matchIfMissing = true)
 	@Conditional(HttpClient5DisabledConditions.class)
 	protected static class HttpClientFeignConfiguration {
 
@@ -187,13 +233,10 @@ public class FeignAutoConfiguration {
 		public HttpClientConnectionManager connectionManager(
 				ApacheHttpClientConnectionManagerFactory connectionManagerFactory,
 				FeignHttpClientProperties httpClientProperties) {
-			final HttpClientConnectionManager connectionManager = connectionManagerFactory
+			final HttpClientConnectionManager connectionManager = connectionManagerFactory.newConnectionManager(
-					.newConnectionManager(httpClientProperties.isDisableSslValidation(),
+					httpClientProperties.isDisableSslValidation(), httpClientProperties.getMaxConnections(),
-							httpClientProperties.getMaxConnections(),
+					httpClientProperties.getMaxConnectionsPerRoute(), httpClientProperties.getTimeToLive(),
-							httpClientProperties.getMaxConnectionsPerRoute(),
+					httpClientProperties.getTimeToLiveUnit(), this.registryBuilder);
-							httpClientProperties.getTimeToLive(),
-							httpClientProperties.getTimeToLiveUnit(),
-							this.registryBuilder);
 			this.connectionManagerTimer.schedule(new TimerTask() {
 				@Override
 				public void run() {
@@ -209,10 +252,8 @@ public class FeignAutoConfiguration {
 				FeignHttpClientProperties httpClientProperties) {
 			RequestConfig defaultRequestConfig = RequestConfig.custom()
 					.setConnectTimeout(httpClientProperties.getConnectionTimeout())
-					.setRedirectsEnabled(httpClientProperties.isFollowRedirects())
+					.setRedirectsEnabled(httpClientProperties.isFollowRedirects()).build();
-					.build();
+			this.httpClient = httpClientFactory.createBuilder().setConnectionManager(httpClientConnectionManager)
-			this.httpClient = httpClientFactory.createBuilder()
-					.setConnectionManager(httpClientConnectionManager)
 					.setDefaultRequestConfig(defaultRequestConfig).build();
 			return this.httpClient;
 		}
@@ -242,35 +283,32 @@ public class FeignAutoConfiguration {
 
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(OkHttpClient.class)
-	@ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
 	@ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
-	@ConditionalOnProperty("feign.okhttp.enabled")
+	@ConditionalOnProperty("spring.cloud.openfeign.okhttp.enabled")
 	protected static class OkHttpFeignConfiguration {
 
 		private okhttp3.OkHttpClient okHttpClient;
 
 		@Bean
 		@ConditionalOnMissingBean(ConnectionPool.class)
-		public ConnectionPool httpClientConnectionPool(
+		public ConnectionPool httpClientConnectionPool(FeignHttpClientProperties httpClientProperties,
-				FeignHttpClientProperties httpClientProperties,
 				OkHttpClientConnectionPoolFactory connectionPoolFactory) {
-			Integer maxTotalConnections = httpClientProperties.getMaxConnections();
+			int maxTotalConnections = httpClientProperties.getMaxConnections();
-			Long timeToLive = httpClientProperties.getTimeToLive();
+			long timeToLive = httpClientProperties.getTimeToLive();
 			TimeUnit ttlUnit = httpClientProperties.getTimeToLiveUnit();
 			return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
 		}
 
 		@Bean
-		public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory,
+		public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory, ConnectionPool connectionPool,
-				ConnectionPool connectionPool,
 				FeignHttpClientProperties httpClientProperties) {
-			Boolean followRedirects = httpClientProperties.isFollowRedirects();
+			boolean followRedirects = httpClientProperties.isFollowRedirects();
-			Integer connectTimeout = httpClientProperties.getConnectionTimeout();
+			int connectTimeout = httpClientProperties.getConnectionTimeout();
-			Boolean disableSslValidation = httpClientProperties.isDisableSslValidation();
+			boolean disableSslValidation = httpClientProperties.isDisableSslValidation();
+			Duration readTimeout = httpClientProperties.getOkHttp().getReadTimeout();
 			this.okHttpClient = httpClientFactory.createBuilder(disableSslValidation)
-					.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
+					.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).followRedirects(followRedirects)
-					.followRedirects(followRedirects).connectionPool(connectionPool)
+					.readTimeout(readTimeout).connectionPool(connectionPool).build();
-					.build();
 			return this.okHttpClient;
 		}
 
@@ -292,35 +330,49 @@ public class FeignAutoConfiguration {
 
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(ApacheHttp5Client.class)
-	@ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
 	@ConditionalOnMissingBean(org.apache.hc.client5.http.impl.classic.CloseableHttpClient.class)
-	@ConditionalOnProperty(value = "feign.httpclient.hc5.enabled", havingValue = "true")
+	@ConditionalOnProperty(value = "spring.cloud.openfeign.httpclient.hc5.enabled", havingValue = "true")
 	@Import(org.springframework.cloud.openfeign.clientconfig.HttpClient5FeignConfiguration.class)
 	protected static class HttpClient5FeignConfiguration {
 
 		@Bean
 		@ConditionalOnMissingBean(Client.class)
-		public Client feignClient(
+		public Client feignClient(org.apache.hc.client5.http.impl.classic.CloseableHttpClient httpClient5) {
-				org.apache.hc.client5.http.impl.classic.CloseableHttpClient httpClient5) {
 			return new ApacheHttp5Client(httpClient5);
 		}
 
 	}
 
-	static class DefaultFeignTargeterConditions extends AllNestedConditions {
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnClass(OAuth2ClientContext.class)
+	@ConditionalOnProperty("spring.cloud.openfeign.oauth2.enabled")
+	@Deprecated // spring-security-oauth2 reached EOL
+	protected static class Oauth2FeignConfiguration {
 
-		DefaultFeignTargeterConditions() {
+		@ConditionalOnBean({ RetryLoadBalancerInterceptor.class, OAuth2ClientContext.class,
-			super(ConfigurationPhase.PARSE_CONFIGURATION);
+				OAuth2ProtectedResourceDetails.class })
+		@ConditionalOnProperty(value = "spring.cloud.openfeign.oauth2.load-balanced", havingValue = "true")
+		@Bean
+		public OAuth2FeignRequestInterceptorConfigurer retryLoadBalancerInterceptorInjectingConfigurer(
+				final RetryLoadBalancerInterceptor loadBalancerInterceptor) {
+			return builder -> builder.withAccessTokenProviderInterceptors(loadBalancerInterceptor);
 		}
 
-		@Conditional(FeignCircuitBreakerDisabledConditions.class)
+		@ConditionalOnBean({ LoadBalancerInterceptor.class, OAuth2ClientContext.class,
-		static class FeignCircuitBreakerDisabled {
+				OAuth2ProtectedResourceDetails.class })
-
+		@ConditionalOnProperty(value = "spring.cloud.openfeign.oauth2.load-balanced", havingValue = "true")
+		@Bean
+		public OAuth2FeignRequestInterceptorConfigurer loadBalancerInterceptorInjectingConfigurer(
+				final LoadBalancerInterceptor loadBalancerInterceptor) {
+			return builder -> builder.withAccessTokenProviderInterceptors(loadBalancerInterceptor);
 		}
 
-		@Conditional(HystrixDisabledConditions.class)
+		@Bean
-		static class HystrixDisabled {
+		@ConditionalOnMissingBean(OAuth2FeignRequestInterceptor.class)
-
+		@ConditionalOnBean({ OAuth2ClientContext.class, OAuth2ProtectedResourceDetails.class })
+		public RequestInterceptor oauth2FeignRequestInterceptor(OAuth2ClientContext oAuth2ClientContext,
+				OAuth2ProtectedResourceDetails resource, List<OAuth2FeignRequestInterceptorConfigurer> configurers) {
+			return buildWithConfigurers(oAuth2ClientContext, resource, configurers);
 		}
 
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2019 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.

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

@@ -0,0 +1,82 @@
+/*
+ * 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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -26,6 +26,8 @@ import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
  * Allows Feign interfaces to work with {@link CircuitBreaker}.
  *
  * @author Marcin Grzejszczak
+ * @author Andrii Bohutskyi
+ * @author Kwangyong Kim
  * @since 3.0.0
  */
 public final class FeignCircuitBreaker {
@@ -50,6 +52,10 @@ public final class FeignCircuitBreaker {
 
 		private String feignClientName;
 
+		private boolean circuitBreakerGroupEnabled;
+
+		private CircuitBreakerNameResolver circuitBreakerNameResolver;
+
 		Builder circuitBreakerFactory(CircuitBreakerFactory circuitBreakerFactory) {
 			this.circuitBreakerFactory = circuitBreakerFactory;
 			return this;
@@ -60,14 +66,21 @@ public final class FeignCircuitBreaker {
 			return this;
 		}
 
-		public <T> T target(Target<T> target, T fallback) {
+		Builder circuitBreakerGroupEnabled(boolean circuitBreakerGroupEnabled) {
-			return build(
+			this.circuitBreakerGroupEnabled = circuitBreakerGroupEnabled;
-					fallback != null ? new FallbackFactory.Default<T>(fallback) : null)
+			return this;
-							.newInstance(target);
 		}
 
-		public <T> T target(Target<T> target,
+		Builder circuitBreakerNameResolver(CircuitBreakerNameResolver circuitBreakerNameResolver) {
-				FallbackFactory<? extends T> fallbackFactory) {
+			this.circuitBreakerNameResolver = circuitBreakerNameResolver;
+			return this;
+		}
+
+		public <T> T target(Target<T> target, T fallback) {
+			return build(fallback != null ? new FallbackFactory.Default<T>(fallback) : null).newInstance(target);
+		}
+
+		public <T> T target(Target<T> target, FallbackFactory<? extends T> fallbackFactory) {
 			return build(fallbackFactory).newInstance(target);
 		}
 
@@ -77,10 +90,9 @@ public final class FeignCircuitBreaker {
 		}
 
 		public Feign build(final FallbackFactory<?> nullableFallbackFactory) {
-			super.invocationHandlerFactory(
+			super.invocationHandlerFactory((target, dispatch) -> new FeignCircuitBreakerInvocationHandler(
-					(target, dispatch) -> new FeignCircuitBreakerInvocationHandler(
+					circuitBreakerFactory, feignClientName, target, dispatch, nullableFallbackFactory,
-							circuitBreakerFactory, target, dispatch,
+					circuitBreakerGroupEnabled, circuitBreakerNameResolver));
-							nullableFallbackFactory));
 			return super.build();
 		}
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -31,7 +31,7 @@ class FeignCircuitBreakerDisabledConditions extends AnyNestedCondition {
 
 	}
 
-	@ConditionalOnProperty(value = "feign.circuitbreaker.enabled", havingValue = "false",
+	@ConditionalOnProperty(value = "spring.cloud.openfeign.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-2020 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.
@@ -17,6 +17,7 @@
 package org.springframework.cloud.openfeign;
 
 import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.LinkedHashMap;
@@ -24,12 +25,14 @@ import java.util.Map;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-import feign.Feign;
 import feign.InvocationHandlerFactory;
 import feign.Target;
 
 import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
 import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
+import org.springframework.cloud.client.circuitbreaker.NoFallbackAvailableException;
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.context.request.RequestContextHolder;
 
 import static feign.Util.checkNotNull;
 
@@ -37,6 +40,8 @@ class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 
 	private final CircuitBreakerFactory factory;
 
+	private final String feignClientName;
+
 	private final Target<?> target;
 
 	private final Map<Method, InvocationHandlerFactory.MethodHandler> dispatch;
@@ -45,25 +50,30 @@ class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 
 	private final Map<Method, Method> fallbackMethodMap;
 
-	FeignCircuitBreakerInvocationHandler(CircuitBreakerFactory factory, Target<?> target,
+	private final boolean circuitBreakerGroupEnabled;
-			Map<Method, InvocationHandlerFactory.MethodHandler> dispatch,
+
-			FallbackFactory<?> nullableFallbackFactory) {
+	private final CircuitBreakerNameResolver circuitBreakerNameResolver;
+
+	FeignCircuitBreakerInvocationHandler(CircuitBreakerFactory factory, String feignClientName, Target<?> target,
+			Map<Method, InvocationHandlerFactory.MethodHandler> dispatch, FallbackFactory<?> nullableFallbackFactory,
+			boolean circuitBreakerGroupEnabled, CircuitBreakerNameResolver circuitBreakerNameResolver) {
 		this.factory = factory;
+		this.feignClientName = feignClientName;
 		this.target = checkNotNull(target, "target");
 		this.dispatch = checkNotNull(dispatch, "dispatch");
 		this.fallbackMethodMap = toFallbackMethod(dispatch);
 		this.nullableFallbackFactory = nullableFallbackFactory;
+		this.circuitBreakerGroupEnabled = circuitBreakerGroupEnabled;
+		this.circuitBreakerNameResolver = circuitBreakerNameResolver;
 	}
 
 	@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 {
-			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())) {
 			try {
-				Object otherHandler = args.length > 0 && args[0] != null
+				Object otherHandler = args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
-						? Proxy.getInvocationHandler(args[0]) : null;
 				return equals(otherHandler);
 			}
 			catch (IllegalArgumentException e) {
@@ -76,8 +86,10 @@ class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 		else if ("toString".equals(method.getName())) {
 			return toString();
 		}
-		String circuitName = Feign.configKey(target.type(), method);
+
-		CircuitBreaker circuitBreaker = this.factory.create(circuitName);
+		String circuitName = circuitBreakerNameResolver.resolveCircuitBreakerName(feignClientName, target, method);
+		CircuitBreaker circuitBreaker = circuitBreakerGroupEnabled ? factory.create(circuitName, feignClientName)
+				: factory.create(circuitName);
 		Supplier<Object> supplier = asSupplier(method, args);
 		if (this.nullableFallbackFactory != null) {
 			Function<Throwable, Object> fallbackFunction = throwable -> {
@@ -85,19 +97,35 @@ class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 				try {
 					return this.fallbackMethodMap.get(method).invoke(fallback, args);
 				}
-				catch (Exception e) {
+				catch (Exception exception) {
-					throw new IllegalStateException(e);
+					unwrapAndRethrow(exception);
 				}
+				return null;
 			};
 			return circuitBreaker.run(supplier, fallbackFunction);
 		}
 		return circuitBreaker.run(supplier);
 	}
 
+	private void unwrapAndRethrow(Exception exception) {
+		if (exception instanceof InvocationTargetException || exception instanceof NoFallbackAvailableException) {
+			Throwable underlyingException = exception.getCause();
+			if (underlyingException instanceof RuntimeException) {
+				throw (RuntimeException) underlyingException;
+			}
+			if (underlyingException != null) {
+				throw new IllegalStateException(underlyingException);
+			}
+			throw new IllegalStateException(exception);
+		}
+	}
+
 	private Supplier<Object> asSupplier(final Method method, final Object[] args) {
+		final RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
 		return () -> {
 			try {
-				return this.dispatch.get(method).invoke(args);
+				RequestContextHolder.setRequestAttributes(requestAttributes);
+				return dispatch.get(method).invoke(args);
 			}
 			catch (RuntimeException throwable) {
 				throw throwable;
@@ -117,8 +145,7 @@ class FeignCircuitBreakerInvocationHandler implements InvocationHandler {
 	 * reflection calls.
 	 * @return cached methods map for fallback invoking
 	 */
-	static Map<Method, Method> toFallbackMethod(
+	static Map<Method, Method> toFallbackMethod(Map<Method, InvocationHandlerFactory.MethodHandler> dispatch) {
-			Map<Method, InvocationHandlerFactory.MethodHandler> dispatch) {
 		Map<Method, Method> result = new LinkedHashMap<Method, Method>();
 		for (Method method : dispatch.keySet()) {
 			method.setAccessible(true);

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -27,71 +27,70 @@ class FeignCircuitBreakerTargeter implements Targeter {
 
 	private final CircuitBreakerFactory circuitBreakerFactory;
 
-	FeignCircuitBreakerTargeter(CircuitBreakerFactory circuitBreakerFactory) {
+	private final boolean circuitBreakerGroupEnabled;
+
+	private final CircuitBreakerNameResolver circuitBreakerNameResolver;
+
+	FeignCircuitBreakerTargeter(CircuitBreakerFactory circuitBreakerFactory, boolean circuitBreakerGroupEnabled,
+			CircuitBreakerNameResolver circuitBreakerNameResolver) {
 		this.circuitBreakerFactory = circuitBreakerFactory;
+		this.circuitBreakerGroupEnabled = circuitBreakerGroupEnabled;
+		this.circuitBreakerNameResolver = circuitBreakerNameResolver;
 	}
 
 	@Override
-	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
+	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
-			FeignContext context, Target.HardCodedTarget<T> target) {
+			Target.HardCodedTarget<T> target) {
 		if (!(feign instanceof FeignCircuitBreaker.Builder)) {
 			return feign.target(target);
 		}
 		FeignCircuitBreaker.Builder builder = (FeignCircuitBreaker.Builder) feign;
-		String name = !StringUtils.hasText(factory.getContextId()) ? factory.getName()
+		String name = !StringUtils.hasText(factory.getContextId()) ? factory.getName() : factory.getContextId();
-				: factory.getContextId();
 		Class<?> fallback = factory.getFallback();
 		if (fallback != void.class) {
 			return targetWithFallback(name, context, target, builder, fallback);
 		}
 		Class<?> fallbackFactory = factory.getFallbackFactory();
 		if (fallbackFactory != void.class) {
-			return targetWithFallbackFactory(name, context, target, builder,
+			return targetWithFallbackFactory(name, context, target, builder, fallbackFactory);
-					fallbackFactory);
 		}
 		return builder(name, builder).target(target);
 	}
 
 	private <T> T targetWithFallbackFactory(String feignClientName, FeignContext context,
-			Target.HardCodedTarget<T> target, FeignCircuitBreaker.Builder builder,
+			Target.HardCodedTarget<T> target, FeignCircuitBreaker.Builder builder, Class<?> fallbackFactoryClass) {
-			Class<?> fallbackFactoryClass) {
+		FallbackFactory<? extends T> fallbackFactory = (FallbackFactory<? extends T>) getFromContext("fallbackFactory",
-		FallbackFactory<? extends T> fallbackFactory = (FallbackFactory<? extends T>) getFromContext(
+				feignClientName, context, fallbackFactoryClass, FallbackFactory.class);
-				"fallbackFactory", feignClientName, context, fallbackFactoryClass,
-				FallbackFactory.class);
 		return builder(feignClientName, builder).target(target, fallbackFactory);
 	}
 
-	private <T> T targetWithFallback(String feignClientName, FeignContext context,
+	private <T> T targetWithFallback(String feignClientName, FeignContext context, Target.HardCodedTarget<T> target,
-			Target.HardCodedTarget<T> target, FeignCircuitBreaker.Builder builder,
+			FeignCircuitBreaker.Builder builder, Class<?> fallback) {
-			Class<?> fallback) {
+		T fallbackInstance = getFromContext("fallback", feignClientName, context, fallback, target.type());
-		T fallbackInstance = getFromContext("fallback", feignClientName, context,
-				fallback, target.type());
 		return builder(feignClientName, builder).target(target, fallbackInstance);
 	}
 
-	private <T> T getFromContext(String fallbackMechanism, String feignClientName,
+	private <T> T getFromContext(String fallbackMechanism, String feignClientName, FeignContext context,
-			FeignContext context, Class<?> beanType, Class<T> targetType) {
+			Class<?> beanType, Class<T> targetType) {
 		Object fallbackInstance = context.getInstance(feignClientName, beanType);
 		if (fallbackInstance == null) {
-			throw new IllegalStateException(String.format(
+			throw new IllegalStateException(
-					"No " + fallbackMechanism
+					String.format("No " + fallbackMechanism + " instance of type %s found for feign client %s",
-							+ " instance of type %s found for feign client %s",
 							beanType, feignClientName));
 		}
 
 		if (!targetType.isAssignableFrom(beanType)) {
-			throw new IllegalStateException(String.format("Incompatible "
+			throw new IllegalStateException(String.format("Incompatible " + fallbackMechanism
-					+ fallbackMechanism
 					+ " instance. Fallback/fallbackFactory of type %s is not assignable to %s for feign client %s",
 					beanType, targetType, feignClientName));
 		}
 		return (T) fallbackInstance;
 	}
 
-	private FeignCircuitBreaker.Builder builder(String feignClientName,
+	private FeignCircuitBreaker.Builder builder(String feignClientName, FeignCircuitBreaker.Builder builder) {
-			FeignCircuitBreaker.Builder builder) {
+		return builder.circuitBreakerFactory(circuitBreakerFactory).feignClientName(feignClientName)
-		return builder.circuitBreakerFactory(this.circuitBreakerFactory)
+				.circuitBreakerGroupEnabled(circuitBreakerGroupEnabled)
-				.feignClientName(feignClientName);
+				.circuitBreakerNameResolver(circuitBreakerNameResolver);
 	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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.
@@ -27,9 +27,9 @@ import org.springframework.core.annotation.AliasFor;
 
 /**
  * Annotation for interfaces declaring that a REST client with that interface should be
- * created (e.g. for autowiring into another component). If ribbon is available it will be
+ * created (e.g. for autowiring into another component). If SC LoadBalancer is available
- * used to load balance the backend requests, and the load balancer can be configured
+ * it will be used to load balance the backend requests, and the load balancer can be
- * using a <code>@RibbonClient</code> with the same name (i.e. value) as the feign client.
+ * configured using the same name (i.e. value) as the feign client.
  *
  * @author Spencer Gibb
  * @author Venil Noronha
@@ -50,14 +50,6 @@ public @interface FeignClient {
 	@AliasFor("name")
 	String value() default "";
 
-	/**
-	 * The service id with optional protocol prefix. Synonym for {@link #value() value}.
-	 * @deprecated use {@link #name() name} instead
-	 * @return the service id with optional protocol prefix
-	 */
-	@Deprecated
-	String serviceId() default "";
-
 	/**
 	 * This will be used as the bean name instead of name if present, but will not be used
 	 * as a service id.
@@ -128,15 +120,13 @@ public @interface FeignClient {
 	 * factory must produce instances of fallback classes that implement the interface
 	 * annotated by {@link FeignClient}. The fallback factory must be a valid spring bean.
 	 *
-	 * @see feign.hystrix.FallbackFactory for details.
 	 * @see FallbackFactory for details.
 	 * @return fallback factory for the specified Feign client interface
 	 */
 	Class<?> fallbackFactory() default void.class;
 
 	/**
-	 * @return path prefix to be used by all method-level mappings. Can be used with or
+	 * @return path prefix to be used by all method-level mappings.
-	 * without <code>@RibbonClient</code>.
 	 */
 	String path() default "";
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -17,7 +17,6 @@
 package org.springframework.cloud.openfeign;
 
 import feign.Feign;
-import feign.hystrix.FallbackFactory;
 
 import org.springframework.context.ApplicationContext;
 
@@ -43,6 +42,11 @@ public class FeignClientBuilder {
 		return new Builder<>(this.applicationContext, type, name);
 	}
 
+	public <T> Builder<T> forType(final Class<T> type, final FeignClientFactoryBean clientFactoryBean,
+			final String name) {
+		return new Builder<>(this.applicationContext, clientFactoryBean, type, name);
+	}
+
 	/**
 	 * Builder of feign targets.
 	 *
@@ -52,9 +56,13 @@ public class FeignClientBuilder {
 
 		private FeignClientFactoryBean feignClientFactoryBean;
 
-		private Builder(final ApplicationContext applicationContext, final Class<T> type,
+		private Builder(final ApplicationContext applicationContext, final Class<T> type, final String name) {
-				final String name) {
+			this(applicationContext, new FeignClientFactoryBean(), type, name);
-			this.feignClientFactoryBean = new FeignClientFactoryBean();
+		}
+
+		private Builder(final ApplicationContext applicationContext, final FeignClientFactoryBean clientFactoryBean,
+				final Class<T> type, final String name) {
+			this.feignClientFactoryBean = clientFactoryBean;
 
 			this.feignClientFactoryBean.setApplicationContext(applicationContext);
 			this.feignClientFactoryBean.setType(type);
@@ -109,13 +117,6 @@ public class FeignClientBuilder {
 			return this;
 		}
 
-		public Builder<T> fallbackFactory(
-				final Class<? extends FallbackFactory<? extends T>> fallbackFactory) {
-			FeignClientsRegistrar.validateFallbackFactory(fallbackFactory);
-			this.feignClientFactoryBean.setFallbackFactory(fallbackFactory);
-			return this;
-		}
-
 		/**
 		 * @return the created Feign client
 		 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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.
@@ -17,11 +17,13 @@
 package org.springframework.cloud.openfeign;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
+import feign.Capability;
 import feign.Client;
 import feign.Contract;
 import feign.ExceptionPropagationPolicy;
@@ -48,7 +50,6 @@ import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.cloud.openfeign.clientconfig.FeignClientConfigurer;
 import org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalancerClient;
 import org.springframework.cloud.openfeign.loadbalancer.RetryableFeignBlockingLoadBalancerClient;
-import org.springframework.cloud.openfeign.ribbon.LoadBalancerFeignClient;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.core.annotation.AnnotationAwareOrderComparator;
@@ -64,10 +65,14 @@ import org.springframework.util.StringUtils;
  * @author Olga Maciaszek-Sharma
  * @author Ilia Ilinykh
  * @author Marcin Grzejszczak
+ * @author Jonatan Ivanov
  * @author Sam Kruglov
+ * @author Jasbir Singh
+ * @author Hyeonmin Park
+ * @author Felix Dittrich
  */
-public class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
+public class FeignClientFactoryBean
-		ApplicationContextAware, BeanFactoryAware {
+		implements FactoryBean<Object>, InitializingBean, ApplicationContextAware, BeanFactoryAware {
 
 	/***********************************
 	 * WARNING! Nothing in this class should be @Autowired. It causes NPEs because of some
@@ -104,7 +109,9 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 
 	private boolean followRedirects = new Request.Options().isFollowRedirects();
 
-	private List<FeignBuilderCustomizer> additionalCustomizers = new ArrayList<>();
+	private boolean refreshableClient = false;
+
+	private final List<FeignBuilderCustomizer> additionalCustomizers = new ArrayList<>();
 
 	@Override
 	public void afterPropertiesSet() {
@@ -126,45 +133,36 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 		// @formatter:on
 
 		configureFeign(context, builder);
-		applyBuildCustomizers(context, builder);
 
 		return builder;
 	}
 
 	private void applyBuildCustomizers(FeignContext context, Feign.Builder builder) {
-		Map<String, FeignBuilderCustomizer> customizerMap = context
+		Map<String, FeignBuilderCustomizer> customizerMap = context.getInstances(contextId,
-				.getInstances(contextId, FeignBuilderCustomizer.class);
+				FeignBuilderCustomizer.class);
 
 		if (customizerMap != null) {
-			customizerMap.values().stream()
+			customizerMap.values().stream().sorted(AnnotationAwareOrderComparator.INSTANCE)
-					.sorted(AnnotationAwareOrderComparator.INSTANCE)
+					.forEach(feignBuilderCustomizer -> feignBuilderCustomizer.customize(builder));
-					.forEach(feignBuilderCustomizer -> feignBuilderCustomizer
-							.customize(builder));
 		}
 		additionalCustomizers.forEach(customizer -> customizer.customize(builder));
 	}
 
 	protected void configureFeign(FeignContext context, Feign.Builder builder) {
-		FeignClientProperties properties = beanFactory != null
+		FeignClientProperties properties = beanFactory != null ? beanFactory.getBean(FeignClientProperties.class)
-				? beanFactory.getBean(FeignClientProperties.class)
 				: applicationContext.getBean(FeignClientProperties.class);
 
-		FeignClientConfigurer feignClientConfigurer = getOptional(context,
+		FeignClientConfigurer feignClientConfigurer = getOptional(context, FeignClientConfigurer.class);
-				FeignClientConfigurer.class);
 		setInheritParentContext(feignClientConfigurer.inheritParentConfiguration());
 
 		if (properties != null && inheritParentContext) {
 			if (properties.isDefaultToProperties()) {
 				configureUsingConfiguration(context, builder);
-				configureUsingProperties(
+				configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
-						properties.getConfig().get(properties.getDefaultConfig()),
-						builder);
 				configureUsingProperties(properties.getConfig().get(contextId), builder);
 			}
 			else {
-				configureUsingProperties(
+				configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
-						properties.getConfig().get(properties.getDefaultConfig()),
-						builder);
 				configureUsingProperties(properties.getConfig().get(contextId), builder);
 				configureUsingConfiguration(context, builder);
 			}
@@ -174,8 +172,7 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 		}
 	}
 
-	protected void configureUsingConfiguration(FeignContext context,
+	protected void configureUsingConfiguration(FeignContext context, Feign.Builder builder) {
-			Feign.Builder builder) {
 		Logger.Level level = getInheritedAwareOptional(context, Logger.Level.class);
 		if (level != null) {
 			builder.logLevel(level);
@@ -184,52 +181,56 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 		if (retryer != null) {
 			builder.retryer(retryer);
 		}
-		ErrorDecoder errorDecoder = getInheritedAwareOptional(context,
+		ErrorDecoder errorDecoder = getInheritedAwareOptional(context, ErrorDecoder.class);
-				ErrorDecoder.class);
 		if (errorDecoder != null) {
 			builder.errorDecoder(errorDecoder);
 		}
 		else {
-			FeignErrorDecoderFactory errorDecoderFactory = getOptional(context,
+			FeignErrorDecoderFactory errorDecoderFactory = getOptional(context, FeignErrorDecoderFactory.class);
-					FeignErrorDecoderFactory.class);
 			if (errorDecoderFactory != null) {
 				ErrorDecoder factoryErrorDecoder = errorDecoderFactory.create(type);
 				builder.errorDecoder(factoryErrorDecoder);
 			}
 		}
-		Request.Options options = getInheritedAwareOptional(context,
+		Request.Options options = getInheritedAwareOptional(context, Request.Options.class);
-				Request.Options.class);
+		if (options == null) {
+			options = getOptionsByName(context, contextId);
+		}
+
 		if (options != null) {
 			builder.options(options);
 			readTimeoutMillis = options.readTimeoutMillis();
 			connectTimeoutMillis = options.connectTimeoutMillis();
 			followRedirects = options.isFollowRedirects();
 		}
-		Map<String, RequestInterceptor> requestInterceptors = getInheritedAwareInstances(
+		Map<String, RequestInterceptor> requestInterceptors = getInheritedAwareInstances(context,
-				context, RequestInterceptor.class);
+				RequestInterceptor.class);
 		if (requestInterceptors != null) {
-			List<RequestInterceptor> interceptors = new ArrayList<>(
+			List<RequestInterceptor> interceptors = new ArrayList<>(requestInterceptors.values());
-					requestInterceptors.values());
 			AnnotationAwareOrderComparator.sort(interceptors);
 			builder.requestInterceptors(interceptors);
 		}
-		QueryMapEncoder queryMapEncoder = getInheritedAwareOptional(context,
+		QueryMapEncoder queryMapEncoder = getInheritedAwareOptional(context, QueryMapEncoder.class);
-				QueryMapEncoder.class);
 		if (queryMapEncoder != null) {
 			builder.queryMapEncoder(queryMapEncoder);
 		}
 		if (decode404) {
 			builder.decode404();
 		}
-		ExceptionPropagationPolicy exceptionPropagationPolicy = getInheritedAwareOptional(
+		ExceptionPropagationPolicy exceptionPropagationPolicy = getInheritedAwareOptional(context,
-				context, ExceptionPropagationPolicy.class);
+				ExceptionPropagationPolicy.class);
 		if (exceptionPropagationPolicy != null) {
 			builder.exceptionPropagationPolicy(exceptionPropagationPolicy);
 		}
+
+		Map<String, Capability> capabilities = getInheritedAwareInstances(context, Capability.class);
+		if (capabilities != null) {
+			capabilities.values().stream().sorted(AnnotationAwareOrderComparator.INSTANCE)
+					.forEach(builder::addCapability);
+		}
 	}
 
-	protected void configureUsingProperties(
+	protected void configureUsingProperties(FeignClientProperties.FeignClientConfiguration config,
-			FeignClientProperties.FeignClientConfiguration config,
 			Feign.Builder builder) {
 		if (config == null) {
 			return;
@@ -239,15 +240,15 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 			builder.logLevel(config.getLoggerLevel());
 		}
 
-		connectTimeoutMillis = config.getConnectTimeout() != null
+		if (!refreshableClient) {
-				? config.getConnectTimeout() : connectTimeoutMillis;
+			connectTimeoutMillis = config.getConnectTimeout() != null ? config.getConnectTimeout()
-		readTimeoutMillis = config.getReadTimeout() != null ? config.getReadTimeout()
+					: connectTimeoutMillis;
-				: readTimeoutMillis;
+			readTimeoutMillis = config.getReadTimeout() != null ? config.getReadTimeout() : readTimeoutMillis;
-		followRedirects = config.isFollowRedirects() != null ? config.isFollowRedirects()
+			followRedirects = config.isFollowRedirects() != null ? config.isFollowRedirects() : followRedirects;
-				: followRedirects;
 
-		builder.options(new Request.Options(connectTimeoutMillis, TimeUnit.MILLISECONDS,
+			builder.options(new Request.Options(connectTimeoutMillis, TimeUnit.MILLISECONDS, readTimeoutMillis,
-				readTimeoutMillis, TimeUnit.MILLISECONDS, followRedirects));
+					TimeUnit.MILLISECONDS, followRedirects));
+		}
 
 		if (config.getRetryer() != null) {
 			Retryer retryer = getOrInstantiate(config.getRetryer());
@@ -259,8 +260,7 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 			builder.errorDecoder(errorDecoder);
 		}
 
-		if (config.getRequestInterceptors() != null
+		if (config.getRequestInterceptors() != null && !config.getRequestInterceptors().isEmpty()) {
-				&& !config.getRequestInterceptors().isEmpty()) {
 			// this will add request interceptor to builder, not replace existing
 			for (Class<RequestInterceptor> bean : config.getRequestInterceptors()) {
 				RequestInterceptor interceptor = getOrInstantiate(bean);
@@ -278,15 +278,8 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 			builder.encoder(getOrInstantiate(config.getEncoder()));
 		}
 
-		if (Objects.nonNull(config.getDefaultRequestHeaders())) {
+		addDefaultRequestHeaders(config, builder);
-			builder.requestInterceptor(requestTemplate -> requestTemplate
+		addDefaultQueryParams(config, builder);
-					.headers(config.getDefaultRequestHeaders()));
-		}
-
-		if (Objects.nonNull(config.getDefaultQueryParameters())) {
-			builder.requestInterceptor(requestTemplate -> requestTemplate
-					.queries(config.getDefaultQueryParameters()));
-		}
 
 		if (Objects.nonNull(config.getDecoder())) {
 			builder.decoder(getOrInstantiate(config.getDecoder()));
@@ -299,12 +292,48 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 		if (Objects.nonNull(config.getExceptionPropagationPolicy())) {
 			builder.exceptionPropagationPolicy(config.getExceptionPropagationPolicy());
 		}
+
+		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) {
+		Map<String, Collection<String>> defaultQueryParameters = config.getDefaultQueryParameters();
+		if (Objects.nonNull(defaultQueryParameters)) {
+			builder.requestInterceptor(requestTemplate -> {
+				Map<String, Collection<String>> queries = requestTemplate.queries();
+				defaultQueryParameters.keySet().forEach(key -> {
+					if (!queries.containsKey(key)) {
+						requestTemplate.query(key, defaultQueryParameters.get(key));
+					}
+				});
+			});
+		}
+	}
+
+	private void addDefaultRequestHeaders(FeignClientProperties.FeignClientConfiguration config,
+			Feign.Builder builder) {
+		Map<String, Collection<String>> defaultRequestHeaders = config.getDefaultRequestHeaders();
+		if (Objects.nonNull(defaultRequestHeaders)) {
+			builder.requestInterceptor(requestTemplate -> {
+				Map<String, Collection<String>> headers = requestTemplate.headers();
+				defaultRequestHeaders.keySet().forEach(key -> {
+					if (!headers.containsKey(key)) {
+						requestTemplate.header(key, defaultRequestHeaders.get(key));
+					}
+				});
+			});
+		}
 	}
 
 	private <T> T getOrInstantiate(Class<T> tClass) {
 		try {
-			return beanFactory != null ? beanFactory.getBean(tClass)
+			return beanFactory != null ? beanFactory.getBean(tClass) : applicationContext.getBean(tClass);
-					: applicationContext.getBean(tClass);
 		}
 		catch (NoSuchBeanDefinitionException e) {
 			return BeanUtils.instantiateClass(tClass);
@@ -314,8 +343,7 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 	protected <T> T get(FeignContext context, Class<T> type) {
 		T instance = context.getInstance(contextId, type);
 		if (instance == null) {
-			throw new IllegalStateException(
+			throw new IllegalStateException("No bean found of type " + type + " for " + contextId);
-					"No bean found of type " + type + " for " + contextId);
 		}
 		return instance;
 	}
@@ -333,8 +361,7 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 		}
 	}
 
-	protected <T> Map<String, T> getInheritedAwareInstances(FeignContext context,
+	protected <T> Map<String, T> getInheritedAwareInstances(FeignContext context, Class<T> type) {
-			Class<T> type) {
 		if (inheritParentContext) {
 			return context.getInstances(contextId, type);
 		}
@@ -343,17 +370,31 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 		}
 	}
 
-	protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
+	protected <T> T loadBalance(Feign.Builder builder, FeignContext context, HardCodedTarget<T> target) {
-			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);
 		}
 
 		throw new IllegalStateException(
-				"No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon or spring-cloud-starter-loadbalancer?");
+				"No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-loadbalancer?");
+	}
+
+	/**
+	 * Meant to get Options bean from context with bean name.
+	 * @param context context of Feign client
+	 * @param contextId name of feign client
+	 * @return returns Options found in context
+	 */
+	protected Request.Options getOptionsByName(FeignContext context, String contextId) {
+		if (refreshableClient) {
+			return context.getInstance(contextId, Request.Options.class.getCanonicalName() + "-" + contextId,
+					Request.Options.class);
+		}
+		return null;
 	}
 
 	@Override
@@ -367,16 +408,14 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 	 * information
 	 */
 	<T> T getTarget() {
-		FeignContext context = beanFactory != null
+		FeignContext context = beanFactory != null ? beanFactory.getBean(FeignContext.class)
-				? beanFactory.getBean(FeignContext.class)
 				: applicationContext.getBean(FeignContext.class);
 		Feign.Builder builder = feign(context);
 
 		if (!StringUtils.hasText(url)) {
 
 			if (LOG.isInfoEnabled()) {
-				LOG.info("For '" + name
+				LOG.info("For '" + name + "' URL not provided. Will try picking an instance via load-balancing.");
-						+ "' URL not provided. Will try picking an instance via load-balancing.");
 			}
 			if (!name.startsWith("http")) {
 				url = "http://" + name;
@@ -385,8 +424,7 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 				url = name;
 			}
 			url += cleanPath();
-			return (T) loadBalance(builder, context,
+			return (T) loadBalance(builder, context, new HardCodedTarget<>(type, name, url));
-					new HardCodedTarget<>(type, name, url));
 		}
 		if (StringUtils.hasText(url) && !url.startsWith("http")) {
 			url = "http://" + url;
@@ -394,11 +432,6 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 		String url = this.url + cleanPath();
 		Client client = getOptional(context, Client.class);
 		if (client != null) {
-			if (client instanceof LoadBalancerFeignClient) {
-				// not load balancing because we have a url,
-				// but ribbon is on the classpath, so unwrap
-				client = ((LoadBalancerFeignClient) client).getDelegate();
-			}
 			if (client instanceof FeignBlockingLoadBalancerClient) {
 				// not load balancing because we have a url,
 				// but Spring Cloud LoadBalancer is on the classpath, so unwrap
@@ -407,17 +440,21 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 			if (client instanceof RetryableFeignBlockingLoadBalancerClient) {
 				// not load balancing because we have a url,
 				// but Spring Cloud LoadBalancer is on the classpath, so unwrap
-				client = ((RetryableFeignBlockingLoadBalancerClient) client)
+				client = ((RetryableFeignBlockingLoadBalancerClient) client).getDelegate();
-						.getDelegate();
 			}
 			builder.client(client);
 		}
+
+		applyBuildCustomizers(context, builder);
+
 		Targeter targeter = get(context, Targeter.class);
-		return (T) targeter.target(this, builder, context,
+		return (T) targeter.target(this, builder, context, new HardCodedTarget<>(type, name, url));
-				new HardCodedTarget<>(type, name, url));
 	}
 
 	private String cleanPath() {
+		if (path == null) {
+			return "";
+		}
 		String path = this.path.trim();
 		if (StringUtils.hasLength(path)) {
 			if (!path.startsWith("/")) {
@@ -526,6 +563,10 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 		this.fallbackFactory = fallbackFactory;
 	}
 
+	public void setRefreshableClient(boolean refreshableClient) {
+		this.refreshableClient = refreshableClient;
+	}
+
 	@Override
 	public boolean equals(Object o) {
 		if (this == o) {
@@ -536,40 +577,33 @@ public class FeignClientFactoryBean implements FactoryBean<Object>, Initializing
 		}
 		FeignClientFactoryBean that = (FeignClientFactoryBean) o;
 		return Objects.equals(applicationContext, that.applicationContext)
-				&& Objects.equals(beanFactory, that.beanFactory)
+				&& Objects.equals(beanFactory, that.beanFactory) && decode404 == that.decode404
-				&& decode404 == that.decode404
+				&& inheritParentContext == that.inheritParentContext && Objects.equals(fallback, that.fallback)
-				&& inheritParentContext == that.inheritParentContext
+				&& Objects.equals(fallbackFactory, that.fallbackFactory) && Objects.equals(name, that.name)
-				&& Objects.equals(fallback, that.fallback)
+				&& Objects.equals(path, that.path) && Objects.equals(type, that.type) && Objects.equals(url, that.url)
-				&& 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)
 				&& Objects.equals(connectTimeoutMillis, that.connectTimeoutMillis)
 				&& Objects.equals(readTimeoutMillis, that.readTimeoutMillis)
-				&& Objects.equals(followRedirects, that.followRedirects);
+				&& Objects.equals(followRedirects, that.followRedirects)
+				&& Objects.equals(refreshableClient, that.refreshableClient);
 	}
 
 	@Override
 	public int hashCode() {
-		return Objects.hash(applicationContext, beanFactory, decode404,
+		return Objects.hash(applicationContext, beanFactory, decode404, inheritParentContext, fallback, fallbackFactory,
-				inheritParentContext, fallback, fallbackFactory, name, path, type, url,
+				name, path, type, url, readTimeoutMillis, connectTimeoutMillis, followRedirects, refreshableClient);
-				readTimeoutMillis, connectTimeoutMillis, followRedirects);
 	}
 
 	@Override
 	public String toString() {
-		return new StringBuilder("FeignClientFactoryBean{").append("type=").append(type)
+		return new StringBuilder("FeignClientFactoryBean{").append("type=").append(type).append(", ").append("name='")
-				.append(", ").append("name='").append(name).append("', ").append("url='")
+				.append(name).append("', ").append("url='").append(url).append("', ").append("path='").append(path)
-				.append(url).append("', ").append("path='").append(path).append("', ")
+				.append("', ").append("decode404=").append(decode404).append(", ").append("inheritParentContext=")
-				.append("decode404=").append(decode404).append(", ")
+				.append(inheritParentContext).append(", ").append("applicationContext=").append(applicationContext)
-				.append("inheritParentContext=").append(inheritParentContext).append(", ")
+				.append(", ").append("beanFactory=").append(beanFactory).append(", ").append("fallback=")
-				.append("applicationContext=").append(applicationContext).append(", ")
+				.append(fallback).append(", ").append("fallbackFactory=").append(fallbackFactory).append("}")
-				.append("beanFactory=").append(beanFactory).append(", ")
+				.append("connectTimeoutMillis=").append(connectTimeoutMillis).append("}").append("readTimeoutMillis=")
-				.append("fallback=").append(fallback).append(", ")
+				.append(readTimeoutMillis).append("}").append("followRedirects=").append(followRedirects)
-				.append("fallbackFactory=").append(fallbackFactory).append("}")
+				.append("refreshableClient=").append(refreshableClient).append("}").toString();
-				.append("connectTimeoutMillis=").append(connectTimeoutMillis).append("}")
-				.append("readTimeoutMillis=").append(readTimeoutMillis).append("}")
-				.append("followRedirects=").append(followRedirects).append("}")
-				.toString();
 	}
 
 	@Override

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2021-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.Map;
+
+import org.springframework.context.annotation.Condition;
+import org.springframework.context.annotation.ConditionContext;
+import org.springframework.core.type.AnnotatedTypeMetadata;
+
+/**
+ * @author Jonatan Ivanov
+ */
+class FeignClientMetricsEnabledCondition implements Condition {
+
+	@Override
+	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
+		FeignClientProperties feignClientProperties = context.getBeanFactory()
+				.getBeanProvider(FeignClientProperties.class).getIfAvailable();
+		if (feignClientProperties != null) {
+			Map<String, FeignClientProperties.FeignClientConfiguration> feignClientConfigMap = feignClientProperties
+					.getConfig();
+			if (feignClientConfigMap != null) {
+				FeignClientProperties.FeignClientConfiguration feignClientConfig = feignClientConfigMap
+						.get(context.getEnvironment().getProperty("spring.cloud.openfeign.client.name"));
+				if (feignClientConfig != null) {
+					FeignClientProperties.MetricsProperties metrics = feignClientConfig.getMetrics();
+					if (metrics != null && metrics.getEnabled() != null) {
+						return metrics.getEnabled();
+					}
+				}
+			}
+		}
+
+		return true;
+	}
+
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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,9 +22,11 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
+import feign.Capability;
 import feign.Contract;
 import feign.ExceptionPropagationPolicy;
 import feign.Logger;
+import feign.QueryMapEncoder;
 import feign.RequestInterceptor;
 import feign.Retryer;
 import feign.codec.Decoder;
@@ -37,9 +39,11 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
  * @author Eko Kurniawan Khannedy
  * @author Ilia Ilinykh
  * @author Ram Anaswara
+ * @author Jonatan Ivanov
  * @author Olga Maciaszek-Sharma
+ * @author Hyeonmin Park
  */
-@ConfigurationProperties("feign.client")
+@ConfigurationProperties("spring.cloud.openfeign.client")
 public class FeignClientProperties {
 
 	private boolean defaultToProperties = true;
@@ -95,10 +99,8 @@ public class FeignClientProperties {
 			return false;
 		}
 		FeignClientProperties that = (FeignClientProperties) o;
-		return defaultToProperties == that.defaultToProperties
+		return defaultToProperties == that.defaultToProperties && Objects.equals(defaultConfig, that.defaultConfig)
-				&& Objects.equals(defaultConfig, that.defaultConfig)
+				&& Objects.equals(config, that.config) && Objects.equals(decodeSlash, that.decodeSlash);
-				&& Objects.equals(config, that.config)
-				&& Objects.equals(decodeSlash, that.decodeSlash);
 	}
 
 	@Override
@@ -137,6 +139,12 @@ public class FeignClientProperties {
 
 		private ExceptionPropagationPolicy exceptionPropagationPolicy;
 
+		private List<Class<Capability>> capabilities;
+
+		private Class<QueryMapEncoder> queryMapEncoder;
+
+		private MetricsProperties metrics;
+
 		private Boolean followRedirects;
 
 		public Logger.Level getLoggerLevel() {
@@ -183,8 +191,7 @@ public class FeignClientProperties {
 			return requestInterceptors;
 		}
 
-		public void setRequestInterceptors(
+		public void setRequestInterceptors(List<Class<RequestInterceptor>> requestInterceptors) {
-				List<Class<RequestInterceptor>> requestInterceptors) {
 			this.requestInterceptors = requestInterceptors;
 		}
 
@@ -192,8 +199,7 @@ public class FeignClientProperties {
 			return defaultRequestHeaders;
 		}
 
-		public void setDefaultRequestHeaders(
+		public void setDefaultRequestHeaders(Map<String, Collection<String>> defaultRequestHeaders) {
-				Map<String, Collection<String>> defaultRequestHeaders) {
 			this.defaultRequestHeaders = defaultRequestHeaders;
 		}
 
@@ -201,8 +207,7 @@ public class FeignClientProperties {
 			return defaultQueryParameters;
 		}
 
-		public void setDefaultQueryParameters(
+		public void setDefaultQueryParameters(Map<String, Collection<String>> defaultQueryParameters) {
-				Map<String, Collection<String>> defaultQueryParameters) {
 			this.defaultQueryParameters = defaultQueryParameters;
 		}
 
@@ -242,11 +247,34 @@ public class FeignClientProperties {
 			return exceptionPropagationPolicy;
 		}
 
-		public void setExceptionPropagationPolicy(
+		public void setExceptionPropagationPolicy(ExceptionPropagationPolicy exceptionPropagationPolicy) {
-				ExceptionPropagationPolicy exceptionPropagationPolicy) {
 			this.exceptionPropagationPolicy = exceptionPropagationPolicy;
 		}
 
+		public List<Class<Capability>> getCapabilities() {
+			return capabilities;
+		}
+
+		public void setCapabilities(List<Class<Capability>> capabilities) {
+			this.capabilities = capabilities;
+		}
+
+		public Class<QueryMapEncoder> getQueryMapEncoder() {
+			return queryMapEncoder;
+		}
+
+		public void setQueryMapEncoder(Class<QueryMapEncoder> queryMapEncoder) {
+			this.queryMapEncoder = queryMapEncoder;
+		}
+
+		public MetricsProperties getMetrics() {
+			return metrics;
+		}
+
+		public void setMetrics(MetricsProperties metrics) {
+			this.metrics = metrics;
+		}
+
 		public Boolean isFollowRedirects() {
 			return followRedirects;
 		}
@@ -264,29 +292,60 @@ public class FeignClientProperties {
 				return false;
 			}
 			FeignClientConfiguration that = (FeignClientConfiguration) o;
-			return loggerLevel == that.loggerLevel
+			return loggerLevel == that.loggerLevel && Objects.equals(connectTimeout, that.connectTimeout)
-					&& Objects.equals(connectTimeout, that.connectTimeout)
+					&& Objects.equals(readTimeout, that.readTimeout) && Objects.equals(retryer, that.retryer)
-					&& Objects.equals(readTimeout, that.readTimeout)
-					&& Objects.equals(retryer, that.retryer)
 					&& Objects.equals(errorDecoder, that.errorDecoder)
 					&& Objects.equals(requestInterceptors, that.requestInterceptors)
-					&& Objects.equals(decode404, that.decode404)
+					&& Objects.equals(decode404, that.decode404) && Objects.equals(encoder, that.encoder)
-					&& Objects.equals(encoder, that.encoder)
+					&& Objects.equals(decoder, that.decoder) && Objects.equals(contract, that.contract)
-					&& Objects.equals(decoder, that.decoder)
+					&& Objects.equals(exceptionPropagationPolicy, that.exceptionPropagationPolicy)
-					&& 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(metrics, that.metrics)
 					&& Objects.equals(followRedirects, that.followRedirects);
 		}
 
 		@Override
 		public int hashCode() {
-			return Objects.hash(loggerLevel, connectTimeout, readTimeout, retryer,
+			return Objects.hash(loggerLevel, connectTimeout, readTimeout, retryer, errorDecoder, requestInterceptors,
-					errorDecoder, requestInterceptors, decode404, encoder, decoder,
+					decode404, encoder, decoder, contract, exceptionPropagationPolicy, defaultQueryParameters,
-					contract, exceptionPropagationPolicy, defaultQueryParameters,
+					defaultRequestHeaders, capabilities, queryMapEncoder, metrics, followRedirects);
-					defaultRequestHeaders, followRedirects);
+		}
+
+	}
+
+	/**
+	 * Metrics configuration for Feign Client.
+	 */
+	public static class MetricsProperties {
+
+		private Boolean enabled = true;
+
+		public Boolean getEnabled() {
+			return enabled;
+		}
+
+		public void setEnabled(Boolean enabled) {
+			this.enabled = enabled;
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			if (this == o) {
+				return true;
+			}
+			if (o == null || getClass() != o.getClass()) {
+				return false;
+			}
+
+			MetricsProperties that = (MetricsProperties) o;
+			return Objects.equals(enabled, that.enabled);
+		}
+
+		@Override
+		public int hashCode() {
+			return Objects.hash(enabled);
 		}
 
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -25,7 +25,7 @@ import org.springframework.cloud.context.named.NamedContextFactory;
  * @author Dave Syer
  * @author Gregor Zurowski
  */
-class FeignClientSpecification implements NamedContextFactory.Specification {
+public class FeignClientSpecification implements NamedContextFactory.Specification {
 
 	private String name;
 
@@ -34,7 +34,7 @@ class FeignClientSpecification implements NamedContextFactory.Specification {
 	FeignClientSpecification() {
 	}
 
-	FeignClientSpecification(String name, Class<?>[] configuration) {
+	public FeignClientSpecification(String name, Class<?>[] configuration) {
 		this.name = name;
 		this.configuration = configuration;
 	}
@@ -64,8 +64,7 @@ class FeignClientSpecification implements NamedContextFactory.Specification {
 			return false;
 		}
 		FeignClientSpecification that = (FeignClientSpecification) o;
-		return Objects.equals(this.name, that.name)
+		return Objects.equals(this.name, that.name) && Arrays.equals(this.configuration, that.configuration);
-				&& Arrays.equals(this.configuration, that.configuration);
 	}
 
 	@Override
@@ -75,9 +74,8 @@ class FeignClientSpecification implements NamedContextFactory.Specification {
 
 	@Override
 	public String toString() {
-		return new StringBuilder("FeignClientSpecification{").append("name='")
+		return new StringBuilder("FeignClientSpecification{").append("name='").append(this.name).append("', ")
-				.append(this.name).append("', ").append("configuration=")
+				.append("configuration=").append(Arrays.toString(this.configuration)).append("}").toString();
-				.append(Arrays.toString(this.configuration)).append("}").toString();
 	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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.
@@ -19,7 +19,6 @@ package org.springframework.cloud.openfeign;
 import java.util.ArrayList;
 import java.util.List;
 
-import com.netflix.hystrix.HystrixCommand;
 import feign.Contract;
 import feign.Feign;
 import feign.Logger;
@@ -29,8 +28,9 @@ import feign.codec.Decoder;
 import feign.codec.Encoder;
 import feign.form.MultipartFormContentProcessor;
 import feign.form.spring.SpringFormEncoder;
-import feign.hystrix.HystrixFeign;
+import feign.micrometer.MicrometerCapability;
 import feign.optionals.OptionalDecoder;
+import io.micrometer.core.instrument.MeterRegistry;
 
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.beans.factory.ObjectProvider;
@@ -47,6 +47,7 @@ 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;
@@ -54,6 +55,7 @@ import org.springframework.cloud.openfeign.support.SpringDecoder;
 import org.springframework.cloud.openfeign.support.SpringEncoder;
 import org.springframework.cloud.openfeign.support.SpringMvcContract;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Scope;
 import org.springframework.core.convert.ConversionService;
@@ -66,8 +68,10 @@ import static feign.form.ContentType.MULTIPART;
  * @author Dave Syer
  * @author Venil Noronha
  * @author Darren Foong
+ * @author Jonatan Ivanov
  * @author Olga Maciaszek-Sharma
  * @author Hyeonmin Park
+ * @author Yanming Zhou
  */
 @Configuration(proxyBeanMethods = false)
 public class FeignClientsConfiguration {
@@ -95,33 +99,30 @@ public class FeignClientsConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
-	public Decoder feignDecoder() {
+	public Decoder feignDecoder(ObjectProvider<HttpMessageConverterCustomizer> customizers) {
-		return new OptionalDecoder(
+		return new OptionalDecoder(new ResponseEntityDecoder(new SpringDecoder(messageConverters, customizers)));
-				new ResponseEntityDecoder(new SpringDecoder(this.messageConverters)));
 	}
 
 	@Bean
 	@ConditionalOnMissingBean
 	@ConditionalOnMissingClass("org.springframework.data.domain.Pageable")
-	public Encoder feignEncoder(ObjectProvider<AbstractFormWriter> formWriterProvider) {
+	public Encoder feignEncoder(ObjectProvider<AbstractFormWriter> formWriterProvider,
-		return springEncoder(formWriterProvider, encoderProperties);
+			ObjectProvider<HttpMessageConverterCustomizer> customizers) {
+		return springEncoder(formWriterProvider, encoderProperties, customizers);
 	}
 
 	@Bean
 	@ConditionalOnClass(name = "org.springframework.data.domain.Pageable")
 	@ConditionalOnMissingBean
-	public Encoder feignEncoderPageable(
+	public Encoder feignEncoderPageable(ObjectProvider<AbstractFormWriter> formWriterProvider,
-			ObjectProvider<AbstractFormWriter> formWriterProvider) {
+			ObjectProvider<HttpMessageConverterCustomizer> customizers) {
 		PageableSpringEncoder encoder = new PageableSpringEncoder(
-				springEncoder(formWriterProvider, encoderProperties));
+				springEncoder(formWriterProvider, encoderProperties, customizers));
 
 		if (springDataWebProperties != null) {
-			encoder.setPageParameter(
+			encoder.setPageParameter(springDataWebProperties.getPageable().getPageParameter());
-					springDataWebProperties.getPageable().getPageParameter());
+			encoder.setSizeParameter(springDataWebProperties.getPageable().getSizeParameter());
-			encoder.setSizeParameter(
+			encoder.setSortParameter(springDataWebProperties.getSort().getSortParameter());
-					springDataWebProperties.getPageable().getSizeParameter());
-			encoder.setSortParameter(
-					springDataWebProperties.getSort().getSortParameter());
 		}
 		return encoder;
 	}
@@ -130,22 +131,26 @@ public class FeignClientsConfiguration {
 	@ConditionalOnClass(name = "org.springframework.data.domain.Pageable")
 	@ConditionalOnMissingBean
 	public QueryMapEncoder feignQueryMapEncoderPageable() {
-		return new PageableSpringQueryMapEncoder();
+		PageableSpringQueryMapEncoder queryMapEncoder = new PageableSpringQueryMapEncoder();
+		if (springDataWebProperties != null) {
+			queryMapEncoder.setPageParameter(springDataWebProperties.getPageable().getPageParameter());
+			queryMapEncoder.setSizeParameter(springDataWebProperties.getPageable().getSizeParameter());
+			queryMapEncoder.setSortParameter(springDataWebProperties.getSort().getSortParameter());
+		}
+		return queryMapEncoder;
 	}
 
 	@Bean
 	@ConditionalOnMissingBean
 	public Contract feignContract(ConversionService feignConversionService) {
-		boolean decodeSlash = feignClientProperties == null
+		boolean decodeSlash = feignClientProperties == null || feignClientProperties.isDecodeSlash();
-				|| 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 : this.feignFormatterRegistrars) {
+		for (FeignFormatterRegistrar feignFormatterRegistrar : feignFormatterRegistrars) {
 			feignFormatterRegistrar.registerFormatters(conversionService);
 		}
 		return conversionService;
@@ -157,17 +162,10 @@ public class FeignClientsConfiguration {
 		return Retryer.NEVER_RETRY;
 	}
 
-	@Bean
-	@Scope("prototype")
-	@ConditionalOnMissingBean
-	public Feign.Builder feignBuilder(Retryer retryer) {
-		return Feign.builder().retryer(retryer);
-	}
-
 	@Bean
 	@ConditionalOnMissingBean(FeignLoggerFactory.class)
 	public FeignLoggerFactory feignLoggerFactory() {
-		return new DefaultFeignLoggerFactory(this.logger);
+		return new DefaultFeignLoggerFactory(logger);
 	}
 
 	@Bean
@@ -178,48 +176,45 @@ public class FeignClientsConfiguration {
 	}
 
 	private Encoder springEncoder(ObjectProvider<AbstractFormWriter> formWriterProvider,
-			FeignEncoderProperties encoderProperties) {
+			FeignEncoderProperties encoderProperties, ObjectProvider<HttpMessageConverterCustomizer> customizers) {
 		AbstractFormWriter formWriter = formWriterProvider.getIfAvailable();
 
 		if (formWriter != null) {
-			return new SpringEncoder(new SpringPojoFormEncoder(formWriter),
+			return new SpringEncoder(new SpringPojoFormEncoder(formWriter), messageConverters, encoderProperties,
-					this.messageConverters, encoderProperties);
+					customizers);
 		}
 		else {
-			return new SpringEncoder(new SpringFormEncoder(), this.messageConverters,
+			return new SpringEncoder(new SpringFormEncoder(), messageConverters, encoderProperties, customizers);
-					encoderProperties);
 		}
 	}
 
-	@Configuration(proxyBeanMethods = false)
-	@ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
-	protected static class HystrixFeignConfiguration {
-
-		@Bean
-		@Scope("prototype")
-		@ConditionalOnMissingBean
-		@ConditionalOnProperty(name = "feign.hystrix.enabled")
-		public Feign.Builder feignHystrixBuilder() {
-			return HystrixFeign.builder();
-		}
-
-	}
-
 	private class SpringPojoFormEncoder extends SpringFormEncoder {
 
 		SpringPojoFormEncoder(AbstractFormWriter formWriter) {
 			super();
 
-			MultipartFormContentProcessor processor = (MultipartFormContentProcessor) getContentProcessor(
+			MultipartFormContentProcessor processor = (MultipartFormContentProcessor) getContentProcessor(MULTIPART);
-					MULTIPART);
 			processor.addFirstWriter(formWriter);
 		}
 
 	}
 
+	@Configuration(proxyBeanMethods = false)
+	@Conditional(FeignCircuitBreakerDisabledConditions.class)
+	protected static class DefaultFeignBuilderConfiguration {
+
+		@Bean
+		@Scope("prototype")
+		@ConditionalOnMissingBean
+		public Feign.Builder feignBuilder(Retryer retryer) {
+			return Feign.builder().retryer(retryer);
+		}
+
+	}
+
 	@Configuration(proxyBeanMethods = false)
 	@ConditionalOnClass(CircuitBreaker.class)
-	@ConditionalOnProperty("feign.circuitbreaker.enabled")
+	@ConditionalOnProperty("spring.cloud.openfeign.circuitbreaker.enabled")
 	protected static class CircuitBreakerPresentFeignBuilderConfiguration {
 
 		@Bean
@@ -239,4 +234,19 @@ public class FeignClientsConfiguration {
 
 	}
 
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnBean(type = "io.micrometer.core.instrument.MeterRegistry")
+	@ConditionalOnClass(name = "feign.micrometer.MicrometerCapability")
+	@ConditionalOnProperty(name = "spring.cloud.openfeign.metrics.enabled", matchIfMissing = true)
+	@Conditional(FeignClientMetricsEnabledCondition.class)
+	protected static class MetricsConfiguration {
+
+		@Bean
+		@ConditionalOnMissingBean
+		public MicrometerCapability micrometerCapability(MeterRegistry meterRegistry) {
+			return new MicrometerCapability(meterRegistry);
+		}
+
+	}
+
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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.
@@ -29,6 +29,9 @@ import java.util.List;
 import java.util.Map;
 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;
@@ -63,9 +66,9 @@ import org.springframework.util.StringUtils;
  * @author Michal Domagala
  * @author Marcin Grzejszczak
  * @author Olga Maciaszek-Sharma
+ * @author Jasbir Singh
  */
-class FeignClientsRegistrar
+class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
-		implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
 
 	// patterned after Spring Integration IntegrationComponentScanRegistrar
 	// and RibbonClientsConfigurationRegistgrar
@@ -78,8 +81,7 @@ class FeignClientsRegistrar
 	}
 
 	static void validateFallback(final Class clazz) {
-		Assert.isTrue(!clazz.isInterface(),
+		Assert.isTrue(!clazz.isInterface(), "Fallback class must implement the interface annotated by @FeignClient");
-				"Fallback class must implement the interface annotated by @FeignClient");
 	}
 
 	static void validateFallbackFactory(final Class clazz) {
@@ -144,16 +146,13 @@ class FeignClientsRegistrar
 	}
 
 	@Override
-	public void registerBeanDefinitions(AnnotationMetadata metadata,
+	public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
-			BeanDefinitionRegistry registry) {
 		registerDefaultConfiguration(metadata, registry);
 		registerFeignClients(metadata, registry);
 	}
 
-	private void registerDefaultConfiguration(AnnotationMetadata metadata,
+	private void registerDefaultConfiguration(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
-			BeanDefinitionRegistry registry) {
+		Map<String, Object> defaultAttrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
-		Map<String, Object> defaultAttrs = metadata
-				.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
 
 		if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
 			String name;
@@ -163,19 +162,15 @@ class FeignClientsRegistrar
 			else {
 				name = "default." + metadata.getClassName();
 			}
-			registerClientConfiguration(registry, name,
+			registerClientConfiguration(registry, name, defaultAttrs.get("defaultConfiguration"));
-					defaultAttrs.get("defaultConfiguration"));
 		}
 	}
 
-	public void registerFeignClients(AnnotationMetadata metadata,
+	public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
-			BeanDefinitionRegistry registry) {
 
 		LinkedHashSet<BeanDefinition> candidateComponents = new LinkedHashSet<>();
-		Map<String, Object> attrs = metadata
+		Map<String, Object> attrs = metadata.getAnnotationAttributes(EnableFeignClients.class.getName());
-				.getAnnotationAttributes(EnableFeignClients.class.getName());
+		final Class<?>[] clients = attrs == null ? null : (Class<?>[]) attrs.get("clients");
-		final Class<?>[] clients = attrs == null ? null
-				: (Class<?>[]) attrs.get("clients");
 		if (clients == null || clients.length == 0) {
 			ClassPathScanningCandidateComponentProvider scanner = getScanner();
 			scanner.setResourceLoader(this.resourceLoader);
@@ -196,23 +191,21 @@ class FeignClientsRegistrar
 				// verify annotated class is an interface
 				AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
 				AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
-				Assert.isTrue(annotationMetadata.isInterface(),
+				Assert.isTrue(annotationMetadata.isInterface(), "@FeignClient can only be specified on an interface");
-						"@FeignClient can only be specified on an interface");
 
 				Map<String, Object> attributes = annotationMetadata
 						.getAnnotationAttributes(FeignClient.class.getCanonicalName());
 
 				String name = getClientName(attributes);
-				registerClientConfiguration(registry, name,
+				registerClientConfiguration(registry, name, attributes.get("configuration"));
-						attributes.get("configuration"));
 
 				registerFeignClient(registry, annotationMetadata, attributes);
 			}
 		}
 	}
 
-	private void registerFeignClient(BeanDefinitionRegistry registry,
+	private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata,
-			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
+			Map<String, Object> attributes) {
 		String className = annotationMetadata.getClassName();
 		Class clazz = ClassUtils.resolveClassName(className, null);
 		ConfigurableBeanFactory beanFactory = registry instanceof ConfigurableBeanFactory
@@ -224,24 +217,20 @@ class FeignClientsRegistrar
 		factoryBean.setName(name);
 		factoryBean.setContextId(contextId);
 		factoryBean.setType(clazz);
-		BeanDefinitionBuilder definition = BeanDefinitionBuilder
+		factoryBean.setRefreshableClient(isClientRefreshEnabled());
-				.genericBeanDefinition(clazz, () -> {
+		BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(clazz, () -> {
 			factoryBean.setUrl(getUrl(beanFactory, attributes));
 			factoryBean.setPath(getPath(beanFactory, attributes));
-					factoryBean.setDecode404(Boolean
+			factoryBean.setDecode404(Boolean.parseBoolean(String.valueOf(attributes.get("decode404"))));
-							.parseBoolean(String.valueOf(attributes.get("decode404"))));
 			Object fallback = attributes.get("fallback");
 			if (fallback != null) {
-						factoryBean.setFallback(fallback instanceof Class
+				factoryBean.setFallback(fallback instanceof Class ? (Class<?>) fallback
-								? (Class<?>) fallback
 						: ClassUtils.resolveClassName(fallback.toString(), null));
 			}
 			Object fallbackFactory = attributes.get("fallbackFactory");
 			if (fallbackFactory != null) {
-						factoryBean.setFallbackFactory(fallbackFactory instanceof Class
+				factoryBean.setFallbackFactory(fallbackFactory instanceof Class ? (Class<?>) fallbackFactory
-								? (Class<?>) fallbackFactory
+						: ClassUtils.resolveClassName(fallbackFactory.toString(), null));
-								: ClassUtils.resolveClassName(fallbackFactory.toString(),
-										null));
 			}
 			return factoryBean.getObject();
 		});
@@ -263,9 +252,10 @@ class FeignClientsRegistrar
 			qualifiers = new String[] { contextId + "FeignClient" };
 		}
 
-		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
+		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, qualifiers);
-				qualifiers);
 		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
+
+		registerOptionsBeanDefinition(registry, contextId);
 	}
 
 	private void validate(Map<String, Object> attributes) {
@@ -292,8 +282,7 @@ class FeignClientsRegistrar
 		return getName(name);
 	}
 
-	private String getContextId(ConfigurableBeanFactory beanFactory,
+	private String getContextId(ConfigurableBeanFactory beanFactory, Map<String, Object> attributes) {
-			Map<String, Object> attributes) {
 		String contextId = (String) attributes.get("contextId");
 		if (!StringUtils.hasText(contextId)) {
 			return getName(attributes);
@@ -313,20 +302,21 @@ class FeignClientsRegistrar
 			if (resolver == null) {
 				return resolved;
 			}
-			return String.valueOf(resolver.evaluate(resolved,
+			Object evaluateValue = resolver.evaluate(resolved, new BeanExpressionContext(beanFactory, null));
-					new BeanExpressionContext(beanFactory, null)));
+			if (evaluateValue != null) {
+				return String.valueOf(evaluateValue);
+			}
+			return null;
 		}
 		return value;
 	}
 
-	private String getUrl(ConfigurableBeanFactory beanFactory,
+	private String getUrl(ConfigurableBeanFactory beanFactory, Map<String, Object> attributes) {
-			Map<String, Object> attributes) {
 		String url = resolve(beanFactory, (String) attributes.get("url"));
 		return getUrl(url);
 	}
 
-	private String getPath(ConfigurableBeanFactory beanFactory,
+	private String getPath(ConfigurableBeanFactory beanFactory, Map<String, Object> attributes) {
-			Map<String, Object> attributes) {
 		String path = resolve(beanFactory, (String) attributes.get("path"));
 		return getPath(path);
 	}
@@ -334,8 +324,7 @@ class FeignClientsRegistrar
 	protected ClassPathScanningCandidateComponentProvider getScanner() {
 		return new ClassPathScanningCandidateComponentProvider(false, this.environment) {
 			@Override
-			protected boolean isCandidateComponent(
+			protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
-					AnnotatedBeanDefinition beanDefinition) {
 				boolean isCandidate = false;
 				if (beanDefinition.getMetadata().isIndependent()) {
 					if (!beanDefinition.getMetadata().isAnnotation()) {
@@ -367,8 +356,7 @@ class FeignClientsRegistrar
 		}
 
 		if (basePackages.isEmpty()) {
-			basePackages.add(
+			basePackages.add(ClassUtils.getPackageName(importingClassMetadata.getClassName()));
-					ClassUtils.getPackageName(importingClassMetadata.getClassName()));
 		}
 		return basePackages;
 	}
@@ -388,8 +376,7 @@ class FeignClientsRegistrar
 		if (client == null) {
 			return null;
 		}
-		List<String> qualifierList = new ArrayList<>(
+		List<String> qualifierList = new ArrayList<>(Arrays.asList((String[]) client.get("qualifiers")));
-				Arrays.asList((String[]) client.get("qualifiers")));
 		qualifierList.removeIf(qualifier -> !StringUtils.hasText(qualifier));
 		if (qualifierList.isEmpty() && getQualifier(client) != null) {
 			qualifierList = Collections.singletonList(getQualifier(client));
@@ -415,18 +402,15 @@ class FeignClientsRegistrar
 			return value;
 		}
 
-		throw new IllegalStateException("Either 'name' or 'value' must be provided in @"
+		throw new IllegalStateException(
-				+ FeignClient.class.getSimpleName());
+				"Either 'name' or 'value' must be provided in @" + FeignClient.class.getSimpleName());
 	}
 
-	private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
+	private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
-			Object configuration) {
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class);
-		BeanDefinitionBuilder builder = BeanDefinitionBuilder
-				.genericBeanDefinition(FeignClientSpecification.class);
 		builder.addConstructorArgValue(name);
 		builder.addConstructorArgValue(configuration);
-		registry.registerBeanDefinition(
+		registry.registerBeanDefinition(name + "." + FeignClientSpecification.class.getSimpleName(),
-				name + "." + FeignClientSpecification.class.getSimpleName(),
 				builder.getBeanDefinition());
 	}
 
@@ -435,4 +419,28 @@ class FeignClientsRegistrar
 		this.environment = environment;
 	}
 
+	/**
+	 * 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
+	 */
+	private void registerOptionsBeanDefinition(BeanDefinitionRegistry registry, String contextId) {
+		if (isClientRefreshEnabled()) {
+			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(),
+					beanName);
+			definitionHolder = ScopedProxyUtils.createScopedProxy(definitionHolder, registry, true);
+			BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
+		}
+	}
+
+	private boolean isClientRefreshEnabled() {
+		return environment.getProperty("spring.cloud.openfeign.client.refresh-enabled", Boolean.class, false);
+	}
+
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -30,11 +30,12 @@ import org.springframework.lang.Nullable;
  * @author Spencer Gibb
  * @author Dave Syer
  * @author Matt King
+ * @author Jasbir Singh
  */
 public class FeignContext extends NamedContextFactory<FeignClientSpecification> {
 
 	public FeignContext() {
-		super(FeignClientsConfiguration.class, "feign", "feign.client.name");
+		super(FeignClientsConfiguration.class, "spring.cloud.openfeign", "spring.cloud.openfeign.client.name");
 	}
 
 	@Nullable
@@ -52,4 +53,8 @@ public class FeignContext extends NamedContextFactory<FeignClientSpecification>
 		return getContext(name).getBeansOfType(type);
 	}
 
+	public <T> T getInstance(String contextName, String beanName, Class<T> type) {
+		return getContext(contextName).getBean(beanName, type);
+	}
+
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020-2020 the original author or authors.
+ * Copyright 2020-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.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2020 the original author or authors.
+ * 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.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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.
@@ -34,7 +34,7 @@ public class HttpClient5DisabledConditions extends AnyNestedCondition {
 
 	}
 
-	@ConditionalOnProperty(value = "feign.httpclient.hc5.enabled", havingValue = "false",
+	@ConditionalOnProperty(value = "spring.cloud.openfeign.httpclient.hc5.enabled", havingValue = "false",
 			matchIfMissing = true)
 	static class HttpClient5Disabled {
 

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

@@ -1,42 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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 org.springframework.boot.autoconfigure.condition.AnyNestedCondition;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-
-/**
- * @author Tim Peeters
- */
-class HystrixDisabledConditions extends AnyNestedCondition {
-
-	HystrixDisabledConditions() {
-		super(ConfigurationPhase.PARSE_CONFIGURATION);
-	}
-
-	@ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
-	static class HystrixFeignClassMissing {
-
-	}
-
-	@ConditionalOnProperty(value = "feign.hystrix.enabled", havingValue = "false")
-	static class HystrixFeignDisabled {
-
-	}
-
-}

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

@@ -1,101 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.Feign;
-import feign.Target;
-import feign.hystrix.FallbackFactory;
-import feign.hystrix.HystrixFeign;
-import feign.hystrix.SetterFactory;
-
-import org.springframework.util.StringUtils;
-
-/**
- * @author Spencer Gibb
- * @author Erik Kringen
- */
-@SuppressWarnings("unchecked")
-class HystrixTargeter implements Targeter {
-
-	@Override
-	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
-			FeignContext context, Target.HardCodedTarget<T> target) {
-		if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {
-			return feign.target(target);
-		}
-		feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;
-		String name = StringUtils.isEmpty(factory.getContextId()) ? factory.getName()
-				: factory.getContextId();
-		SetterFactory setterFactory = getOptional(name, context, SetterFactory.class);
-		if (setterFactory != null) {
-			builder.setterFactory(setterFactory);
-		}
-		Class<?> fallback = factory.getFallback();
-		if (fallback != void.class) {
-			return targetWithFallback(name, context, target, builder, fallback);
-		}
-		Class<?> fallbackFactory = factory.getFallbackFactory();
-		if (fallbackFactory != void.class) {
-			return targetWithFallbackFactory(name, context, target, builder,
-					fallbackFactory);
-		}
-
-		return feign.target(target);
-	}
-
-	private <T> T targetWithFallbackFactory(String feignClientName, FeignContext context,
-			Target.HardCodedTarget<T> target, HystrixFeign.Builder builder,
-			Class<?> fallbackFactoryClass) {
-		FallbackFactory<? extends T> fallbackFactory = (FallbackFactory<? extends T>) getFromContext(
-				"fallbackFactory", feignClientName, context, fallbackFactoryClass,
-				FallbackFactory.class);
-		return builder.target(target, fallbackFactory);
-	}
-
-	private <T> T targetWithFallback(String feignClientName, FeignContext context,
-			Target.HardCodedTarget<T> target, HystrixFeign.Builder builder,
-			Class<?> fallback) {
-		T fallbackInstance = getFromContext("fallback", feignClientName, context,
-				fallback, target.type());
-		return builder.target(target, fallbackInstance);
-	}
-
-	private <T> T getFromContext(String fallbackMechanism, String feignClientName,
-			FeignContext context, Class<?> beanType, Class<T> targetType) {
-		Object fallbackInstance = context.getInstance(feignClientName, beanType);
-		if (fallbackInstance == null) {
-			throw new IllegalStateException(String.format(
-					"No " + fallbackMechanism
-							+ " instance of type %s found for feign client %s",
-					beanType, 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;
-	}
-
-	private <T> T getOptional(String feignClientName, FeignContext context,
-			Class<T> beanType) {
-		return context.getInstance(feignClientName, beanType);
-	}
-
-}

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

@@ -0,0 +1,86 @@
+/*
+ * 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 java.util.concurrent.TimeUnit;
+
+import feign.Request;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+/**
+ * This factory bean is meant to create {@link Request.Options} instance as per the
+ * applicable configurations.
+ *
+ * @author Jasbir Singh
+ */
+public class OptionsFactoryBean implements FactoryBean<Request.Options>, ApplicationContextAware {
+
+	private ApplicationContext applicationContext;
+
+	private String contextId;
+
+	private Request.Options options;
+
+	@Override
+	public Class<?> getObjectType() {
+		return Request.Options.class;
+	}
+
+	@Override
+	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+		this.applicationContext = applicationContext;
+	}
+
+	@Override
+	public Request.Options getObject() throws Exception {
+		if (options != null) {
+			return options;
+		}
+
+		options = new Request.Options();
+		FeignClientProperties properties = applicationContext.getBean(FeignClientProperties.class);
+		options = createOptionsWithApplicableValues(properties.getConfig().get(properties.getDefaultConfig()), options);
+		options = createOptionsWithApplicableValues(properties.getConfig().get(contextId), options);
+		return options;
+	}
+
+	public void setContextId(String contextId) {
+		this.contextId = contextId;
+	}
+
+	private Request.Options createOptionsWithApplicableValues(
+			FeignClientProperties.FeignClientConfiguration clientConfiguration, Request.Options options) {
+		if (Objects.isNull(clientConfiguration)) {
+			return options;
+		}
+
+		int connectTimeoutMillis = Objects.nonNull(clientConfiguration.getConnectTimeout())
+				? clientConfiguration.getConnectTimeout() : options.connectTimeoutMillis();
+		int readTimeoutMillis = Objects.nonNull(clientConfiguration.getReadTimeout())
+				? clientConfiguration.getReadTimeout() : options.readTimeoutMillis();
+		boolean followRedirects = Objects.nonNull(clientConfiguration.isFollowRedirects())
+				? clientConfiguration.isFollowRedirects() : options.isFollowRedirects();
+		return new Request.Options(connectTimeoutMillis, TimeUnit.MILLISECONDS, readTimeoutMillis,
+				TimeUnit.MILLISECONDS, followRedirects);
+	}
+
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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,9 +22,9 @@ import feign.Target;
 /**
  * @author Spencer Gibb
  */
-interface Targeter {
+public interface Targeter {
 
-	<T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
+	<T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
-			FeignContext context, Target.HardCodedTarget<T> target);
+			Target.HardCodedTarget<T> target);
 
 }

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

@@ -0,0 +1,67 @@
+/*
+ * 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.Arrays;
+
+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
+ *
+ */
+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, Arrays.asList("")).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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -48,15 +48,13 @@ public class MatrixVariableParameterProcessor implements AnnotatedParameterProce
 	}
 
 	@Override
-	public boolean processArgument(AnnotatedParameterContext context,
+	public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) {
-			Annotation annotation, Method method) {
 		int parameterIndex = context.getParameterIndex();
 		Class<?> parameterType = method.getParameterTypes()[parameterIndex];
 		MethodMetadata data = context.getMethodMetadata();
 		String name = ANNOTATION.cast(annotation).value();
 
-		checkState(emptyToNull(name) != null,
+		checkState(emptyToNull(name) != null, "MatrixVariable annotation was empty on param %s.",
-				"MatrixVariable annotation was empty on param %s.",
 				context.getParameterIndex());
 
 		context.setParameterName(name);
@@ -65,8 +63,7 @@ public class MatrixVariableParameterProcessor implements AnnotatedParameterProce
 			data.indexToExpander().put(parameterIndex, this::expandMap);
 		}
 		else {
-			data.indexToExpander().put(parameterIndex,
+			data.indexToExpander().put(parameterIndex, object -> ";" + name + "=" + object.toString());
-					object -> ";" + name + "=" + object.toString());
 		}
 
 		return true;
@@ -76,8 +73,7 @@ public class MatrixVariableParameterProcessor implements AnnotatedParameterProce
 		Map<String, Object> paramMap = (Map) object;
 
 		return paramMap.keySet().stream().filter(key -> paramMap.get(key) != null)
-				.map(key -> ";" + key + "=" + paramMap.get(key).toString())
+				.map(key -> ";" + key + "=" + paramMap.get(key).toString()).collect(Collectors.joining());
-				.collect(Collectors.joining());
 	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -34,6 +34,7 @@ import static feign.Util.emptyToNull;
  *
  * @author Jakub Narloch
  * @author Abhijit Sarkar
+ * @author Yanming Zhou
  * @see AnnotatedParameterProcessor
  */
 public class PathVariableParameterProcessor implements AnnotatedParameterProcessor {
@@ -46,18 +47,16 @@ public class PathVariableParameterProcessor implements AnnotatedParameterProcess
 	}
 
 	@Override
-	public boolean processArgument(AnnotatedParameterContext context,
+	public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) {
-			Annotation annotation, Method method) {
 		String name = ANNOTATION.cast(annotation).value();
-		checkState(emptyToNull(name) != null,
+		checkState(emptyToNull(name) != null, "PathVariable annotation was empty on param %s.",
-				"PathVariable annotation was empty on param %s.",
 				context.getParameterIndex());
 		context.setParameterName(name);
 
 		MethodMetadata data = context.getMethodMetadata();
 		String varName = '{' + name + '}';
-		if (!data.template().url().contains(varName)
+		String varNameRegex = ".*\\{" + name + "(:[^}]+)?\\}.*";
-				&& !searchMapValues(data.template().queries(), varName)
+		if (!data.template().url().matches(varNameRegex) && !searchMapValues(data.template().queries(), varName)
 				&& !searchMapValues(data.template().headers(), varName)) {
 			data.formParams().add(name);
 		}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -40,8 +40,7 @@ public class QueryMapParameterProcessor implements AnnotatedParameterProcessor {
 	}
 
 	@Override
-	public boolean processArgument(AnnotatedParameterContext context,
+	public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) {
-			Annotation annotation, Method method) {
 		int paramIndex = context.getParameterIndex();
 		MethodMetadata metadata = context.getMethodMetadata();
 		if (metadata.queryMapIndex() == null) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -46,27 +46,23 @@ public class RequestHeaderParameterProcessor implements AnnotatedParameterProces
 	}
 
 	@Override
-	public boolean processArgument(AnnotatedParameterContext context,
+	public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) {
-			Annotation annotation, Method method) {
 		int parameterIndex = context.getParameterIndex();
 		Class<?> parameterType = method.getParameterTypes()[parameterIndex];
 		MethodMetadata data = context.getMethodMetadata();
 
 		if (Map.class.isAssignableFrom(parameterType)) {
-			checkState(data.headerMapIndex() == null,
+			checkState(data.headerMapIndex() == null, "Header map can only be present once.");
-					"Header map can only be present once.");
 			data.headerMapIndex(parameterIndex);
 
 			return true;
 		}
 
 		String name = ANNOTATION.cast(annotation).value();
-		checkState(emptyToNull(name) != null,
+		checkState(emptyToNull(name) != null, "RequestHeader.value() was empty on parameter %s", parameterIndex);
-				"RequestHeader.value() was empty on parameter %s", parameterIndex);
 		context.setParameterName(name);
 
-		Collection<String> header = context.setTemplateParameter(name,
+		Collection<String> header = context.setTemplateParameter(name, data.template().headers().get(name));
-				data.template().headers().get(name));
 		data.template().header(name, header);
 		return true;
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -46,15 +46,13 @@ public class RequestParamParameterProcessor implements AnnotatedParameterProcess
 	}
 
 	@Override
-	public boolean processArgument(AnnotatedParameterContext context,
+	public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) {
-			Annotation annotation, Method method) {
 		int parameterIndex = context.getParameterIndex();
 		Class<?> parameterType = method.getParameterTypes()[parameterIndex];
 		MethodMetadata data = context.getMethodMetadata();
 
 		if (Map.class.isAssignableFrom(parameterType)) {
-			checkState(data.queryMapIndex() == null,
+			checkState(data.queryMapIndex() == null, "Query map can only be present once.");
-					"Query map can only be present once.");
 			data.queryMapIndex(parameterIndex);
 
 			return true;
@@ -62,12 +60,10 @@ public class RequestParamParameterProcessor implements AnnotatedParameterProcess
 
 		RequestParam requestParam = ANNOTATION.cast(annotation);
 		String name = requestParam.value();
-		checkState(emptyToNull(name) != null,
+		checkState(emptyToNull(name) != null, "RequestParam.value() was empty on parameter %s", parameterIndex);
-				"RequestParam.value() was empty on parameter %s", parameterIndex);
 		context.setParameterName(name);
 
-		Collection<String> query = context.setTemplateParameter(name,
+		Collection<String> query = context.setTemplateParameter(name, data.template().queries().get(name));
-				data.template().queries().get(name));
 		data.template().query(name, query);
 		return true;
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -44,19 +44,16 @@ public class RequestPartParameterProcessor implements AnnotatedParameterProcesso
 	}
 
 	@Override
-	public boolean processArgument(AnnotatedParameterContext context,
+	public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) {
-			Annotation annotation, Method method) {
 		int parameterIndex = context.getParameterIndex();
 		MethodMetadata data = context.getMethodMetadata();
 
 		String name = ANNOTATION.cast(annotation).value();
-		checkState(emptyToNull(name) != null,
+		checkState(emptyToNull(name) != null, "RequestPart.value() was empty on parameter %s", parameterIndex);
-				"RequestPart.value() was empty on parameter %s", parameterIndex);
 		context.setParameterName(name);
 
 		data.formParams().add(name);
-		Collection<String> names = context.setTemplateParameter(name,
+		Collection<String> names = context.setTemplateParameter(name, data.indexToName().get(parameterIndex));
-				data.indexToName().get(parameterIndex));
 		data.indexToName().put(parameterIndex, names);
 		return true;
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2019 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.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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,11 +23,11 @@ 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;
@@ -66,25 +66,19 @@ public class HttpClient5FeignConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean(HttpClientConnectionManager.class)
-	public HttpClientConnectionManager hc5ConnectionManager(
+	public HttpClientConnectionManager hc5ConnectionManager(FeignHttpClientProperties httpClientProperties) {
-			FeignHttpClientProperties httpClientProperties) {
 		return PoolingHttpClientConnectionManagerBuilder.create()
-				.setSSLSocketFactory(httpsSSLConnectionSocketFactory(
+				.setSSLSocketFactory(httpsSSLConnectionSocketFactory(httpClientProperties.isDisableSslValidation()))
-						httpClientProperties.isDisableSslValidation()))
 				.setMaxConnTotal(httpClientProperties.getMaxConnections())
 				.setMaxConnPerRoute(httpClientProperties.getMaxConnectionsPerRoute())
-				.setConnPoolPolicy(PoolReusePolicy.valueOf(
+				.setConnPoolPolicy(PoolReusePolicy.valueOf(httpClientProperties.getHc5().getPoolReusePolicy().name()))
-						httpClientProperties.getHc5().getPoolReusePolicy().name()))
+				.setPoolConcurrencyPolicy(
-				.setPoolConcurrencyPolicy(PoolConcurrencyPolicy.valueOf(
+						PoolConcurrencyPolicy.valueOf(httpClientProperties.getHc5().getPoolConcurrencyPolicy().name()))
-						httpClientProperties.getHc5().getPoolConcurrencyPolicy().name()))
 				.setConnectionTimeToLive(
-						TimeValue.of(httpClientProperties.getTimeToLive(),
+						TimeValue.of(httpClientProperties.getTimeToLive(), httpClientProperties.getTimeToLiveUnit()))
-								httpClientProperties.getTimeToLiveUnit()))
+				.setDefaultSocketConfig(
-				.setDefaultSocketConfig(SocketConfig.custom()
+						SocketConfig.custom().setSoTimeout(Timeout.of(httpClientProperties.getHc5().getSocketTimeout(),
-						.setSoTimeout(Timeout.of(
+								httpClientProperties.getHc5().getSocketTimeoutUnit())).build())
-								httpClientProperties.getHc5().getSocketTimeout(),
-								httpClientProperties.getHc5().getSocketTimeoutUnit()))
-						.build())
 				.build();
 	}
 
@@ -93,14 +87,10 @@ public class HttpClient5FeignConfiguration {
 			FeignHttpClientProperties httpClientProperties) {
 		httpClient5 = HttpClients.custom().disableCookieManagement().useSystemProperties()
 				.setConnectionManager(connectionManager).evictExpiredConnections()
-				.setDefaultRequestConfig(
+				.setDefaultRequestConfig(RequestConfig.custom()
-						RequestConfig.custom()
+						.setConnectTimeout(
-								.setConnectTimeout(Timeout.of(
+								Timeout.of(httpClientProperties.getConnectionTimeout(), TimeUnit.MILLISECONDS))
-										httpClientProperties.getConnectionTimeout(),
+						.setRedirectsEnabled(httpClientProperties.isFollowRedirects()).build())
-										TimeUnit.MILLISECONDS))
-								.setRedirectsEnabled(
-										httpClientProperties.isFollowRedirects())
-								.build())
 				.build();
 		return httpClient5;
 	}
@@ -112,17 +102,14 @@ public class HttpClient5FeignConfiguration {
 		}
 	}
 
-	private LayeredConnectionSocketFactory httpsSSLConnectionSocketFactory(
+	private LayeredConnectionSocketFactory httpsSSLConnectionSocketFactory(boolean isDisableSslValidation) {
-			boolean isDisableSslValidation) {
 		final SSLConnectionSocketFactoryBuilder sslConnectionSocketFactoryBuilder = SSLConnectionSocketFactoryBuilder
 				.create().setTlsVersions(TLS.V_1_3, TLS.V_1_2);
 
 		if (isDisableSslValidation) {
 			try {
 				final SSLContext sslContext = SSLContext.getInstance("SSL");
-				sslContext.init(null,
+				sslContext.init(null, new TrustManager[] { new DisabledValidationTrustManager() }, new SecureRandom());
-						new TrustManager[] { new DisabledValidationTrustManager() },
-						new SecureRandom());
 				sslConnectionSocketFactoryBuilder.setSslContext(sslContext);
 			}
 			catch (NoSuchAlgorithmException e) {
@@ -133,8 +120,7 @@ public class HttpClient5FeignConfiguration {
 			}
 		}
 		else {
-			sslConnectionSocketFactoryBuilder
+			sslConnectionSocketFactoryBuilder.setSslContext(SSLContexts.createSystemDefault());
-					.setSslContext(SSLContexts.createSystemDefault());
 		}
 
 		return sslConnectionSocketFactoryBuilder.build();
@@ -145,12 +131,10 @@ public class HttpClient5FeignConfiguration {
 		DisabledValidationTrustManager() {
 		}
 
-		public void checkClientTrusted(X509Certificate[] x509Certificates, String s)
+		public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
-				throws CertificateException {
 		}
 
-		public void checkServerTrusted(X509Certificate[] x509Certificates, String s)
+		public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
-				throws CertificateException {
 		}
 
 		public X509Certificate[] getAcceptedIssuers() {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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,8 +20,7 @@ import java.io.IOException;
 import java.util.Timer;
 import java.util.TimerTask;
 
-import javax.annotation.PreDestroy;
+import jakarta.annotation.PreDestroy;
-
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.http.client.config.RequestConfig;
@@ -53,8 +52,8 @@ public class HttpClientFeignConfiguration {
 
 	private static final Log LOG = LogFactory.getLog(HttpClientFeignConfiguration.class);
 
-	private final Timer connectionManagerTimer = new Timer(
+	private final Timer connectionManagerTimer = new Timer("FeignApacheHttpClientConfiguration.connectionManagerTimer",
-			"FeignApacheHttpClientConfiguration.connectionManagerTimer", true);
+			true);
 
 	private CloseableHttpClient httpClient;
 
@@ -66,11 +65,9 @@ public class HttpClientFeignConfiguration {
 	public HttpClientConnectionManager connectionManager(
 			ApacheHttpClientConnectionManagerFactory connectionManagerFactory,
 			FeignHttpClientProperties httpClientProperties) {
-		final HttpClientConnectionManager connectionManager = connectionManagerFactory
+		final HttpClientConnectionManager connectionManager = connectionManagerFactory.newConnectionManager(
-				.newConnectionManager(httpClientProperties.isDisableSslValidation(),
+				httpClientProperties.isDisableSslValidation(), httpClientProperties.getMaxConnections(),
-						httpClientProperties.getMaxConnections(),
+				httpClientProperties.getMaxConnectionsPerRoute(), httpClientProperties.getTimeToLive(),
-						httpClientProperties.getMaxConnectionsPerRoute(),
-						httpClientProperties.getTimeToLive(),
 				httpClientProperties.getTimeToLiveUnit(), this.registryBuilder);
 		this.connectionManagerTimer.schedule(new TimerTask() {
 			@Override
@@ -82,37 +79,30 @@ public class HttpClientFeignConfiguration {
 	}
 
 	@Bean
-	@ConditionalOnProperty(value = "feign.compression.response.enabled",
+	@ConditionalOnProperty(value = "spring.cloud.openfeign.compression.response.enabled", havingValue = "true")
-			havingValue = "true")
+	public CloseableHttpClient customHttpClient(HttpClientConnectionManager httpClientConnectionManager,
-	public CloseableHttpClient customHttpClient(
-			HttpClientConnectionManager httpClientConnectionManager,
 			FeignHttpClientProperties httpClientProperties) {
-		HttpClientBuilder builder = HttpClientBuilder.create().disableCookieManagement()
+		HttpClientBuilder builder = HttpClientBuilder.create().disableCookieManagement().useSystemProperties();
-				.useSystemProperties();
+		this.httpClient = createClient(builder, httpClientConnectionManager, httpClientProperties);
-		this.httpClient = createClient(builder, httpClientConnectionManager,
-				httpClientProperties);
 		return this.httpClient;
 	}
 
 	@Bean
-	@ConditionalOnProperty(value = "feign.compression.response.enabled",
+	@ConditionalOnProperty(value = "spring.cloud.openfeign.compression.response.enabled", havingValue = "false",
-			havingValue = "false", matchIfMissing = true)
+			matchIfMissing = true)
 	public CloseableHttpClient httpClient(ApacheHttpClientFactory httpClientFactory,
-			HttpClientConnectionManager httpClientConnectionManager,
+			HttpClientConnectionManager httpClientConnectionManager, FeignHttpClientProperties httpClientProperties) {
-			FeignHttpClientProperties httpClientProperties) {
+		this.httpClient = createClient(httpClientFactory.createBuilder(), httpClientConnectionManager,
-		this.httpClient = createClient(httpClientFactory.createBuilder(),
+				httpClientProperties);
-				httpClientConnectionManager, httpClientProperties);
 		return this.httpClient;
 	}
 
 	private CloseableHttpClient createClient(HttpClientBuilder builder,
-			HttpClientConnectionManager httpClientConnectionManager,
+			HttpClientConnectionManager httpClientConnectionManager, FeignHttpClientProperties httpClientProperties) {
-			FeignHttpClientProperties httpClientProperties) {
 		RequestConfig defaultRequestConfig = RequestConfig.custom()
 				.setConnectTimeout(httpClientProperties.getConnectionTimeout())
 				.setRedirectsEnabled(httpClientProperties.isFollowRedirects()).build();
-		CloseableHttpClient httpClient = builder
+		CloseableHttpClient httpClient = builder.setDefaultRequestConfig(defaultRequestConfig)
-				.setDefaultRequestConfig(defaultRequestConfig)
 				.setConnectionManager(httpClientConnectionManager).build();
 		return httpClient;
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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,10 +16,10 @@
 
 package org.springframework.cloud.openfeign.clientconfig;
 
+import java.time.Duration;
 import java.util.concurrent.TimeUnit;
 
-import javax.annotation.PreDestroy;
+import jakarta.annotation.PreDestroy;
-
 import okhttp3.ConnectionPool;
 import okhttp3.OkHttpClient;
 
@@ -46,25 +46,23 @@ public class OkHttpFeignConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean(ConnectionPool.class)
-	public ConnectionPool httpClientConnectionPool(
+	public ConnectionPool httpClientConnectionPool(FeignHttpClientProperties httpClientProperties,
-			FeignHttpClientProperties httpClientProperties,
 			OkHttpClientConnectionPoolFactory connectionPoolFactory) {
-		Integer maxTotalConnections = httpClientProperties.getMaxConnections();
+		int maxTotalConnections = httpClientProperties.getMaxConnections();
-		Long timeToLive = httpClientProperties.getTimeToLive();
+		long timeToLive = httpClientProperties.getTimeToLive();
 		TimeUnit ttlUnit = httpClientProperties.getTimeToLiveUnit();
 		return connectionPoolFactory.create(maxTotalConnections, timeToLive, ttlUnit);
 	}
 
 	@Bean
-	public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory,
+	public okhttp3.OkHttpClient client(OkHttpClientFactory httpClientFactory, ConnectionPool connectionPool,
-			ConnectionPool connectionPool,
 			FeignHttpClientProperties httpClientProperties) {
-		Boolean followRedirects = httpClientProperties.isFollowRedirects();
+		boolean followRedirects = httpClientProperties.isFollowRedirects();
-		Integer connectTimeout = httpClientProperties.getConnectionTimeout();
+		int connectTimeout = httpClientProperties.getConnectionTimeout();
-		this.okHttpClient = httpClientFactory
+		Duration reaTimeout = httpClientProperties.getOkHttp().getReadTimeout();
-				.createBuilder(httpClientProperties.isDisableSslValidation())
+		this.okHttpClient = httpClientFactory.createBuilder(httpClientProperties.isDisableSslValidation())
-				.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
+				.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).followRedirects(followRedirects)
-				.followRedirects(followRedirects).connectionPool(connectionPool).build();
+				.readTimeout(reaTimeout).connectionPool(connectionPool).build();
 		return this.okHttpClient;
 	}
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -48,8 +48,7 @@ public abstract class BaseRequestInterceptor implements RequestInterceptor {
 	 * @param name the header name
 	 * @param values the header values
 	 */
-	protected void addHeader(RequestTemplate requestTemplate, String name,
+	protected void addHeader(RequestTemplate requestTemplate, String name, String... values) {
-			String... values) {
 
 		if (!requestTemplate.headers().containsKey(name)) {
 			requestTemplate.header(name, values);

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -39,8 +39,7 @@ import org.springframework.context.annotation.Configuration;
 @EnableConfigurationProperties(FeignClientEncodingProperties.class)
 @ConditionalOnClass(Feign.class)
 @ConditionalOnBean(Client.class)
-@ConditionalOnProperty(value = "feign.compression.response.enabled",
+@ConditionalOnProperty(value = "spring.cloud.openfeign.compression.response.enabled", matchIfMissing = false)
-		matchIfMissing = false)
 // The OK HTTP client uses "transparent" compression.
 // If the accept-encoding header is present it disable transparent compression
 @ConditionalOnMissingBean(type = "okhttp3.OkHttpClient")

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -33,8 +33,7 @@ public class FeignAcceptGzipEncodingInterceptor extends BaseRequestInterceptor {
 	 * Creates new instance of {@link FeignAcceptGzipEncodingInterceptor}.
 	 * @param properties the encoding properties
 	 */
-	protected FeignAcceptGzipEncodingInterceptor(
+	protected FeignAcceptGzipEncodingInterceptor(FeignClientEncodingProperties properties) {
-			FeignClientEncodingProperties properties) {
 		super(properties);
 	}
 
@@ -44,8 +43,8 @@ public class FeignAcceptGzipEncodingInterceptor extends BaseRequestInterceptor {
 	@Override
 	public void apply(RequestTemplate template) {
 
-		addHeader(template, HttpEncoding.ACCEPT_ENCODING_HEADER,
+		addHeader(template, HttpEncoding.ACCEPT_ENCODING_HEADER, HttpEncoding.GZIP_ENCODING,
-				HttpEncoding.GZIP_ENCODING, HttpEncoding.DEFLATE_ENCODING);
+				HttpEncoding.DEFLATE_ENCODING);
 	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -26,14 +26,13 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
  *
  * @author Jakub Narloch
  */
-@ConfigurationProperties("feign.compression.request")
+@ConfigurationProperties("spring.cloud.openfeign.compression.request")
 public class FeignClientEncodingProperties {
 
 	/**
 	 * The list of supported mime types.
 	 */
-	private String[] mimeTypes = new String[] { "text/xml", "application/xml",
+	private String[] mimeTypes = new String[] { "text/xml", "application/xml", "application/json" };
-			"application/json" };
 
 	/**
 	 * The minimum threshold content size.
@@ -77,9 +76,8 @@ public class FeignClientEncodingProperties {
 	@Override
 	public String toString() {
 		return new StringBuilder("FeignClientEncodingProperties{").append("mimeTypes=")
-				.append(Arrays.toString(this.mimeTypes)).append(", ")
+				.append(Arrays.toString(this.mimeTypes)).append(", ").append("minRequestSize=")
-				.append("minRequestSize=").append(this.minRequestSize).append("}")
+				.append(this.minRequestSize).append("}").toString();
-				.toString();
 	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -39,7 +39,7 @@ import org.springframework.context.annotation.Configuration;
 // The OK HTTP client uses "transparent" compression.
 // If the content-encoding header is present it disable transparent compression
 @ConditionalOnMissingBean(type = "okhttp3.OkHttpClient")
-@ConditionalOnProperty("feign.compression.request.enabled")
+@ConditionalOnProperty("spring.cloud.openfeign.compression.request.enabled")
 @AutoConfigureAfter(FeignAutoConfiguration.class)
 public class FeignContentGzipEncodingAutoConfiguration {
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -33,8 +33,7 @@ public class FeignContentGzipEncodingInterceptor extends BaseRequestInterceptor
 	 * Creates new instance of {@link FeignContentGzipEncodingInterceptor}.
 	 * @param properties the encoding properties
 	 */
-	protected FeignContentGzipEncodingInterceptor(
+	protected FeignContentGzipEncodingInterceptor(FeignClientEncodingProperties properties) {
-			FeignClientEncodingProperties properties) {
 		super(properties);
 	}
 
@@ -45,8 +44,8 @@ public class FeignContentGzipEncodingInterceptor extends BaseRequestInterceptor
 	public void apply(RequestTemplate template) {
 
 		if (requiresCompression(template)) {
-			addHeader(template, HttpEncoding.CONTENT_ENCODING_HEADER,
+			addHeader(template, HttpEncoding.CONTENT_ENCODING_HEADER, HttpEncoding.GZIP_ENCODING,
-					HttpEncoding.GZIP_ENCODING, HttpEncoding.DEFLATE_ENCODING);
+					HttpEncoding.DEFLATE_ENCODING);
 		}
 	}
 
@@ -84,7 +83,7 @@ public class FeignContentGzipEncodingInterceptor extends BaseRequestInterceptor
 	}
 
 	/**
-	 * Returns whether the content mime types matches the configures mime types.
+	 * Returns whether the content mime types matches the configured mime types.
 	 * @param contentTypes the content types
 	 * @return true if any specified content type matches the request content types
 	 */
@@ -93,8 +92,7 @@ public class FeignContentGzipEncodingInterceptor extends BaseRequestInterceptor
 			return false;
 		}
 
-		if (getProperties().getMimeTypes() == null
+		if (getProperties().getMimeTypes() == null || getProperties().getMimeTypes().length == 0) {
-				|| getProperties().getMimeTypes().length == 0) {
 			// no specific mime types has been set - matching everything
 			return true;
 		}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2021 the original author or authors.
+ * 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.
@@ -16,26 +16,18 @@
 
 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.RepresentationModel;
+import org.springframework.hateoas.config.HateoasConfiguration;
-import org.springframework.hateoas.mediatype.hal.HalMediaTypeConfiguration;
+import org.springframework.hateoas.config.WebConverters;
-import org.springframework.hateoas.server.mvc.TypeConstrainedMappingJackson2HttpMessageConverter;
-
-import static org.springframework.hateoas.MediaTypes.HAL_JSON;
 
 /**
  * @author Hector Espert
@@ -43,25 +35,15 @@ import static org.springframework.hateoas.MediaTypes.HAL_JSON;
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnWebApplication
-@ConditionalOnClass(RepresentationModel.class)
+@ConditionalOnClass(WebConverters.class)
-@AutoConfigureAfter({ JacksonAutoConfiguration.class,
+@AutoConfigureAfter({ JacksonAutoConfiguration.class, HttpMessageConvertersAutoConfiguration.class,
-		HttpMessageConvertersAutoConfiguration.class,
+		RepositoryRestMvcAutoConfiguration.class, HateoasConfiguration.class })
-		RepositoryRestMvcAutoConfiguration.class })
 public class FeignHalAutoConfiguration {
 
 	@Bean
-	@ConditionalOnBean(HalMediaTypeConfiguration.class)
+	@ConditionalOnBean(WebConverters.class)
-	@ConditionalOnMissingBean
+	HttpMessageConverterCustomizer webConvertersCustomizer(WebConverters webConverters) {
-	public TypeConstrainedMappingJackson2HttpMessageConverter halJacksonHttpMessageConverter(
+		return new WebConvertersCustomizer(webConverters);
-			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

@@ -0,0 +1,41 @@
+/*
+ * 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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -24,43 +24,48 @@ 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.client.loadbalancer.LoadBalancedRetryFactory;
-import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClientsProperties;
+import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 
 /**
- * Configuration instantiating a {@link BlockingLoadBalancerClient}-based {@link Client}
+ * Configuration instantiating a {@link LoadBalancerClient}-based {@link Client} object
- * object that uses {@link Client.Default} under the hood.
+ * 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)
 class DefaultFeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
 	@Conditional(OnRetryNotEnabledCondition.class)
-	public Client feignClient(BlockingLoadBalancerClient loadBalancerClient) {
+	public Client feignClient(LoadBalancerClient loadBalancerClient,
-		return new FeignBlockingLoadBalancerClient(new Client.Default(null, null),
+			LoadBalancerClientFactory loadBalancerClientFactory,
-				loadBalancerClient);
+			List<LoadBalancerFeignRequestTransformer> transformers) {
+		return new FeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient,
+				loadBalancerClientFactory, transformers);
 	}
 
 	@Bean
 	@ConditionalOnMissingBean
 	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
 	@ConditionalOnBean(LoadBalancedRetryFactory.class)
-	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled",
+	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
-			havingValue = "true", matchIfMissing = true)
+			matchIfMissing = true)
-	public Client feignRetryClient(BlockingLoadBalancerClient loadBalancerClient,
+	public Client feignRetryClient(LoadBalancerClient loadBalancerClient,
-			List<LoadBalancedRetryFactory> loadBalancedRetryFactories) {
+			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
-		AnnotationAwareOrderComparator.sort(loadBalancedRetryFactories);
+			List<LoadBalancerFeignRequestTransformer> transformers) {
-		return new RetryableFeignBlockingLoadBalancerClient(
+		return new RetryableFeignBlockingLoadBalancerClient(new Client.Default(null, null), loadBalancerClient,
-				new Client.Default(null, null), loadBalancerClient,
+				loadBalancedRetryFactory, loadBalancerClientFactory, transformers);
-				loadBalancedRetryFactories.get(0));
 	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -19,6 +19,9 @@ 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;
 import feign.Request;
@@ -27,58 +30,124 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import org.springframework.cloud.client.ServiceInstance;
-import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.CompletionContext;
+import org.springframework.cloud.client.loadbalancer.DefaultRequest;
+import org.springframework.cloud.client.loadbalancer.DefaultResponse;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerLifecycle;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerLifecycleValidator;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerProperties;
+import org.springframework.cloud.client.loadbalancer.RequestDataContext;
+import org.springframework.cloud.client.loadbalancer.ResponseData;
+import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
 import org.springframework.http.HttpStatus;
 import org.springframework.util.Assert;
 
+import static org.springframework.cloud.openfeign.loadbalancer.LoadBalancerUtils.buildRequestData;
+import static org.springframework.cloud.openfeign.loadbalancer.LoadBalancerUtils.executeWithLoadBalancerLifecycleProcessing;
+
 /**
- * A {@link Client} implementation that uses {@link BlockingLoadBalancerClient} to select
+ * A {@link Client} implementation that uses {@link LoadBalancerClient} to select a
- * a {@link ServiceInstance} to use while resolving the request host.
+ * {@link ServiceInstance} to use while resolving the request host.
  *
  * @author Olga Maciaszek-Sharma
+ * @author changjin wei(魏昌进)
  * @since 2.2.0
  */
+@SuppressWarnings({ "unchecked", "rawtypes" })
 public class FeignBlockingLoadBalancerClient implements Client {
 
-	private static final Log LOG = LogFactory
+	private static final Log LOG = LogFactory.getLog(FeignBlockingLoadBalancerClient.class);
-			.getLog(FeignBlockingLoadBalancerClient.class);
 
 	private final Client delegate;
 
-	private final BlockingLoadBalancerClient loadBalancerClient;
+	private final LoadBalancerClient loadBalancerClient;
 
-	public FeignBlockingLoadBalancerClient(Client delegate,
+	private final LoadBalancerClientFactory loadBalancerClientFactory;
-			BlockingLoadBalancerClient loadBalancerClient) {
+
+	private final List<LoadBalancerFeignRequestTransformer> transformers;
+
+	/**
+	 * @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.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
 	public Response execute(Request request, Request.Options options) throws IOException {
 		final URI originalUri = URI.create(request.url());
 		String serviceId = originalUri.getHost();
-		Assert.state(serviceId != null,
+		Assert.state(serviceId != null, "Request URI does not contain a valid hostname: " + originalUri);
-				"Request URI does not contain a valid hostname: " + originalUri);
+		String hint = getHint(serviceId);
-		ServiceInstance instance = loadBalancerClient.choose(serviceId);
+		DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest<>(
+				new RequestDataContext(buildRequestData(request), hint));
+		Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator
+				.getSupportedLifecycleProcessors(
+						loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),
+						RequestDataContext.class, ResponseData.class, ServiceInstance.class);
+		supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
+		ServiceInstance instance = loadBalancerClient.choose(serviceId, lbRequest);
+		org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(
+				instance);
 		if (instance == null) {
-			String message = "Load balancer does not contain an instance for the service "
+			String message = "Load balancer does not contain an instance for the service " + serviceId;
-					+ serviceId;
 			if (LOG.isWarnEnabled()) {
 				LOG.warn(message);
 			}
-			return Response.builder().request(request)
+			supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
-					.status(HttpStatus.SERVICE_UNAVAILABLE.value())
+					.onComplete(new CompletionContext<ResponseData, ServiceInstance, RequestDataContext>(
+							CompletionContext.Status.DISCARD, lbRequest, lbResponse)));
+			return Response.builder().request(request).status(HttpStatus.SERVICE_UNAVAILABLE.value())
 					.body(message, StandardCharsets.UTF_8).build();
 		}
-		String reconstructedUrl = loadBalancerClient.reconstructURI(instance, originalUri)
+		String reconstructedUrl = loadBalancerClient.reconstructURI(instance, originalUri).toString();
-				.toString();
+		Request newRequest = buildRequest(request, reconstructedUrl, instance);
-		Request newRequest = buildRequest(request, reconstructedUrl);
+		return executeWithLoadBalancerLifecycleProcessing(delegate, options, newRequest, lbRequest, lbResponse,
-		return delegate.execute(newRequest, options);
+				supportedLifecycleProcessors);
 	}
 
 	protected Request buildRequest(Request request, String reconstructedUrl) {
-		return Request.create(request.httpMethod(), reconstructedUrl, request.headers(),
+		return Request.create(request.httpMethod(), reconstructedUrl, request.headers(), request.body(),
-				request.body(), request.charset(), request.requestTemplate());
+				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
@@ -86,4 +155,11 @@ public class FeignBlockingLoadBalancerClient implements Client {
 		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-2021 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.
@@ -24,36 +24,34 @@ import org.springframework.boot.autoconfigure.AutoConfigureBefore;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
-import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
+import org.springframework.cloud.loadbalancer.config.BlockingLoadBalancerClientAutoConfiguration;
+import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
 import org.springframework.cloud.openfeign.FeignAutoConfiguration;
-import org.springframework.cloud.openfeign.ribbon.FeignRibbonClientAutoConfiguration;
 import org.springframework.cloud.openfeign.support.FeignHttpClientProperties;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 
 /**
- * An autoconfiguration that instantiates {@link BlockingLoadBalancerClient}-based
+ * An autoconfiguration that instantiates {@link LoadBalancerClient}-based implementations
- * implementations of {@link Client}. In order to use this load-balancing mechanism, the
+ * of {@link Client}.
- * Ribbon-based implementation has to be disabled by setting
- * <code>spring.cloud.loadbalancer.ribbon.enabled</code> to <code>true</code>.
  *
  * @author Olga Maciaszek-Sharma
  * @author Nguyen Ky Thanh
  * @since 2.2.0
  */
 @ConditionalOnClass(Feign.class)
-@ConditionalOnBean(BlockingLoadBalancerClient.class)
+@ConditionalOnBean({ LoadBalancerClient.class, LoadBalancerClientFactory.class })
 @AutoConfigureBefore(FeignAutoConfiguration.class)
-@AutoConfigureAfter(FeignRibbonClientAutoConfiguration.class)
+@AutoConfigureAfter({ BlockingLoadBalancerClientAutoConfiguration.class, LoadBalancerAutoConfiguration.class })
 @EnableConfigurationProperties(FeignHttpClientProperties.class)
 @Configuration(proxyBeanMethods = false)
 // 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({ HttpClientFeignLoadBalancerConfiguration.class,
+@Import({ HttpClientFeignLoadBalancerConfiguration.class, OkHttpFeignLoadBalancerConfiguration.class,
-		OkHttpFeignLoadBalancerConfiguration.class,
+		HttpClient5FeignLoadBalancerConfiguration.class, DefaultFeignLoadBalancerConfiguration.class })
-		HttpClient5FeignLoadBalancerConfiguration.class,
-		DefaultFeignLoadBalancerConfiguration.class })
 public class FeignLoadBalancerAutoConfiguration {
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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.
@@ -26,50 +26,55 @@ 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.client.loadbalancer.LoadBalancedRetryFactory;
-import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClientsProperties;
+import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
 import org.springframework.cloud.openfeign.clientconfig.HttpClient5FeignConfiguration;
 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.core.annotation.AnnotationAwareOrderComparator;
 
 /**
- * Configuration instantiating a {@link BlockingLoadBalancerClient}-based {@link Client}
+ * Configuration instantiating a {@link LoadBalancerClient}-based {@link Client} object
- * object that uses {@link ApacheHttp5Client} under the hood.
+ * that uses {@link ApacheHttp5Client} under the hood.
  *
  * @author Nguyen Ky Thanh
+ * @author changjin wei(魏昌进)
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnClass(ApacheHttp5Client.class)
-@ConditionalOnBean(BlockingLoadBalancerClient.class)
+@ConditionalOnBean({ LoadBalancerClient.class, LoadBalancerClientFactory.class })
-@ConditionalOnProperty(value = "feign.httpclient.hc5.enabled", havingValue = "true")
+@ConditionalOnProperty(value = "spring.cloud.openfeign.httpclient.hc5.enabled", havingValue = "true")
 @Import(HttpClient5FeignConfiguration.class)
+@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
 class HttpClient5FeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
 	@Conditional(OnRetryNotEnabledCondition.class)
-	public Client feignClient(BlockingLoadBalancerClient loadBalancerClient,
+	public Client feignClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient5,
-			HttpClient httpClient5) {
+			LoadBalancerClientFactory loadBalancerClientFactory,
+			List<LoadBalancerFeignRequestTransformer> transformers) {
 		Client delegate = new ApacheHttp5Client(httpClient5);
-		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient);
+		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancerClientFactory,
+				transformers);
 	}
 
 	@Bean
 	@ConditionalOnMissingBean
 	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
 	@ConditionalOnBean(LoadBalancedRetryFactory.class)
-	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled",
+	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
-			havingValue = "true", matchIfMissing = true)
+			matchIfMissing = true)
-	public Client feignRetryClient(BlockingLoadBalancerClient loadBalancerClient,
+	public Client feignRetryClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient5,
-			HttpClient httpClient5,
+			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancedRetryFactory> loadBalancedRetryFactories) {
+			List<LoadBalancerFeignRequestTransformer> transformers) {
-		AnnotationAwareOrderComparator.sort(loadBalancedRetryFactories);
 		Client delegate = new ApacheHttp5Client(httpClient5);
-		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient,
+		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancedRetryFactory,
-				loadBalancedRetryFactories.get(0));
+				loadBalancerClientFactory, transformers);
 	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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.
@@ -26,54 +26,59 @@ 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.client.loadbalancer.LoadBalancedRetryFactory;
-import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClientsProperties;
+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;
-import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 
 /**
- * Configuration instantiating a {@link BlockingLoadBalancerClient}-based {@link Client}
+ * Configuration instantiating a {@link LoadBalancerClient}-based {@link Client} object
- * object that uses {@link ApacheHttpClient} under the hood.
+ * that uses {@link ApacheHttpClient} under the hood.
  *
  * @author Olga Maciaszek-Sharma
  * @author Nguyen Ky Thanh
+ * @author changjin wei(魏昌进)
  * @since 2.2.0
  */
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnClass(ApacheHttpClient.class)
-@ConditionalOnBean(BlockingLoadBalancerClient.class)
+@ConditionalOnBean({ LoadBalancerClient.class, LoadBalancerClientFactory.class })
-@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
+@ConditionalOnProperty(value = "spring.cloud.openfeign.httpclient.enabled", matchIfMissing = true)
 @Conditional(HttpClient5DisabledConditions.class)
 @Import(HttpClientFeignConfiguration.class)
+@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
 class HttpClientFeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
 	@Conditional(OnRetryNotEnabledCondition.class)
-	public Client feignClient(BlockingLoadBalancerClient loadBalancerClient,
+	public Client feignClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient,
-			HttpClient httpClient) {
+			LoadBalancerClientFactory loadBalancerClientFactory,
+			List<LoadBalancerFeignRequestTransformer> transformers) {
 		ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
-		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient);
+		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancerClientFactory,
+				transformers);
 	}
 
 	@Bean
 	@ConditionalOnMissingBean
 	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
 	@ConditionalOnBean(LoadBalancedRetryFactory.class)
-	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled",
+	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
-			havingValue = "true", matchIfMissing = true)
+			matchIfMissing = true)
-	public Client feignRetryClient(BlockingLoadBalancerClient loadBalancerClient,
+	public Client feignRetryClient(LoadBalancerClient loadBalancerClient, HttpClient httpClient,
-			HttpClient httpClient,
+			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancedRetryFactory> loadBalancedRetryFactories) {
+			List<LoadBalancerFeignRequestTransformer> transformers) {
-		AnnotationAwareOrderComparator.sort(loadBalancedRetryFactories);
 		ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
-		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient,
+		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancedRetryFactory,
-				loadBalancedRetryFactories.get(0));
+				loadBalancerClientFactory, transformers);
 	}
 
 }

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

@@ -0,0 +1,47 @@
+/*
+ * 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/LoadBalancerResponseStatusCodeException.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -28,18 +28,14 @@ import org.springframework.cloud.client.loadbalancer.RetryableStatusCodeExceptio
  *
  * @author Ryan Baxter
  */
-public class LoadBalancerResponseStatusCodeException
+public class LoadBalancerResponseStatusCodeException extends RetryableStatusCodeException {
-		extends RetryableStatusCodeException {
 
 	private final Response response;
 
-	public LoadBalancerResponseStatusCodeException(String serviceId, Response response,
+	public LoadBalancerResponseStatusCodeException(String serviceId, Response response, byte[] body, URI uri) {
-			byte[] body, URI uri) {
 		super(serviceId, response.status(), response, uri);
-		this.response = Response.builder()
+		this.response = Response.builder().body(new ByteArrayInputStream(body), body.length).headers(response.headers())
-				.body(new ByteArrayInputStream(body), body.length)
+				.reason(response.reason()).status(response.status()).request(response.request()).build();
-				.headers(response.headers()).reason(response.reason())
-				.status(response.status()).request(response.request()).build();
 	}
 
 	@Override

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

@@ -0,0 +1,95 @@
+/*
+ * 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.io.IOException;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Set;
+
+import feign.Client;
+import feign.Request;
+import feign.Response;
+
+import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.cloud.client.loadbalancer.CompletionContext;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerLifecycle;
+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;
+
+/**
+ * @author Olga Maciaszek-Sharma
+ *
+ * A utility class for handling {@link LoadBalancerLifecycle} calls.
+ */
+@SuppressWarnings({ "unchecked", "rawtypes" })
+final class LoadBalancerUtils {
+
+	private LoadBalancerUtils() {
+		throw new IllegalStateException("Can't instantiate a utility class");
+	}
+
+	static Response executeWithLoadBalancerLifecycleProcessing(Client feignClient, Request.Options options,
+			Request feignRequest, org.springframework.cloud.client.loadbalancer.Request lbRequest,
+			org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse,
+			Set<LoadBalancerLifecycle> supportedLifecycleProcessors, boolean loadBalanced) throws IOException {
+		supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStartRequest(lbRequest, lbResponse));
+		try {
+			Response response = feignClient.execute(feignRequest, options);
+			if (loadBalanced) {
+				supportedLifecycleProcessors.forEach(
+						lifecycle -> lifecycle.onComplete(new CompletionContext<>(CompletionContext.Status.SUCCESS,
+								lbRequest, lbResponse, buildResponseData(response))));
+			}
+			return response;
+		}
+		catch (Exception exception) {
+			if (loadBalanced) {
+				supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onComplete(
+						new CompletionContext<>(CompletionContext.Status.FAILED, exception, lbRequest, lbResponse)));
+			}
+			throw exception;
+		}
+	}
+
+	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,
+				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.resolve(request.httpMethod().name()), URI.create(request.url()),
+				requestHeaders, null, new HashMap<>());
+	}
+
+	static Response executeWithLoadBalancerLifecycleProcessing(Client feignClient, Request.Options options,
+			Request feignRequest, org.springframework.cloud.client.loadbalancer.Request lbRequest,
+			org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse,
+			Set<LoadBalancerLifecycle> supportedLifecycleProcessors) throws IOException {
+		return executeWithLoadBalancerLifecycleProcessing(feignClient, options, feignRequest, lbRequest, lbResponse,
+				supportedLifecycleProcessors, true);
+	}
+
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -25,51 +25,56 @@ 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.client.loadbalancer.LoadBalancedRetryFactory;
-import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClientsProperties;
+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;
-import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 
 /**
- * Configuration instantiating a {@link BlockingLoadBalancerClient}-based {@link Client}
+ * Configuration instantiating a {@link LoadBalancerClient}-based {@link Client} object
- * object that uses {@link OkHttpClient} under the hood.
+ * 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("feign.okhttp.enabled")
+@ConditionalOnProperty("spring.cloud.openfeign.okhttp.enabled")
-@ConditionalOnBean(BlockingLoadBalancerClient.class)
+@ConditionalOnBean({ LoadBalancerClient.class, LoadBalancerClientFactory.class })
 @Import(OkHttpFeignConfiguration.class)
+@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
 class OkHttpFeignLoadBalancerConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
 	@Conditional(OnRetryNotEnabledCondition.class)
-	public Client feignClient(okhttp3.OkHttpClient okHttpClient,
+	public Client feignClient(okhttp3.OkHttpClient okHttpClient, LoadBalancerClient loadBalancerClient,
-			BlockingLoadBalancerClient loadBalancerClient) {
+			LoadBalancerClientFactory loadBalancerClientFactory,
+			List<LoadBalancerFeignRequestTransformer> transformers) {
 		OkHttpClient delegate = new OkHttpClient(okHttpClient);
-		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient);
+		return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancerClientFactory,
+				transformers);
 	}
 
 	@Bean
 	@ConditionalOnMissingBean
 	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
 	@ConditionalOnBean(LoadBalancedRetryFactory.class)
-	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled",
+	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "true",
-			havingValue = "true", matchIfMissing = true)
+			matchIfMissing = true)
-	public Client feignRetryClient(BlockingLoadBalancerClient loadBalancerClient,
+	public Client feignRetryClient(LoadBalancerClient loadBalancerClient, okhttp3.OkHttpClient okHttpClient,
-			okhttp3.OkHttpClient okHttpClient,
+			LoadBalancedRetryFactory loadBalancedRetryFactory, LoadBalancerClientFactory loadBalancerClientFactory,
-			List<LoadBalancedRetryFactory> loadBalancedRetryFactories) {
+			List<LoadBalancerFeignRequestTransformer> transformers) {
-		AnnotationAwareOrderComparator.sort(loadBalancedRetryFactories);
 		OkHttpClient delegate = new OkHttpClient(okHttpClient);
-		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient,
+		return new RetryableFeignBlockingLoadBalancerClient(delegate, loadBalancerClient, loadBalancedRetryFactory,
-				loadBalancedRetryFactories.get(0));
+				loadBalancerClientFactory, transformers);
 	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -47,8 +47,7 @@ public class OnRetryNotEnabledCondition extends AnyNestedCondition {
 
 	}
 
-	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled",
+	@ConditionalOnProperty(value = "spring.cloud.loadbalancer.retry.enabled", havingValue = "false")
-			havingValue = "false")
 	static class OnLoadBalancerRetryEnabledCondition {
 
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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,9 +20,11 @@ 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;
+import java.util.Set;
 
 import feign.Client;
 import feign.Request;
@@ -31,12 +33,21 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.cloud.client.loadbalancer.CompletionContext;
+import org.springframework.cloud.client.loadbalancer.DefaultRequest;
+import org.springframework.cloud.client.loadbalancer.DefaultResponse;
 import org.springframework.cloud.client.loadbalancer.InterceptorRetryPolicy;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRecoveryCallback;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
 import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
-import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerLifecycle;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerLifecycleValidator;
+import org.springframework.cloud.client.loadbalancer.LoadBalancerProperties;
+import org.springframework.cloud.client.loadbalancer.ResponseData;
+import org.springframework.cloud.client.loadbalancer.RetryableRequestContext;
+import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpRequest;
@@ -45,78 +56,147 @@ import org.springframework.retry.backoff.BackOffPolicy;
 import org.springframework.retry.backoff.NoBackOffPolicy;
 import org.springframework.retry.policy.NeverRetryPolicy;
 import org.springframework.retry.support.RetryTemplate;
+import org.springframework.util.Assert;
 import org.springframework.util.StreamUtils;
 
+import static org.springframework.cloud.openfeign.loadbalancer.LoadBalancerUtils.buildRequestData;
+
 /**
  * A {@link Client} implementation that provides Spring Retry support for requests
  * load-balanced with Spring Cloud LoadBalancer.
  *
  * @author Olga Maciaszek-Sharma
+ * @author changjin wei(魏昌进)
  * @since 2.2.6
  */
+@SuppressWarnings({ "rawtypes", "unchecked" })
 public class RetryableFeignBlockingLoadBalancerClient implements Client {
 
-	private static final Log LOG = LogFactory
+	private static final Log LOG = LogFactory.getLog(RetryableFeignBlockingLoadBalancerClient.class);
-			.getLog(FeignBlockingLoadBalancerClient.class);
 
 	private final Client delegate;
 
-	private final BlockingLoadBalancerClient loadBalancerClient;
+	private final LoadBalancerClient loadBalancerClient;
 
 	private final LoadBalancedRetryFactory loadBalancedRetryFactory;
 
-	public RetryableFeignBlockingLoadBalancerClient(Client delegate,
+	private final LoadBalancerClientFactory loadBalancerClientFactory;
-			BlockingLoadBalancerClient loadBalancerClient,
+
-			LoadBalancedRetryFactory loadBalancedRetryFactory) {
+	private final List<LoadBalancerFeignRequestTransformer> transformers;
+
+	/**
+	 * @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.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
 	public Response execute(Request request, Request.Options options) throws IOException {
 		final URI originalUri = URI.create(request.url());
 		String serviceId = originalUri.getHost();
-		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryFactory
+		Assert.state(serviceId != null, "Request URI does not contain a valid hostname: " + originalUri);
-				.createRetryPolicy(serviceId, loadBalancerClient);
+		final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryFactory.createRetryPolicy(serviceId,
+				loadBalancerClient);
 		RetryTemplate retryTemplate = buildRetryTemplate(serviceId, request, retryPolicy);
 		return retryTemplate.execute(context -> {
 			Request feignRequest = null;
+			ServiceInstance retrievedServiceInstance = null;
+			Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator
+					.getSupportedLifecycleProcessors(
+							loadBalancerClientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),
+							RetryableRequestContext.class, ResponseData.class, ServiceInstance.class);
+			String hint = getHint(serviceId);
+			DefaultRequest<RetryableRequestContext> lbRequest = new DefaultRequest<>(
+					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) {
-				ServiceInstance serviceInstance = ((LoadBalancedRetryContext) context)
+				LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext) context;
-						.getServiceInstance();
+				ServiceInstance serviceInstance = lbContext.getServiceInstance();
-				if (serviceInstance != null) {
+				if (serviceInstance == null) {
 					if (LOG.isDebugEnabled()) {
-						LOG.debug(String.format(
+						LOG.debug("Service instance retrieved from LoadBalancedRetryContext: was null. "
-								"Using service instance from LoadBalancedRetryContext: %s",
+								+ "Reattempting service instance selection");
-								serviceInstance));
 					}
-					String reconstructedUrl = loadBalancerClient
+					ServiceInstance previousServiceInstance = lbContext.getPreviousServiceInstance();
-							.reconstructURI(serviceInstance, originalUri).toString();
+					lbRequest.getContext().setPreviousServiceInstance(previousServiceInstance);
-					feignRequest = buildRequest(request, reconstructedUrl);
+					supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
+					retrievedServiceInstance = loadBalancerClient.choose(serviceId, lbRequest);
+					if (LOG.isDebugEnabled()) {
+						LOG.debug(String.format("Selected service instance: %s", retrievedServiceInstance));
 					}
+					lbContext.setServiceInstance(retrievedServiceInstance);
 				}
-			if (feignRequest == null) {
+
+				if (retrievedServiceInstance == null) {
 					if (LOG.isWarnEnabled()) {
-					LOG.warn(
+						LOG.warn("Service instance was not resolved, executing the original request");
-							"Service instance was not resolved, executing the original request");
 					}
+					org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(
+							retrievedServiceInstance);
+					supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
+							.onComplete(new CompletionContext<ResponseData, ServiceInstance, RetryableRequestContext>(
+									CompletionContext.Status.DISCARD, lbRequest, lbResponse)));
 					feignRequest = request;
 				}
-			Response response = delegate.execute(feignRequest, options);
+				else {
+					if (LOG.isDebugEnabled()) {
+						LOG.debug(String.format("Using service instance from LoadBalancedRetryContext: %s",
+								retrievedServiceInstance));
+					}
+					String reconstructedUrl = loadBalancerClient.reconstructURI(retrievedServiceInstance, originalUri)
+							.toString();
+					feignRequest = buildRequest(request, reconstructedUrl, retrievedServiceInstance);
+				}
+			}
+			org.springframework.cloud.client.loadbalancer.Response<ServiceInstance> lbResponse = new DefaultResponse(
+					retrievedServiceInstance);
+			Response response = LoadBalancerUtils.executeWithLoadBalancerLifecycleProcessing(delegate, options,
+					feignRequest, lbRequest, lbResponse, supportedLifecycleProcessors,
+					retrievedServiceInstance != null);
 			int responseStatus = response.status();
 			if (retryPolicy != null && retryPolicy.retryableStatusCode(responseStatus)) {
 				if (LOG.isDebugEnabled()) {
-					LOG.debug(
+					LOG.debug(String.format("Retrying on status code: %d", responseStatus));
-							String.format("Retrying on status code: %d", responseStatus));
 				}
 				byte[] byteArray = response.body() == null ? new byte[] {}
 						: StreamUtils.copyToByteArray(response.body().asInputStream());
 				response.close();
-				throw new LoadBalancerResponseStatusCodeException(serviceId, response,
+				throw new LoadBalancerResponseStatusCodeException(serviceId, response, byteArray,
-						byteArray, URI.create(request.url()));
+						URI.create(request.url()));
 			}
 			return response;
 		}, new LoadBalancedRecoveryCallback<Response, Response>() {
@@ -128,26 +208,31 @@ public class RetryableFeignBlockingLoadBalancerClient implements Client {
 	}
 
 	protected Request buildRequest(Request request, String reconstructedUrl) {
-		return Request.create(request.httpMethod(), reconstructedUrl, request.headers(),
+		return Request.create(request.httpMethod(), reconstructedUrl, request.headers(), request.body(),
-				request.body(), request.charset(), request.requestTemplate());
+				request.charset(), request.requestTemplate());
 	}
 
-	private RetryTemplate buildRetryTemplate(String serviceId, Request request,
+	protected Request buildRequest(Request request, String reconstructedUrl, ServiceInstance instance) {
-			LoadBalancedRetryPolicy retryPolicy) {
+		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
+		BackOffPolicy backOffPolicy = this.loadBalancedRetryFactory.createBackOffPolicy(serviceId);
-				.createBackOffPolicy(serviceId);
+		retryTemplate.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
-		retryTemplate.setBackOffPolicy(
+		RetryListener[] retryListeners = this.loadBalancedRetryFactory.createRetryListeners(serviceId);
-				backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
-		RetryListener[] retryListeners = this.loadBalancedRetryFactory
-				.createRetryListeners(serviceId);
 		if (retryListeners != null && retryListeners.length != 0) {
 			retryTemplate.setListeners(retryListeners);
 		}
 
 		retryTemplate.setRetryPolicy(retryPolicy == null ? new NeverRetryPolicy()
-				: new InterceptorRetryPolicy(toHttpRequest(request), retryPolicy,
+				: new InterceptorRetryPolicy(toHttpRequest(request), retryPolicy, loadBalancerClient, serviceId));
-						loadBalancerClient, serviceId));
 		return retryTemplate;
 	}
 
@@ -187,4 +272,11 @@ 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/ribbon/CachingSpringLoadBalancerFactory.java

@@ -1,72 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import java.util.Map;
-
-import com.netflix.client.config.IClientConfig;
-import com.netflix.loadbalancer.ILoadBalancer;
-
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
-import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
-import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
-import org.springframework.util.ConcurrentReferenceHashMap;
-
-/**
- * Factory for SpringLoadBalancer instances that caches the entries created.
- *
- * @author Spencer Gibb
- * @author Dave Syer
- * @author Ryan Baxter
- * @author Gang Li
- */
-public class CachingSpringLoadBalancerFactory {
-
-	protected final SpringClientFactory factory;
-
-	protected LoadBalancedRetryFactory loadBalancedRetryFactory = null;
-
-	private volatile Map<String, FeignLoadBalancer> cache = new ConcurrentReferenceHashMap<>();
-
-	public CachingSpringLoadBalancerFactory(SpringClientFactory factory) {
-		this.factory = factory;
-	}
-
-	public CachingSpringLoadBalancerFactory(SpringClientFactory factory,
-			LoadBalancedRetryFactory loadBalancedRetryPolicyFactory) {
-		this.factory = factory;
-		this.loadBalancedRetryFactory = loadBalancedRetryPolicyFactory;
-	}
-
-	public FeignLoadBalancer create(String clientName) {
-		FeignLoadBalancer client = this.cache.get(clientName);
-		if (client != null) {
-			return client;
-		}
-		IClientConfig config = this.factory.getClientConfig(clientName);
-		ILoadBalancer lb = this.factory.getLoadBalancer(clientName);
-		ServerIntrospector serverIntrospector = this.factory.getInstance(clientName,
-				ServerIntrospector.class);
-		client = this.loadBalancedRetryFactory != null
-				? new RetryableFeignLoadBalancer(lb, config, serverIntrospector,
-						this.loadBalancedRetryFactory)
-				: new FeignLoadBalancer(lb, config, serverIntrospector);
-		this.cache.put(clientName, client);
-		return client;
-	}
-
-}

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

@@ -1,40 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import feign.Client;
-
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-/**
- * @author Spencer Gibb
- */
-@Configuration(proxyBeanMethods = false)
-class DefaultFeignLoadBalancedConfiguration {
-
-	@Bean
-	@ConditionalOnMissingBean
-	public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
-			SpringClientFactory clientFactory) {
-		return new LoadBalancerFeignClient(new Client.Default(null, null), cachingFactory,
-				clientFactory);
-	}
-
-}

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

@@ -1,251 +0,0 @@
-/*
- * Copyright 2013-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import java.io.IOException;
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-
-import com.netflix.client.AbstractLoadBalancerAwareClient;
-import com.netflix.client.ClientRequest;
-import com.netflix.client.IResponse;
-import com.netflix.client.RequestSpecificRetryHandler;
-import com.netflix.client.RetryHandler;
-import com.netflix.client.config.IClientConfig;
-import com.netflix.loadbalancer.ILoadBalancer;
-import com.netflix.loadbalancer.Server;
-import feign.Client;
-import feign.Request;
-import feign.Response;
-
-import org.springframework.cloud.netflix.ribbon.RibbonProperties;
-import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpMethod;
-import org.springframework.http.HttpRequest;
-
-import static org.springframework.cloud.netflix.ribbon.RibbonUtils.updateToSecureConnectionIfNeeded;
-
-/**
- * @author Dave Syer
- * @author Spencer Gibb
- * @author Ryan Baxter
- * @author Tim Ysewyn
- * @author Olga Maciaszek-Sharma
- */
-public class FeignLoadBalancer extends
-		AbstractLoadBalancerAwareClient<FeignLoadBalancer.RibbonRequest, FeignLoadBalancer.RibbonResponse> {
-
-	private final RibbonProperties ribbon;
-
-	protected int connectTimeout;
-
-	protected int readTimeout;
-
-	protected IClientConfig clientConfig;
-
-	protected ServerIntrospector serverIntrospector;
-
-	protected boolean followRedirects;
-
-	public FeignLoadBalancer(ILoadBalancer lb, IClientConfig clientConfig,
-			ServerIntrospector serverIntrospector) {
-		super(lb, clientConfig);
-		setRetryHandler(RetryHandler.DEFAULT);
-		this.clientConfig = clientConfig;
-		this.ribbon = RibbonProperties.from(clientConfig);
-		RibbonProperties ribbon = this.ribbon;
-		connectTimeout = ribbon.getConnectTimeout();
-		readTimeout = ribbon.getReadTimeout();
-		this.serverIntrospector = serverIntrospector;
-		followRedirects = ribbon.isFollowRedirects();
-	}
-
-	@Override
-	public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride)
-			throws IOException {
-		Request.Options options;
-		if (configOverride != null) {
-			RibbonProperties override = RibbonProperties.from(configOverride);
-			options = new Request.Options(override.connectTimeout(connectTimeout),
-					TimeUnit.MILLISECONDS, override.readTimeout(readTimeout),
-					TimeUnit.MILLISECONDS, override.isFollowRedirects(followRedirects));
-		}
-		else {
-			options = new Request.Options(connectTimeout, TimeUnit.MILLISECONDS,
-					readTimeout, TimeUnit.MILLISECONDS, followRedirects);
-		}
-		Response response = request.client().execute(request.toRequest(), options);
-		return new RibbonResponse(request.getUri(), response);
-	}
-
-	@Override
-	public RequestSpecificRetryHandler getRequestSpecificRetryHandler(
-			RibbonRequest request, IClientConfig requestConfig) {
-		if (ribbon.isOkToRetryOnAllOperations()) {
-			return new RequestSpecificRetryHandler(true, true, getRetryHandler(),
-					requestConfig);
-		}
-		if (!request.toRequest().httpMethod().name().equals("GET")) {
-			return new RequestSpecificRetryHandler(true, false, getRetryHandler(),
-					requestConfig);
-		}
-		else {
-			return new RequestSpecificRetryHandler(true, true, getRetryHandler(),
-					requestConfig);
-		}
-	}
-
-	@Override
-	public URI reconstructURIWithServer(Server server, URI original) {
-		URI uri = updateToSecureConnectionIfNeeded(original, clientConfig,
-				serverIntrospector, server);
-		return super.reconstructURIWithServer(server, uri);
-	}
-
-	protected static class RibbonRequest extends ClientRequest implements Cloneable {
-
-		private final Request request;
-
-		private final Client client;
-
-		protected RibbonRequest(Client client, Request request, URI uri) {
-			this.client = client;
-			setUri(uri);
-			this.request = toRequest(request);
-		}
-
-		private Request toRequest(Request request) {
-			Map<String, Collection<String>> headers = new LinkedHashMap<>(
-					request.headers());
-			return Request.create(request.httpMethod(), getUri().toASCIIString(), headers,
-					request.body(), request.charset(), request.requestTemplate());
-		}
-
-		Request toRequest() {
-			return toRequest(request);
-		}
-
-		Client client() {
-			return client;
-		}
-
-		HttpRequest toHttpRequest() {
-			return new HttpRequest() {
-				@Override
-				public HttpMethod getMethod() {
-					return HttpMethod
-							.resolve(RibbonRequest.this.toRequest().httpMethod().name());
-				}
-
-				@Override
-				public String getMethodValue() {
-					return getMethod().name();
-				}
-
-				@Override
-				public URI getURI() {
-					return RibbonRequest.this.getUri();
-				}
-
-				@Override
-				public HttpHeaders getHeaders() {
-					Map<String, List<String>> headers = new HashMap<>();
-					Map<String, Collection<String>> feignHeaders = RibbonRequest.this
-							.toRequest().headers();
-					for (String key : feignHeaders.keySet()) {
-						headers.put(key, new ArrayList<>(feignHeaders.get(key)));
-					}
-					HttpHeaders httpHeaders = new HttpHeaders();
-					httpHeaders.putAll(headers);
-					return httpHeaders;
-
-				}
-			};
-		}
-
-		public Request getRequest() {
-			return request;
-		}
-
-		public Client getClient() {
-			return client;
-		}
-
-		@Override
-		public Object clone() {
-			return new RibbonRequest(client, request, getUri());
-		}
-
-	}
-
-	protected static class RibbonResponse implements IResponse {
-
-		private final URI uri;
-
-		private final Response response;
-
-		protected RibbonResponse(URI uri, Response response) {
-			this.uri = uri;
-			this.response = response;
-		}
-
-		@Override
-		public Object getPayload() {
-			return response.body();
-		}
-
-		@Override
-		public boolean hasPayload() {
-			return response.body() != null;
-		}
-
-		@Override
-		public boolean isSuccess() {
-			return response.status() == 200;
-		}
-
-		@Override
-		public URI getRequestedURI() {
-			return uri;
-		}
-
-		@Override
-		public Map<String, Collection<String>> getHeaders() {
-			return response.headers();
-		}
-
-		Response toResponse() {
-			return response;
-		}
-
-		@Override
-		public void close() throws IOException {
-			if (response != null && response.body() != null) {
-				response.body().close();
-			}
-		}
-
-	}
-
-}

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

@@ -1,129 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import java.net.URI;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.springframework.cloud.client.ServiceInstance;
-import org.springframework.cloud.client.loadbalancer.InterceptorRetryPolicy;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
-import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser;
-import org.springframework.http.HttpRequest;
-import org.springframework.retry.RetryContext;
-
-/**
- * @author Ryan Baxter
- */
-public class FeignRetryPolicy extends InterceptorRetryPolicy {
-
-	private HttpRequest request;
-
-	private String serviceId;
-
-	public FeignRetryPolicy(HttpRequest request, LoadBalancedRetryPolicy policy,
-			ServiceInstanceChooser serviceInstanceChooser, String serviceName) {
-		super(request, policy, serviceInstanceChooser, serviceName);
-		this.request = request;
-		this.serviceId = serviceName;
-	}
-
-	@Override
-	public boolean canRetry(RetryContext context) {
-		/*
-		 * In InterceptorRetryPolicy.canRetry we ask the LoadBalancer to choose a server
-		 * if one is not set in the retry context and then return true. RetryTemplat calls
-		 * the canRetry method of the policy even on its first execution. So the fact that
-		 * we didnt have a service instance set in the RetryContext signaled that it was
-		 * the first execution and we should return true.
-		 *
-		 * In the Feign scenario, Feign as actually already queried the load balancer for
-		 * a service instance and we set that service instance in the context when we call
-		 * the open method of the policy. So in the Feign case we just return true if the
-		 * retry count is 0 indicating we haven't yet made a failed request.
-		 */
-		if (context.getRetryCount() == 0) {
-			return true;
-		}
-		return super.canRetry(context);
-	}
-
-	@Override
-	public RetryContext open(RetryContext parent) {
-		/*
-		 * With Feign (unlike Ribbon) the request already has the URI for the service
-		 * instance we are going to make the request to, so extract that information and
-		 * set the service instance in the context. In the Ribbon scenario the URI in the
-		 * request object still has the service id so we choose and set the service
-		 * instance later on.
-		 */
-		LoadBalancedRetryContext context = new LoadBalancedRetryContext(parent,
-				this.request);
-		context.setServiceInstance(
-				new FeignRetryPolicyServiceInstance(this.serviceId, this.request));
-		return context;
-	}
-
-	class FeignRetryPolicyServiceInstance implements ServiceInstance {
-
-		private String serviceId;
-
-		private HttpRequest request;
-
-		private Map<String, String> metadata;
-
-		FeignRetryPolicyServiceInstance(String serviceId, HttpRequest request) {
-			this.serviceId = serviceId;
-			this.request = request;
-			this.metadata = new HashMap<>();
-		}
-
-		@Override
-		public String getServiceId() {
-			return this.serviceId;
-		}
-
-		@Override
-		public String getHost() {
-			return this.request.getURI().getHost();
-		}
-
-		@Override
-		public int getPort() {
-			return this.request.getURI().getPort();
-		}
-
-		@Override
-		public boolean isSecure() {
-			return "https".equals(this.request.getURI().getScheme());
-		}
-
-		@Override
-		public URI getUri() {
-			return this.request.getURI();
-		}
-
-		@Override
-		public Map<String, String> getMetadata() {
-			return this.metadata;
-		}
-
-	}
-
-}

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

@@ -1,85 +0,0 @@
-/*
- * Copyright 2013-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import com.netflix.loadbalancer.ILoadBalancer;
-import feign.Feign;
-import feign.Request;
-
-import org.springframework.boot.autoconfigure.AutoConfigureBefore;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
-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.netflix.ribbon.SpringClientFactory;
-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;
-import org.springframework.context.annotation.Primary;
-
-/**
- * Autoconfiguration to be activated if Feign is in use and needs to be use Ribbon as a
- * load balancer.
- *
- * @author Dave Syer
- * @author Olga Maciaszek-Sharma
- * @author Nguyen Ky Thanh
- */
-@ConditionalOnClass({ ILoadBalancer.class, Feign.class })
-@ConditionalOnProperty(value = "spring.cloud.loadbalancer.ribbon.enabled",
-		matchIfMissing = true)
-@Configuration(proxyBeanMethods = false)
-@AutoConfigureBefore(FeignAutoConfiguration.class)
-@EnableConfigurationProperties({ FeignHttpClientProperties.class })
-// 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({ HttpClientFeignLoadBalancedConfiguration.class,
-		OkHttpFeignLoadBalancedConfiguration.class,
-		HttpClient5FeignLoadBalancedConfiguration.class,
-		DefaultFeignLoadBalancedConfiguration.class })
-public class FeignRibbonClientAutoConfiguration {
-
-	@Bean
-	@Primary
-	@ConditionalOnMissingBean
-	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
-	public CachingSpringLoadBalancerFactory cachingLBClientFactory(
-			SpringClientFactory factory) {
-		return new CachingSpringLoadBalancerFactory(factory);
-	}
-
-	@Bean
-	@Primary
-	@ConditionalOnMissingBean
-	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
-	public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
-			SpringClientFactory factory, LoadBalancedRetryFactory retryFactory) {
-		return new CachingSpringLoadBalancerFactory(factory, retryFactory);
-	}
-
-	@Bean
-	@ConditionalOnMissingBean
-	public Request.Options feignRequestOptions() {
-		return LoadBalancerFeignClient.DEFAULT_OPTIONS;
-	}
-
-}

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

@@ -1,52 +0,0 @@
-/*
- * Copyright 2013-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import feign.Client;
-import feign.hc5.ApacheHttp5Client;
-import org.apache.hc.client5.http.classic.HttpClient;
-
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
-import org.springframework.cloud.openfeign.clientconfig.HttpClient5FeignConfiguration;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-
-/**
- * Configuration instantiating a {@link LoadBalancerFeignClient}-based {@link Client}
- * object that uses {@link ApacheHttp5Client} under the hood.
- *
- * @author Nguyen Ky Thanh
- */
-@Configuration(proxyBeanMethods = false)
-@ConditionalOnClass(ApacheHttp5Client.class)
-@ConditionalOnProperty(value = "feign.httpclient.hc5.enabled", havingValue = "true")
-@Import(HttpClient5FeignConfiguration.class)
-class HttpClient5FeignLoadBalancedConfiguration {
-
-	@Bean
-	@ConditionalOnMissingBean(Client.class)
-	public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
-			SpringClientFactory clientFactory, HttpClient httpClient5) {
-		Client delegate = new ApacheHttp5Client(httpClient5);
-		return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
-	}
-
-}

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

@@ -1,54 +0,0 @@
-/*
- * Copyright 2013-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import feign.Client;
-import feign.httpclient.ApacheHttpClient;
-import org.apache.http.client.HttpClient;
-
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
-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;
-
-/**
- * @author Spencer Gibb
- * @author Olga Maciaszek-Sharma
- * @author Nguyen Ky Thanh
- */
-@Configuration(proxyBeanMethods = false)
-@ConditionalOnClass(ApacheHttpClient.class)
-@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
-@Conditional(HttpClient5DisabledConditions.class)
-@Import(HttpClientFeignConfiguration.class)
-class HttpClientFeignLoadBalancedConfiguration {
-
-	@Bean
-	@ConditionalOnMissingBean(Client.class)
-	public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
-			SpringClientFactory clientFactory, HttpClient httpClient) {
-		ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
-		return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
-	}
-
-}

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

@@ -1,146 +0,0 @@
-/*
- * Copyright 2013-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import java.io.IOException;
-import java.net.URI;
-
-import com.netflix.client.ClientException;
-import com.netflix.client.config.CommonClientConfigKey;
-import com.netflix.client.config.DefaultClientConfigImpl;
-import com.netflix.client.config.IClientConfig;
-import feign.Client;
-import feign.Request;
-import feign.Response;
-
-import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
-
-/**
- * @author Dave Syer
- * @author Olga Maciaszek-Sharma
- *
- */
-public class LoadBalancerFeignClient implements Client {
-
-	static final Request.Options DEFAULT_OPTIONS = new Request.Options();
-
-	private final Client delegate;
-
-	private CachingSpringLoadBalancerFactory lbClientFactory;
-
-	private SpringClientFactory clientFactory;
-
-	public LoadBalancerFeignClient(Client delegate,
-			CachingSpringLoadBalancerFactory lbClientFactory,
-			SpringClientFactory clientFactory) {
-		this.delegate = delegate;
-		this.lbClientFactory = lbClientFactory;
-		this.clientFactory = clientFactory;
-	}
-
-	static URI cleanUrl(String originalUrl, String host) {
-		String newUrl = originalUrl;
-		if (originalUrl.startsWith("https://")) {
-			newUrl = originalUrl.substring(0, 8)
-					+ originalUrl.substring(8 + host.length());
-		}
-		else if (originalUrl.startsWith("http")) {
-			newUrl = originalUrl.substring(0, 7)
-					+ originalUrl.substring(7 + host.length());
-		}
-		StringBuffer buffer = new StringBuffer(newUrl);
-		if ((newUrl.startsWith("https://") && newUrl.length() == 8)
-				|| (newUrl.startsWith("http://") && newUrl.length() == 7)) {
-			buffer.append("/");
-		}
-		return URI.create(buffer.toString());
-	}
-
-	@Override
-	public Response execute(Request request, Request.Options options) throws IOException {
-		try {
-			URI asUri = URI.create(request.url());
-			String clientName = asUri.getHost();
-			URI uriWithoutHost = cleanUrl(request.url(), clientName);
-			FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
-					this.delegate, request, uriWithoutHost);
-
-			IClientConfig requestConfig = getClientConfig(options, clientName);
-			return lbClient(clientName)
-					.executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
-		}
-		catch (ClientException e) {
-			IOException io = findIOException(e);
-			if (io != null) {
-				throw io;
-			}
-			throw new RuntimeException(e);
-		}
-	}
-
-	IClientConfig getClientConfig(Request.Options options, String clientName) {
-		IClientConfig requestConfig;
-		if (options == DEFAULT_OPTIONS) {
-			requestConfig = this.clientFactory.getClientConfig(clientName);
-		}
-		else {
-			requestConfig = new FeignOptionsClientConfig(options);
-		}
-		return requestConfig;
-	}
-
-	protected IOException findIOException(Throwable t) {
-		if (t == null) {
-			return null;
-		}
-		if (t instanceof IOException) {
-			return (IOException) t;
-		}
-		return findIOException(t.getCause());
-	}
-
-	public Client getDelegate() {
-		return this.delegate;
-	}
-
-	private FeignLoadBalancer lbClient(String clientName) {
-		return this.lbClientFactory.create(clientName);
-	}
-
-	static class FeignOptionsClientConfig extends DefaultClientConfigImpl {
-
-		FeignOptionsClientConfig(Request.Options options) {
-			setProperty(CommonClientConfigKey.ConnectTimeout,
-					options.connectTimeoutMillis());
-			setProperty(CommonClientConfigKey.ReadTimeout, options.readTimeoutMillis());
-			setProperty(CommonClientConfigKey.FollowRedirects,
-					options.isFollowRedirects());
-		}
-
-		@Override
-		public void loadProperties(String clientName) {
-
-		}
-
-		@Override
-		public void loadDefaultValues() {
-
-		}
-
-	}
-
-}

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

@@ -1,49 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import feign.Client;
-import feign.okhttp.OkHttpClient;
-
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
-import org.springframework.cloud.openfeign.clientconfig.OkHttpFeignConfiguration;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-
-/**
- * @author Spencer Gibb
- * @author Olga Maciaszek-Sharma
- */
-@Configuration(proxyBeanMethods = false)
-@ConditionalOnClass(OkHttpClient.class)
-@ConditionalOnProperty("feign.okhttp.enabled")
-@Import(OkHttpFeignConfiguration.class)
-class OkHttpFeignLoadBalancedConfiguration {
-
-	@Bean
-	@ConditionalOnMissingBean(Client.class)
-	public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
-			SpringClientFactory clientFactory, okhttp3.OkHttpClient okHttpClient) {
-		OkHttpClient delegate = new OkHttpClient(okHttpClient);
-		return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
-	}
-
-}

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

@@ -1,141 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import java.io.IOException;
-import java.net.URI;
-
-import com.netflix.client.DefaultLoadBalancerRetryHandler;
-import com.netflix.client.RequestSpecificRetryHandler;
-import com.netflix.client.config.IClientConfig;
-import com.netflix.loadbalancer.ILoadBalancer;
-import com.netflix.loadbalancer.Server;
-import feign.Request;
-import feign.Response;
-
-import org.springframework.cloud.client.ServiceInstance;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRecoveryCallback;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryContext;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryFactory;
-import org.springframework.cloud.client.loadbalancer.LoadBalancedRetryPolicy;
-import org.springframework.cloud.client.loadbalancer.ServiceInstanceChooser;
-import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
-import org.springframework.cloud.netflix.ribbon.RibbonProperties;
-import org.springframework.cloud.netflix.ribbon.ServerIntrospector;
-import org.springframework.retry.RetryListener;
-import org.springframework.retry.backoff.BackOffPolicy;
-import org.springframework.retry.backoff.NoBackOffPolicy;
-import org.springframework.retry.policy.NeverRetryPolicy;
-import org.springframework.retry.support.RetryTemplate;
-import org.springframework.util.StreamUtils;
-
-/**
- * A {@link FeignLoadBalancer} that leverages Spring Retry to retry failed requests.
- *
- * @author Ryan Baxter
- * @author Gang Li
- */
-public class RetryableFeignLoadBalancer extends FeignLoadBalancer
-		implements ServiceInstanceChooser {
-
-	private final LoadBalancedRetryFactory loadBalancedRetryFactory;
-
-	public RetryableFeignLoadBalancer(ILoadBalancer lb, IClientConfig clientConfig,
-			ServerIntrospector serverIntrospector,
-			LoadBalancedRetryFactory loadBalancedRetryFactory) {
-		super(lb, clientConfig, serverIntrospector);
-		this.loadBalancedRetryFactory = loadBalancedRetryFactory;
-		this.setRetryHandler(new DefaultLoadBalancerRetryHandler(clientConfig));
-	}
-
-	@Override
-	public RibbonResponse execute(final RibbonRequest request,
-			IClientConfig configOverride) throws IOException {
-		final Request.Options options;
-		if (configOverride != null) {
-			RibbonProperties ribbon = RibbonProperties.from(configOverride);
-			options = new Request.Options(ribbon.connectTimeout(this.connectTimeout),
-					ribbon.readTimeout(this.readTimeout));
-		}
-		else {
-			options = new Request.Options(this.connectTimeout, this.readTimeout);
-		}
-		final LoadBalancedRetryPolicy retryPolicy = this.loadBalancedRetryFactory
-				.createRetryPolicy(this.getClientName(), this);
-		RetryTemplate retryTemplate = new RetryTemplate();
-		BackOffPolicy backOffPolicy = this.loadBalancedRetryFactory
-				.createBackOffPolicy(this.getClientName());
-		retryTemplate.setBackOffPolicy(
-				backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
-		RetryListener[] retryListeners = this.loadBalancedRetryFactory
-				.createRetryListeners(this.getClientName());
-		if (retryListeners != null && retryListeners.length != 0) {
-			retryTemplate.setListeners(retryListeners);
-		}
-		retryTemplate.setRetryPolicy(retryPolicy == null ? new NeverRetryPolicy()
-				: new FeignRetryPolicy(request.toHttpRequest(), retryPolicy, this,
-						this.getClientName()));
-		return retryTemplate.execute(retryContext -> {
-			Request feignRequest = null;
-			// on retries the policy will choose the server and set it in the context
-			// extract the server and update the request being made
-			if (retryContext instanceof LoadBalancedRetryContext) {
-				ServiceInstance service = ((LoadBalancedRetryContext) retryContext)
-						.getServiceInstance();
-				if (service != null) {
-					feignRequest = ((RibbonRequest) request
-							.replaceUri(reconstructURIWithServer(
-									new Server(service.getHost(), service.getPort()),
-									request.getUri()))).toRequest();
-				}
-			}
-			if (feignRequest == null) {
-				feignRequest = request.toRequest();
-			}
-			Response response = request.client().execute(feignRequest, options);
-			if (retryPolicy != null
-					&& retryPolicy.retryableStatusCode(response.status())) {
-				byte[] byteArray = response.body() == null ? new byte[] {}
-						: StreamUtils.copyToByteArray(response.body().asInputStream());
-				response.close();
-				throw new RibbonResponseStatusCodeException(
-						RetryableFeignLoadBalancer.this.clientName, response, byteArray,
-						request.getUri());
-			}
-			return new RibbonResponse(request.getUri(), response);
-		}, new LoadBalancedRecoveryCallback<RibbonResponse, Response>() {
-			@Override
-			protected RibbonResponse createResponse(Response response, URI uri) {
-				return new RibbonResponse(uri, response);
-			}
-		});
-	}
-
-	@Override
-	public RequestSpecificRetryHandler getRequestSpecificRetryHandler(
-			FeignLoadBalancer.RibbonRequest request, IClientConfig requestConfig) {
-		return new RequestSpecificRetryHandler(false, false, this.getRetryHandler(),
-				requestConfig);
-	}
-
-	@Override
-	public ServiceInstance choose(String serviceId) {
-		return new RibbonLoadBalancerClient.RibbonServer(serviceId,
-				this.getLoadBalancer().chooseServer(serviceId));
-	}
-
-}

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

@@ -1,49 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.ribbon;
-
-import java.io.ByteArrayInputStream;
-import java.net.URI;
-
-import feign.Response;
-
-import org.springframework.cloud.client.loadbalancer.RetryableStatusCodeException;
-
-/**
- * A {@link RetryableStatusCodeException} for {@link Response}s.
- *
- * @author Ryan Baxter
- */
-public class RibbonResponseStatusCodeException extends RetryableStatusCodeException {
-
-	private final Response response;
-
-	public RibbonResponseStatusCodeException(String serviceId, Response response,
-			byte[] body, URI uri) {
-		super(serviceId, response.status(), response, uri);
-		this.response = Response.builder()
-				.body(new ByteArrayInputStream(body), body.length)
-				.headers(response.headers()).reason(response.reason())
-				.status(response.status()).request(response.request()).build();
-	}
-
-	@Override
-	public Response getResponse() {
-		return this.response;
-	}
-
-}

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/security/OAuth2FeignRequestInterceptorBuilder.java

@@ -0,0 +1,81 @@
+/*
+ * 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.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.springframework.http.client.ClientHttpRequestInterceptor;
+import org.springframework.security.oauth2.client.OAuth2ClientContext;
+import org.springframework.security.oauth2.client.resource.OAuth2ProtectedResourceDetails;
+import org.springframework.security.oauth2.client.token.AccessTokenProvider;
+import org.springframework.security.oauth2.client.token.AccessTokenProviderChain;
+import org.springframework.security.oauth2.client.token.OAuth2AccessTokenSupport;
+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;
+
+/**
+ * Allows to customize pre-defined {@link OAuth2FeignRequestInterceptor} using configurer
+ * beans of class {@link OAuth2FeignRequestInterceptorConfigurer}. Each configurer
+ * instance can add {@link AccessTokenProvider} new {@link ClientHttpRequestInterceptor}
+ * instances.
+ *
+ * @author Wojciech Mąka
+ * @since 3.1.1
+ */
+public class OAuth2FeignRequestInterceptorBuilder {
+
+	private AccessTokenProvider accessTokenProvider;
+
+	private final List<ClientHttpRequestInterceptor> accessTokenProviderInterceptors = new ArrayList<>();
+
+	public OAuth2FeignRequestInterceptorBuilder() {
+		accessTokenProvider = new AccessTokenProviderChain(Arrays.<AccessTokenProvider>asList(
+				new AuthorizationCodeAccessTokenProvider(), new ImplicitAccessTokenProvider(),
+				new ResourceOwnerPasswordAccessTokenProvider(), new ClientCredentialsAccessTokenProvider()));
+	}
+
+	public OAuth2FeignRequestInterceptorBuilder withAccessTokenProviderInterceptors(
+			ClientHttpRequestInterceptor... interceptors) {
+		accessTokenProviderInterceptors.addAll(Arrays.asList(interceptors));
+		return this;
+	}
+
+	OAuth2FeignRequestInterceptor build(OAuth2ClientContext oAuth2ClientContext,
+			OAuth2ProtectedResourceDetails resource) {
+		if (OAuth2AccessTokenSupport.class.isAssignableFrom(accessTokenProvider.getClass())) {
+			((OAuth2AccessTokenSupport) accessTokenProvider).setInterceptors(accessTokenProviderInterceptors);
+		}
+		final OAuth2FeignRequestInterceptor feignRequestInterceptor = new OAuth2FeignRequestInterceptor(
+				oAuth2ClientContext, resource);
+		feignRequestInterceptor.setAccessTokenProvider(accessTokenProvider);
+		return feignRequestInterceptor;
+	}
+
+	public static OAuth2FeignRequestInterceptor buildWithConfigurers(OAuth2ClientContext oAuth2ClientContext,
+			OAuth2ProtectedResourceDetails resource, List<OAuth2FeignRequestInterceptorConfigurer> buildConfigurers) {
+		final OAuth2FeignRequestInterceptorBuilder builder = new OAuth2FeignRequestInterceptorBuilder();
+		for (OAuth2FeignRequestInterceptorConfigurer configurer : buildConfigurers) {
+			configurer.customize(builder);
+		}
+		return builder.build(oAuth2ClientContext, resource);
+	}
+
+}

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

@@ -0,0 +1,35 @@
+/*
+ * 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 org.springframework.security.oauth2.client.token.AccessTokenProvider;
+
+/**
+ * Interface for configurer beans working with
+ * {@link OAuth2FeignRequestInterceptorBuilder} in order to provide custom interceptors
+ * for {@link AccessTokenProvider} managed internally by
+ * {@link OAuth2FeignRequestInterceptor}.
+ *
+ * @author Wojciech Mąka
+ * @since 3.1.1
+ */
+@FunctionalInterface
+public interface OAuth2FeignRequestInterceptorConfigurer {
+
+	void customize(OAuth2FeignRequestInterceptorBuilder requestInterceptorBuilder);
+
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -29,7 +29,6 @@ import org.springframework.http.MediaType;
 import org.springframework.web.multipart.MultipartFile;
 
 import static feign.form.ContentProcessor.CRLF;
-import static feign.form.util.PojoUtil.isUserPojo;
 
 /**
  * @author Darren Foong
@@ -45,12 +44,10 @@ public abstract class AbstractFormWriter extends AbstractWriter {
 	@Override
 	public void write(Output output, String key, Object object) throws EncodeException {
 		try {
-			String string = new StringBuilder()
+			String string = new StringBuilder().append("Content-Disposition: form-data; name=\"").append(key)
-					.append("Content-Disposition: form-data; name=\"").append(key)
+					.append('"').append(CRLF).append("Content-Type: ").append(getContentType()).append("; charset=")
-					.append('"').append(CRLF).append("Content-Type: ")
+					.append(output.getCharset().name()).append(CRLF).append(CRLF).append(writeAsString(object))
-					.append(getContentType()).append("; charset=")
+					.toString();
-					.append(output.getCharset().name()).append(CRLF).append(CRLF)
-					.append(writeAsString(object)).toString();
 
 			output.write(string);
 		}

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

@@ -1,85 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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

@@ -1,59 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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

@@ -0,0 +1,54 @@
+/*
+ * 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/FallbackCommand.java

@@ -1,79 +0,0 @@
-/*
- * Copyright 2013-2020 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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 com.netflix.hystrix.HystrixCommand;
-import com.netflix.hystrix.HystrixCommandGroupKey;
-import com.netflix.hystrix.HystrixThreadPoolKey;
-
-/**
- * Convenience class for implementing feign fallbacks that return {@link HystrixCommand}.
- * Also useful for return types of {@link rx.Observable} and
- * {@link java.util.concurrent.Future}. For those return types, just call
- * {@link FallbackCommand#observe()} or {@link FallbackCommand#queue()} respectively.
- *
- * @param <T> result type
- * @author Spencer Gibb
- */
-public class FallbackCommand<T> extends HystrixCommand<T> {
-
-	private T result;
-
-	public FallbackCommand(T result) {
-		this(result, "fallback");
-	}
-
-	protected FallbackCommand(T result, String groupname) {
-		super(HystrixCommandGroupKey.Factory.asKey(groupname));
-		this.result = result;
-	}
-
-	public FallbackCommand(T result, HystrixCommandGroupKey group) {
-		super(group);
-		this.result = result;
-	}
-
-	public FallbackCommand(T result, HystrixCommandGroupKey group,
-			int executionIsolationThreadTimeoutInMilliseconds) {
-		super(group, executionIsolationThreadTimeoutInMilliseconds);
-		this.result = result;
-	}
-
-	public FallbackCommand(T result, HystrixCommandGroupKey group,
-			HystrixThreadPoolKey threadPool) {
-		super(group, threadPool);
-		this.result = result;
-	}
-
-	public FallbackCommand(T result, HystrixCommandGroupKey group,
-			HystrixThreadPoolKey threadPool,
-			int executionIsolationThreadTimeoutInMilliseconds) {
-		super(group, threadPool, executionIsolationThreadTimeoutInMilliseconds);
-		this.result = result;
-	}
-
-	public FallbackCommand(T result, Setter setter) {
-		super(setter);
-		this.result = result;
-	}
-
-	@Override
-	protected T run() throws Exception {
-		return this.result;
-	}
-
-}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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.
@@ -24,7 +24,7 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
  * @author Olga Maciaszek-Sharma
  * @since 2.2.8
  */
-@ConfigurationProperties("feign.encoder")
+@ConfigurationProperties("spring.cloud.openfeign.encoder")
 public class FeignEncoderProperties {
 
 	/**

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2021 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,15 +16,19 @@
 
 package org.springframework.cloud.openfeign.support;
 
+import java.time.Duration;
 import java.util.concurrent.TimeUnit;
 
+import feign.okhttp.OkHttpClient;
+
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
 /**
  * @author Ryan Baxter
  * @author Nguyen Ky Thanh
+ * @author Olga Maciaszek-Sharma
  */
-@ConfigurationProperties(prefix = "feign.httpclient")
+@ConfigurationProperties(prefix = "spring.cloud.openfeign.httpclient")
 public class FeignHttpClientProperties {
 
 	/**
@@ -88,8 +92,13 @@ public class FeignHttpClientProperties {
 	 */
 	private Hc5Properties hc5 = new Hc5Properties();
 
+	/**
+	 * Additional {@link OkHttpClient}-specific properties.
+	 */
+	private OkHttp okHttp = new OkHttp();
+
 	public int getConnectionTimerRepeat() {
-		return this.connectionTimerRepeat;
+		return connectionTimerRepeat;
 	}
 
 	public void setConnectionTimerRepeat(int connectionTimerRepeat) {
@@ -97,7 +106,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public boolean isDisableSslValidation() {
-		return this.disableSslValidation;
+		return disableSslValidation;
 	}
 
 	public void setDisableSslValidation(boolean disableSslValidation) {
@@ -105,7 +114,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public int getMaxConnections() {
-		return this.maxConnections;
+		return maxConnections;
 	}
 
 	public void setMaxConnections(int maxConnections) {
@@ -113,7 +122,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public int getMaxConnectionsPerRoute() {
-		return this.maxConnectionsPerRoute;
+		return maxConnectionsPerRoute;
 	}
 
 	public void setMaxConnectionsPerRoute(int maxConnectionsPerRoute) {
@@ -121,7 +130,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public long getTimeToLive() {
-		return this.timeToLive;
+		return timeToLive;
 	}
 
 	public void setTimeToLive(long timeToLive) {
@@ -129,7 +138,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public TimeUnit getTimeToLiveUnit() {
-		return this.timeToLiveUnit;
+		return timeToLiveUnit;
 	}
 
 	public void setTimeToLiveUnit(TimeUnit timeToLiveUnit) {
@@ -137,7 +146,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public boolean isFollowRedirects() {
-		return this.followRedirects;
+		return followRedirects;
 	}
 
 	public void setFollowRedirects(boolean followRedirects) {
@@ -145,7 +154,7 @@ public class FeignHttpClientProperties {
 	}
 
 	public int getConnectionTimeout() {
-		return this.connectionTimeout;
+		return connectionTimeout;
 	}
 
 	public void setConnectionTimeout(int connectionTimeout) {
@@ -160,6 +169,14 @@ public class FeignHttpClientProperties {
 		this.hc5 = hc5;
 	}
 
+	public OkHttp getOkHttp() {
+		return okHttp;
+	}
+
+	public void setOkHttp(OkHttp okHttp) {
+		this.okHttp = okHttp;
+	}
+
 	public static class Hc5Properties {
 
 		/**
@@ -203,11 +220,10 @@ public class FeignHttpClientProperties {
 		private TimeUnit socketTimeoutUnit = DEFAULT_SOCKET_TIMEOUT_UNIT;
 
 		public PoolConcurrencyPolicy getPoolConcurrencyPolicy() {
-			return this.poolConcurrencyPolicy;
+			return poolConcurrencyPolicy;
 		}
 
-		public void setPoolConcurrencyPolicy(
+		public void setPoolConcurrencyPolicy(PoolConcurrencyPolicy poolConcurrencyPolicy) {
-				PoolConcurrencyPolicy poolConcurrencyPolicy) {
 			this.poolConcurrencyPolicy = poolConcurrencyPolicy;
 		}
 
@@ -273,4 +289,24 @@ 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);
+
+		public Duration getReadTimeout() {
+			return readTimeout;
+		}
+
+		public void setReadTimeout(Duration readTimeout) {
+			this.readTimeout = readTimeout;
+		}
+
+	}
+
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.
@@ -54,10 +54,8 @@ public final class FeignUtils {
 		return headers;
 	}
 
-	static Collection<String> addTemplateParameter(Collection<String> possiblyNull,
+	static Collection<String> addTemplateParameter(Collection<String> possiblyNull, String paramName) {
-			String paramName) {
+		Collection<String> params = ofNullable(possiblyNull).map(ArrayList::new).orElse(new ArrayList<>());
-		Collection<String> params = ofNullable(possiblyNull).map(ArrayList::new)
-				.orElse(new ArrayList<>());
 		params.add(String.format("{%s}", paramName));
 		return params;
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 the original author or authors.
+ * 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.
@@ -14,25 +14,20 @@
  * limitations under the License.
  */
 
-package org.springframework.cloud.openfeign.hystrix.security.app;
+package org.springframework.cloud.openfeign.support;
 
-import java.util.concurrent.Callable;
+import java.util.List;
+import java.util.function.Consumer;
 
-import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;
+import org.springframework.http.converter.HttpMessageConverter;
 
-public class CustomConcurrenyStrategy extends HystrixConcurrencyStrategy {
+/**
-
+ * Allows customising {@link HttpMessageConverter} objects passed via {@link Consumer}
-	private boolean hookCalled;
+ * parameter.
-
+ *
-	@Override
+ * @author Olga Maciaszek-Sharma
-	public <T> Callable<T> wrapCallable(Callable<T> callable) {
+ * @since 3.1.0
-		this.hookCalled = true;
+ */
-
+public interface HttpMessageConverterCustomizer extends Consumer<List<HttpMessageConverter<?>>> {
-		return super.wrapCallable(callable);
-	}
-
-	public boolean isHookCalled() {
-		return this.hookCalled;
-	}
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2020 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.