全局记录Feign的请求和响应日志方式

package com.example.demo.feign;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.WEB.bind.annotation.GetMapping;
@FeignClient(name = "deom", url = "https://www.baidu.com")
public interface FeignDemo {
    @GetMapping("/")
    String test();
}

logging:
  level:
    com.example.demo.feign.FeignDemo: debug
# 下面的配置，也可以写代码代替
# @Bean
# public Logger.Level level() { return Logger.Level.FULL; }
feign:
  client:
    config:
      default:
        loggerLevel: full

package com.example.demo.cacheDemo;
import feign.slf4j.Slf4jLogger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class FeignConfiguration {
    @Bean
    public feign.Logger logger() {
        return new Slf4jLogger();
    }
}

logging:
  level:
    # 删除具体的FeignClient接口配置，只保留这一个就好了
    feign.Logger: debug
# 也可以写代码代替
# @Bean
# public Logger.Level level() { return Logger.Level.FULL; }
feign:
  client:
    config:
      default:
        loggerLevel: full

// 默认不注入，如果yml配置里有 logging.level.beinet.cn.demostudy.MyClient 才注入
@Bean
@ConditionalOnProperty("logging.level.beinet.cn.demostudy.MyClient")
MyClient getClient() throws NoSuchAlgorithmException, KeyManagementException {
    // 忽略SSL校验
    SSLContext ctx = SSLContext.getInstance("SSL");
    X509TrustManager tm = new X509TrustManager() {
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) {
        }
        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) {
        }
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    };
    ctx.init(null, new TrustManager[]{tm}, null);
    return new MyClient(ctx.getSocketFactory(), (hostname, sslSession) -> true);
}

package beinet.cn.demostudy;
import feign.Client;
import feign.Request;
import feign.Response;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StreamUtils;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLSocketFactory;
import java.io.*;
import java.util.Collection;
import java.util.Map;
@Slf4j
public class MyClient extends Client.Default {
    public MyClient(SSLSocketFactory socketFactory, HostnameVerifier hostnameVerifier) {
        super(socketFactory, hostnameVerifier);
    }
    @Override
    public Response execute(Request request, Request.Options options) throws IOException {
        StringBuilder sb = new StringBuilder("[log started]\r\n");
        sb.append(request.httpMethod()).append(" ").append(request.url()).append("\r\n");
        CombineHeaders(sb, request.headers()); // 请求Header
        CombineBody(sb, request.body());
        long costTime = -1;
        Exception exception = null;
        BufferingFeignClientResponse response = null;
        long begin = System.currentTimeMillis();
        try {
            response = new BufferingFeignClientResponse(super.execute(request, options));
            costTime = (System.currentTimeMillis() - begin);
        } catch (Exception exp) {
            costTime = (System.currentTimeMillis() - begin);
            exception = exp;
            throw exp;
        } finally {
            sb.append("\r\nResponse cost time(ms)： ").append(String.valueOf(costTime));
            if (response != null)
                sb.append("  status: ").append(response.status());
            sb.append("\r\n");
            if (response != null) {
                CombineHeaders(sb, response.headers()); // 响应Header
                sb.append("Body:\r\n").append(response.body()).append("\r\n");
            }
            if (exception != null) {
                sb.append("Exception:\r\n  ").append(exception.getMessage()).append("\r\n");
            }
            sb.append("\r\n[log ended]");
            log.debug(sb.toString());
        }
        Response ret = response.getResponse().toBuilder()
                .body(response.getBody(),
                        response.getResponse().body().length()).build();
        response.close();
        return ret;
    }
    private static void CombineHeaders(StringBuilder sb, Map<String, Collection<String>> headers) {
        if (headers != null && !headers.isEmpty()) {
            sb.append("Headers:\r\n");
            for (Map.Entry<String, Collection<String>> ob : headers.entrySet()) {
                for (String val : ob.getValue()) {
                    sb.append("  ").append(ob.geTKEy()).append(": ").append(val).append("\r\n");
                }
            }
        }
    }
    private static void CombineBody(StringBuilder sb, byte[] body) {
        if (body == null || body.length <= 0)
            return;
        sb.append("Body:\r\n").append(new String(body)).append("\r\n");
    }
    static final class BufferingFeignClientResponse implements Closeable {
        private Response response;
        private byte[] body;
        private BufferingFeignClientResponse(Response response) {
            this.response = response;
        }
        private Response getResponse() {
            return this.response;
        }
        private int status() {
            return this.response.status();
        }
        private Map<String, Collection<String>> headers() {
            return this.response.headers();
        }
        private String body() throws IOException {
            StringBuilder sb = new StringBuilder();
            try (InputStreamReader reader = new InputStreamReader(getBody())) {
                char[] tmp = new char[1024];
                int len;
                while ((len = reader.read(tmp, 0, tmp.length)) != -1) {
                    sb.append(new String(tmp, 0, len));
                }
            }
            return sb.toString();
        }
        private InputStream getBody() throws IOException {
            if (this.body == null) {
                this.body = StreamUtils.copyToByteArray(this.response.body().asInputStream());
            }
            return new ByteArrayInputStream(this.body);
        }
        @Override
        public void close() {
            this.response.close();
        }
    }
}

package com.example.demo.feign;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
@Aspect
@Component
@Slf4j
public class FeignAspect {
    // 这个也行 @Pointcut("@annotation(org.springframework.web.bind.annotation.PostMapping)")
    // 参考 https://GitHub.com/spring-cloud/spring-cloud-openfeign/issues/322
    @Pointcut("@within(org.springframework.cloud.openfeign.FeignClient)")
    public void feignClientPointcut() {
    }
    @Around("feignClientPointcut()")
    public Object feignAround(ProceedingJoinPoint joinPoint) throws Throwable {
        return logAround(joinPoint);
    }
    private static ObjectMapper mapper = new ObjectMapper();
    private Object logAround(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();
        Object result = null;
        Exception exception = null;
        try {
            result = point.proceed();
        } catch (Exception exp) {
            exception = exp;
        }
        long time = System.currentTimeMillis() - beginTime;
        saveLog(point, result, exception, time);
        if (exception != null) {
            throw exception;
        }
        return result;
    }
    private static void saveLog(ProceedingJoinPoint joinPoint, Object result, Exception exception, long time) {
        Dto dto = new Dto();
        dto.setCostTime(time);
        try {
            if (exception != null) {
                dto.setExp(exception.toString());
            }
            if (result != null) {
                dto.setResult(serial(result));
            }
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            //请求的 类名、方法名
            String className = joinPoint.getTarget().getClass().getName();
            String signName = signature.getDeclaringTypeName();
            if (!signName.equalsIgnoreCase(className))
                signName += "|" + className;
            dto.setClas(signName);
            String methodName = signature.getName();
            dto.setMethod(methodName);
            //请求的参数
            Object[] args = joinPoint.getArgs();
            if (args != null && args.length > 0) {
                dto.setPara(serial(args));
            }
        } catch (Exception e) {
            dto.setExp(e.toString());
        }
        if (exception != null) {
            log.warn(dto.toString());
        } else {
            log.info(dto.toString());
        }
    }
    private static String serial(Object obj) {
        try {
            return mapper.writeValueAsString(obj);
        } catch (Exception ex) {
            return obj.toString();
        }
    }
    @Data
    private static class Dto {
        
        private String clas;
        
        private String method;
        
        private String para;
        
        private String result;
        
        private long costTime;
        
        private String remark;
        
        private String exp;
    }
}