假装客户端请求和响应以及 URL 日志记录

Question

如何记录Feign客户端请求，响应和URL的有效负载。 我必须实现拦截器吗？因为我的要求是将请求和响应记录在数据库上的特殊表上。

Answer 1

> Feign 具有开箱即用的日志记录机制，可以通过简单的步骤来实现。

如果您使用的是弹簧云启动器假装

假装使用Slf4jLogger进行日志记录。佯装日志记录文档

根据文档，以下日志记录级别可供配置，

• NONE- 无日志记录(默认)。
• BASIC- 仅记录请求方法和 URL 以及响应状态代码和执行时间。
• HEADERS- 记录基本信息以及请求和响应标头。
• FULL- 记录请求和响应的标头、正文和元数据。

注入Logger.Level豆就足够了。

@Bean
Logger.Level feignLoggerLevel() {
return Logger.Level.BASIC;
}

或

如果希望使用配置属性来配置所有@FeignClient，则可以使用默认假名称创建配置属性。

feign:
client:
config:
default:
loggerLevel: basic

如果您使用的是'io.github.openfeign:feign-core'

如果您正在构建 Feign 构建器，那么您可以将logLevel(Level.BASIC)提及为

Feign.builder()
.logger(new Slf4jLogger())
.logLevel(Level.BASIC)
.target(SomeFeignClient.class, url);

我们可以灵活地自定义日志记录消息

默认假装请求和响应日志记录

请求日志记录

响应日志记录

我们可以通过覆盖Logger#logRequest和Logger#logAndRebufferResponse方法来自定义假请求、响应日志记录模式。在以下示例中，我们自定义了请求日志记录模式

log(configKey, "---> %s %s HTTP/1.1 (%s-byte body) ", request.httpMethod().name(), request.url(), bodyLength);

和响应日志记录模式

log(configKey, "<--- %s %s HTTP/1.1 %s (%sms) ", request.httpMethod().name(), request.url(), status, elapsedTime);

完整示例是

import feign.Logger;
import feign.Request;
import feign.Response;
import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import static feign.Logger.Level.HEADERS;
@Slf4j
public class CustomFeignRequestLogging extends Logger {
@Override
protected void logRequest(String configKey, Level logLevel, Request request) {
if (logLevel.ordinal() >= HEADERS.ordinal()) {
super.logRequest(configKey, logLevel, request);
} else {
int bodyLength = 0;
if (request.requestBody().asBytes() != null) {
bodyLength = request.requestBody().asBytes().length;
}
log(configKey, "---> %s %s HTTP/1.1 (%s-byte body) ", request.httpMethod().name(), request.url(), bodyLength);
}
}
@Override
protected Response logAndRebufferResponse(String configKey, Level logLevel, Response response, long elapsedTime)
throws IOException {
if (logLevel.ordinal() >= HEADERS.ordinal()) {
return super.logAndRebufferResponse(configKey, logLevel, response, elapsedTime);
} else {
int status = response.status();
Request request = response.request();
log(configKey, "<--- %s %s HTTP/1.1 %s (%sms) ", request.httpMethod().name(), request.url(), status, elapsedTime);
return response;   
}        
}

@Override
protected void log(String configKey, String format, Object... args) {
log.debug(format(configKey, format, args));
}
protected String format(String configKey, String format, Object... args) {
return String.format(methodTag(configKey) + format, args);
}
}

注意：可以轻松记录请求有效负载

String bodyText =
request.charset() != null ? new String(request.body(), request.charset()) : null;

但是，在读取输入流后要小心编写响应有效负载Util.toByteArray(response.body().asInputStream())然后您必须像response.toBuilder().body(bodyData).build()一样再次构造响应。否则，你最终会得到期望。原因是响应流被读取并在返回之前始终关闭，这就是该方法被命名为logAndRebufferResponse

如何使用自定义CustomFeignRequestLogging？

如果您仅使用'io.github.openfeign:feign-core'构建假客户端

Feign.builder()
.logger(new CustomFeignRequestLogging())
.logLevel(feign.Logger.Level.BASIC);

如果您使用的是'org.springframework.cloud:spring-cloud-starter-openfeign'

@Configuration
public class FeignLoggingConfiguration {
@Bean
public CustomFeignRequestLogging customFeignRequestLogging() {
return new CustomFeignRequestLogging();
}
@Bean
Logger.Level feignLoggerLevel() {
return Logger.Level.BASIC;
}
}

Answer 2

在我将以下设置添加到我的 application.yml 文件之前，接受的答案对我不起作用：

logging:
level:
com:
mypackage1:
mysubackage1:
mysubpackage2: DEBUG

Answer 3

我正在使用Feign客户端构建器，如下所示

@Bean
public VpsFeignClient vpsFeignClient() {
return Feign.builder()
.encoder(new FormEncoder(new GsonEncoder()))
.decoder(new GsonDecoder())
.logger(new Slf4jLogger(VpsFeignClient.class))
.logLevel(feignLoggerLevel())
.retryer(new Default())
.errorDecoder(new CustomServerErrorDecoder())
.requestInterceptor(template -> {
//Set some header if necessary
template.header("Content-Type", "application/json");
})
.contract(new SpringMvcContract())
.target(VpsFeignClient.class, dataVpsEndpoint);
}

我的假装是

public interface VpsFeignClient {
@RequestMapping(path = "/test", method = RequestMethod.GET)
TimeRespDto getTestValue();
}

Answer 4

Feign提供了一个可以记录完整请求和响应的Logger接口。 您需要在 Feign 生成器或配置中设置Logger.Level。

Feign.builder()
.logLevel(Logger.Level.FULL) // this will log the request and response
.target(MyApi, "my host");

Answer 5

在你的RestConfiguration 中，你需要提高默认的日志记录 feignClient 级别，并通过@Bean feignLogger 覆盖，如下所示：

@Configuration(proxyBeanMethods = false)
@EnableCircuitBreaker
@EnableFeignClients(basePackageClasses = [Application::class])
class RestConfiguration: WebMvcConfigurer {
@Bean
fun feignLoggerLevel(): Logger.Level {
return Logger.Level.FULL
}
@Bean
fun feignLogger(): Logger {
return FeignClientLogger()
}
}

并根据需要实现您的记录器。例如，日志格式的日志记录：

import feign.Logger
import feign.Request
import feign.Response
import feign.Util.*
import org.slf4j.LoggerFactory
class FeignClientLogger : Logger() {
private val log = LoggerFactory.getLogger(this::class.java)
override fun logRequest(configKey: String?, logLevel: Level?, request: Request?) {
if (request == null)
return
val feignRequest = FeignRequest()
feignRequest.method = request.httpMethod().name
feignRequest.url = request.url()
for (field in request.headers().keys) {
for (value in valuesOrEmpty(request.headers(), field)) {
feignRequest.addHeader(field, value)
}
}
if (request.requestBody() != null) {
feignRequest.body = request.requestBody().asString()
}
log.trace(feignRequest.toString())
}
override fun logAndRebufferResponse(
configKey: String?,
logLevel: Level?,
response: Response?,
elapsedTime: Long
): Response? {
if (response == null)
return response
val feignResponse = FeignResponse()
val status = response.status()
feignResponse.status = response.status()
feignResponse.reason =
(if (response.reason() != null && logLevel!! > Level.NONE) " " + response.reason() else "")
feignResponse.duration = elapsedTime
if (logLevel!!.ordinal >= Level.HEADERS.ordinal) {
for (field in response.headers().keys) {
for (value in valuesOrEmpty(response.headers(), field)) {
feignResponse.addHeader(field, value)
}
}
if (response.body() != null && !(status == 204 || status == 205)) {
val bodyData: ByteArray = toByteArray(response.body().asInputStream())
if (logLevel.ordinal >= Level.FULL.ordinal && bodyData.isNotEmpty()) {
feignResponse.body = decodeOrDefault(bodyData, UTF_8, "Binary data")
}
log.trace(feignResponse.toString())
return response.toBuilder().body(bodyData).build()
} else {
log.trace(feignResponse.toString())
}
}
return response
}
override fun log(p0: String?, p1: String?, vararg p2: Any?) {}
}
class FeignResponse {
var status = 0
var reason: String? = null
var duration: Long = 0
private val headers: MutableList<String> = mutableListOf()
var body: String? = null
fun addHeader(key: String?, value: String?) {
headers.add("$key: $value")
}
override fun toString() =
"""{"type":"response","status":"$status","duration":"$duration","headers":$headers,"body":$body,"reason":"$reason"}"""
}
class FeignRequest {
var method: String? = null
var url: String? = null
private val headers: MutableList<String> = mutableListOf()
var body: String? = null
fun addHeader(key: String?, value: String?) {
headers.add("$key: $value")
}
override fun toString() =
"""{"type":"request","method":"$method","url":"$url","headers":$headers,"body":$body}"""
}

Answer 6

Feign 客户端响应没有拦截器。请求拦截器仅适用于 Feign 客户端。

最好的解决方案是使用 RestTemplate 而不是假装：

@Configuration
public class RestConfiguration {
@Bean
public RestTemplate restTemplate() {
RestTemplate restTemplate
= new RestTemplate(
new BufferingClientHttpRequestFactory(
new SimpleClientHttpRequestFactory()
)
);
List<ClientHttpRequestInterceptor> interceptors = restTemplate.getInterceptors();
if (CollectionUtils.isEmpty(interceptors)) {
interceptors = new ArrayList<>();
}
interceptors.add(new UserRestTemplateClientInterceptor());
restTemplate.setInterceptors(interceptors);
return restTemplate;
}
}

@Autowire要在其中使用的restTemplate

，如下所示：

@Autowire
RestTemplate restTemplate;