SpringCloud Feign 配置

Feign 日志默认只在 debug 级别才能打印，而生产环境日志级别为 info 或更高，因此需要修改 Feign 日志打印策略

Feign 日志配置
解决Feign只打印DEBUG级别日志方式1
- 在logback-spring.xml文件为Feign添加单独的处理
解决Feign只打印DEBUG级别日志方式2
- 自定义Feign日志打印规则
- logback-spring.xml添加info级别记录即可
Feign配置使用OKHttp
Feign配置
- 请求压缩
- 负载均衡

# Feign 日志配置

配置文件

feign:
  okhttp:
    enabled: true
  client:
    config:
      default: # 服务名 填写default表示为所有服务 或者指定某个服务 如 order
        loggerLevel: FULL

1
2
3
4
5
6
7

loggerLevel取值：

NONE 无记录(DEFAULT)
BASIC 只记录请求方法和URL以及响应状态代码和执行时间
HEADERS 记录基本信息以及请求和响应标头
FULL 记录请求和响应的头文件，正文和元数据

# 解决Feign只打印DEBUG级别日志方式1

# 在`logback-spring.xml`文件为Feign添加单独的处理

	<appender name="FEIGN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/${APP_NAME}-feign.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志归档 -->
            <fileNamePattern>${log.path}/${APP_NAME}/${APP_NAME}-feign-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>365</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录debug级别以上的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
        </filter>
    </appender>
	<logger name="com.wh.feign" level="debug">
 		<appender-ref ref="FEIGN_FILE"/>
	</logger>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Feign的日志会被单独记录到文件中

# 解决Feign只打印DEBUG级别日志方式2

# 自定义Feign日志打印规则

package com.wh.config;

import feign.Logger;
import feign.Request;
import feign.Response;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.openfeign.FeignLoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;

/**
 * @author wangwenhao
 * @description FeignLoggerConfiguration
 * @date 2020-06-17 10:08
 */
@Configuration
public class FeignLoggerConfiguration {

    @Bean
    public InfoFeignLoggerFactory infoFeignLoggerFactory() {
        return new InfoFeignLoggerFactory();
    }

    public static class InfoFeignLoggerFactory implements FeignLoggerFactory {

        @Override
        public Logger create(Class<?> type) {
            return new InfoFeignLogger(LoggerFactory.getLogger(type));
        }
    }

    public static class InfoFeignLogger extends Logger {

        private final org.slf4j.Logger logger;

        public InfoFeignLogger(org.slf4j.Logger logger) {
            this.logger = logger;
        }

        @Override
        protected void log(String configKey, String format, Object... args) {
            // info 级别
            if (logger.isInfoEnabled()) {
                this.logger.info(String.format(methodTag(configKey) + format, args));
            }
        }

        @Override
        protected void logRequest(String configKey, Level logLevel, Request request) {
            // info 级别
            if (logger.isInfoEnabled()) {
                super.logRequest(configKey, logLevel, request);
            }
        }

        @Override
        protected Response logAndRebufferResponse(String configKey, Level logLevel, Response response, long elapsedTime) throws IOException {
            // info 级别
            if (logger.isInfoEnabled()) {
                return super.logAndRebufferResponse(configKey, logLevel, response, elapsedTime);
            }
            return response;
        }
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

# `logback-spring.xml`添加`info`级别记录即可

<logger name="com.wh.feign" level="info"/>

此时Feign打印的日志就是INFO级别的

# `Feign`配置使用`OKHttp`

# 1.引入OKHttp依赖

		<dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>3.14.9</version>
        </dependency>

        <dependency>
            <groupId>io.github.openfeign</groupId>
            <artifactId>feign-okhttp</artifactId>
            <version>11.0</version>
        </dependency>

1
2
3
4
5
6
7
8
9
10
11

# 2.修改配置文件

feign:
  okhttp:
    enabled: true
  client:
    config:
      default: # 服务名 填写default表示为所有服务 或者指定某个服务 如 order
        connectTimeout: 10000 # 连接超时 10秒
        readTimeout: 20000 # 读取超时 20秒
# 配置Ribbon
ribbon:
  okhttp:
    enabled: true

1
2
3
4
5
6
7
8
9
10
11
12

# 3.添加`OKHttp`配置类

package com.wh.config;

import feign.Feign;
import okhttp3.ConnectionPool;
import okhttp3.OkHttpClient;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.cloud.openfeign.FeignAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

/**
 * @author wangwenhao
 * @description Feign底层使用OKHttp访问配置
 * @date 2020-06-16 16:14
 */
@Configuration
@ConditionalOnClass(Feign.class)
@AutoConfigureBefore(FeignAutoConfiguration.class)
public class FeignClientOkHttpConfiguration {

    @Bean
    public OkHttpClient okHttpClient() {
        return new OkHttpClient.Builder()
                // 连接池
                .connectionPool(new ConnectionPool(200, 5, TimeUnit.MINUTES))
                // 连接超时
                .connectTimeout(30L, TimeUnit.SECONDS)
                // 写超时
                .writeTimeout(30L, TimeUnit.SECONDS)
                // 读取超时
                .readTimeout(30L, TimeUnit.SECONDS)
                // 自动重连
                .retryOnConnectionFailure(true)
                .build();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# Feign配置

feign:
	client:
		config:
			feignName: ##定义FeginClient的名称 配置全局则将该名字设置为 default
                connectTimeout: 5000 # 相当于Request.Options
                readTimeout: 5000 # 相当于Request.Options
                # 配置Feign的日志级别，相当于代码配置方式中的Logger
                loggerLevel: FULL
                # Feign的错误解码器，相当于代码配置方式中的ErrorDecoder
                errorDecoder: com.example.SimpleErrorDecoder
                # 配置重试，相当于代码配置方式中的Retryer
                retryer: com.example.SimpleRetryer
                # 配置拦截器，相当于代码配置方式中的RequestInterceptor
                requestInterceptors:
                	- com.example.FooRequestInterceptor
                	- com.example.BarRequestInterceptor
                decode404: false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

feignName：FeginClient的名称
connectTimeout ：建立链接的超时时长
readTimeout ：读取超时时长
loggerLevel: Fegin的日志级别
errorDecoder ：Feign的错误解码器
retryer ：配置重试
requestInterceptors ：添加请求拦截器
decode404 ：配置熔断不处理404异常

# 请求压缩

feign:
	compression:
		request:
			enabled: true # 开启请求压缩
			mime-types: text/html,application/xml,application/json # 设置压缩的数据类型
			min-request-size: 2048 # 设置触发压缩的大小下限
		response:
			enabled: true # 开启响应压缩

1
2
3
4
5
6
7
8

配置对请求和响应进行GZIP压缩，并可以配置要压缩的数据类型和触发下限

# 负载均衡

feign默认使用ribbon的轮询算法进行负载均衡，可以通过以下配置修改负载均衡策略
```
服务名称:
	ribbon:
		NFLoadBalancerRuleClassName: 策略类的全类名
```
1
2
3

com.netflix.loadbalancer.RoundRobinRule ：以轮询的方式进行负载均衡。
com.netflix.loadbalancer.RandomRule ：随机策略
com.netflix.loadbalancer.RetryRule ：重试策略。
com.netflix.loadbalancer.WeightedResponseTimeRule ：权重策略。会计算每个服务的权重，越高的被调用的可能性越大。
com.netflix.loadbalancer.BestAvailableRule ：最佳策略。遍历所有的服务实例，过滤掉故障实例，并返回请求数最小的实例返回。
com.netflix.loadbalancer.AvailabilityFilteringRule ：可用过滤策略。过滤掉故障和请求数超过阈值的服务实例，再从剩下的实力中轮询调用。

水星记

Choose mode