2022-11-30 23:44:17.389  INFO 22088 --- [erListUpdater-0] c.netflix.config.ChainedDynamicProperty  : Flipping property: cloud-guli-product.ribbon.ActiveConnectionsLimit to use NEXT property: niws.loadbalancer.availabilityFilteringRule.activeConnectionsLimit = 2147483647
2022-11-30 23:44:21.644 ERROR 22088 --- [ctor-http-nio-5] a.w.r.e.AbstractErrorWebExceptionHandler : [453e5166]  500 Server Error for HTTP GET "/admin/product/attr/base/list/0?t=1669812012957&page=1&limit=10&key="

io.netty.channel.ConnectTimeoutException: connection timed out: /192.168.39.86:5000
	at io.netty.channel.nio.AbstractNioChannel$AbstractNioUnsafe$1.run(AbstractNioChannel.java:261) ~[netty-transport-4.1.43.Final.jar:4.1.43.Final]
	Suppressed: reactor.core.publisher.FluxOnAssembly$OnAssemblyException: 
Error has been observed at the following site(s):
	|_ checkpoint ⇢ org.springframework.web.cors.reactive.CorsWebFilter [DefaultWebFilterChain]
	|_ checkpoint ⇢ org.springframework.cloud.gateway.filter.WeightCalculatorWebFilter [DefaultWebFilterChain]
	|_ checkpoint ⇢ org.springframework.boot.actuate.metrics.web.reactive.server.MetricsWebFilter [DefaultWebFilterChain]
	|_ checkpoint ⇢ HTTP GET "/admin/product/attr/base/list/0?t=1669812012957&page=1&limit=10&key=" [ExceptionHandlingWebHandler]

2022-10-28 09:31:36.477  INFO 10736 --- [192.168.112.230] o.s.a.r.c.CachingConnectionFactory       : Attempting to connect to: [localhost:5672]
2022-10-28 09:31:40.585  WARN 10736 --- [192.168.112.230] o.s.b.a.amqp.RabbitHealthIndicator       : Rabbit health check failed

org.springframework.amqp.AmqpConnectException: java.net.ConnectException: Connection refused: connect

Caused by: java.lang.IllegalStateException: No DataSource set
        at org.springframework.util.Assert.state(Assert.java:76)
        at org.springframework.jdbc.support.JdbcAccessor.obtainDataSource(JdbcAccessor.java:86)
        at org.springframework.jdbc.core.JdbcTemplate.execute(JdbcTemplate.java:376)
        at org.springframework.jdbc.core.JdbcTemplate.query(JdbcTemplate.java:465)
        at org.springframework.jdbc.core.JdbcTemplate.query(JdbcTemplate.java:475)
        at org.springframework.jdbc.core.JdbcTemplate.queryForObject(JdbcTemplate.java:508)
        at org.springframework.jdbc.core.JdbcTemplate.queryForObject(JdbcTemplate.java:515)
        at com.alibaba.nacos.config.server.service.repository.extrnal.ExternalStoragePersistServiceImpl.findConfigMaxId(ExternalStoragePersistServiceImpl.java:674)
        at com.alibaba.nacos.config.server.service.dump.processor.DumpAllProcessor.process(DumpAllProcessor.java:51)
        at com.alibaba.nacos.config.server.service.dump.DumpService.dumpConfigInfo(DumpService.java:282)
        at com.alibaba.nacos.config.server.service.dump.DumpService.dumpOperate(DumpService.java:195)
        ... 65 common frames omitted

@Configuration
public class FeignLogConfiguration {
    @Bean
    public Logger.Level level() {
        return Logger.Level.FULL;
    }
}

    @Bean("restTemplate")
    public RestTemplate restTemplate(){
        RestTemplate restTemplate = new RestTemplate();
        MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
        mappingJackson2HttpMessageConverter.setSupportedMediaTypes(Arrays.asList(
                MediaType.TEXT_HTML,  //配了text/html
                MediaType.TEXT_PLAIN)); //配了 text/plain
        restTemplate.getMessageConverters().add(mappingJackson2HttpMessageConverter);

        return restTemplate;
    }
//类上面记得加@configuration

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class ConsumerMain83 {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerMain83.class, args);
    }
}

@FeignClient(name = "${my.remote-server}")
@Component
public interface FeignTestService {
    @GetMapping("/nacos/payment/test")
    String test();
}

@FeignClient(name = "https://gitee.com/api/v5",url = "https://gitee.com/api/v5")
public interface GiteeFeignService {
    @GetMapping("emails")
    String getAllEmail(@RequestParam("access_token") String access_token);
}

@Configuration
public class MyFeignConfig {
    @Bean
    public RequestInterceptor requestInterceptor() {
        return template -> {
            ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            if (requestAttributes != null) {
                String cookie = requestAttributes.getRequest().getHeader("Cookie");
                template.header("Cookie", cookie);
            }
        };
    }
}

        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            //为异步任务线程设置request
            RequestContextHolder.setRequestAttributes(requestAttributes);
            ...
        });

package com.pika.vm.github.config;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.google.common.base.CaseFormat;
import com.ruoyi.common.core.utils.StringUtils;
import feign.FeignException;
import feign.Response;
import feign.Util;
import feign.codec.Decoder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
import org.springframework.cloud.openfeign.support.SpringDecoder;
import org.springframework.context.annotation.Bean;

import java.io.IOException;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.util.Objects;
import java.util.Set;

import static java.nio.charset.StandardCharsets.UTF_8;

/**
 * Desc:
 *
 * @since 2024/01
 */
@Slf4j
public class GithubFeignConfig {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    static {
        objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
        objectMapper.disable(JsonGenerator.Feature.IGNORE_UNKNOWN);
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        objectMapper.disable(MapperFeature.DEFAULT_VIEW_INCLUSION);
    }

    @Bean
    public Decoder feignClientDecoder(HttpMessageConverters httpMessageConverters) {
        return new FeignClientDecoder(() -> httpMessageConverters);
    }


    public static class FeignClientDecoder extends SpringDecoder {
        public FeignClientDecoder(ObjectFactory<HttpMessageConverters> messageConverters) {
            super(messageConverters);
        }

        @Override
        public Object decode(Response response, Type type) throws IOException, FeignException {
            final Response.Body body = response.body();
            final String bodyClassName = body.getClass().getName();
            //Response.ByteArrayBody feign.Response$InputStreamBody feign.Response$ByteArrayBody
            //因为ByteArrayBody是private 所以不能instance of
            if (Objects.equals(bodyClassName, "feign.Response$ByteArrayBody") || Objects.equals(bodyClassName, "feign.Response$InputStreamBody")) {
                String result;
                if (Objects.equals(bodyClassName, "feign.Response$ByteArrayBody")) {
                    result = body.toString();
                } else {
                    byte[] bodyData = Util.toByteArray(body.asInputStream());
                    result = Util.decodeOrDefault(bodyData, UTF_8, "Binary data");
                }
                final Response.Builder respBuild = Response.builder()
                        .headers(response.headers())
                        .reason(response.reason())
                        .status(response.status())
                        .request(response.request());

                if (StringUtils.isNoneBlank(result) && JSON.isValid(result)) {
                    final Object jsonObject = JSON.parse(result);
                    lowerUnderScore2LowCamelCase(jsonObject);
                    respBuild.body(JSON.toJSONString(jsonObject), Charset.defaultCharset());
                } else {
                    respBuild.body(result, Charset.defaultCharset());
                }
                return super.decode(respBuild.build(), type);
            }
            return super.decode(response, type);
        }
    }

    /**
     * 小写驼峰小写下划线
     */
    public static void lowCameCase2LowerUnderScore(Object json) {
        if (json instanceof JSONArray) {
            JSONArray arr = (JSONArray) json;
            for (Object obj : arr) {
                lowCameCase2LowerUnderScore(obj);
            }
        } else if (json instanceof JSONObject) {
            JSONObject jo = (JSONObject) json;
            Set<String> keys = jo.keySet();
            String[] array = keys.toArray(new String[0]);
            for (String key : array) {
                Object value = jo.get(key);
                final String underLineKey = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, key);
                jo.remove(key);
                jo.put(underLineKey, value);
                lowCameCase2LowerUnderScore(value);
            }
        }
    }

    /**
     * 小写下划线转小写驼峰
     */
    public static void lowerUnderScore2LowCamelCase(Object json) {
        if (json instanceof JSONArray) {
            JSONArray arr = (JSONArray) json;
            for (Object obj : arr) {
                lowerUnderScore2LowCamelCase(obj);
            }
        } else if (json instanceof JSONObject) {
            JSONObject jo = (JSONObject) json;
            Set<String> keys = jo.keySet();
            String[] array = keys.toArray(new String[0]);
            for (String key : array) {
                Object value = jo.get(key);
                final String lowCaseKey = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, key);
                jo.remove(key);
                jo.put(lowCaseKey, value);
                lowerUnderScore2LowCamelCase(value);
            }
        }
    }
}

@FeignClient(name = "gitHubFeignService",url = "https://api.github.com",configuration = GithubFeignConfig.class)
public interface GitHubFeignService {
    @GetMapping("/user/repos")
    List<Repository> get_own_repos(@RequestHeader(value = "Authorization", defaultValue = "") String token,
                                   @RequestHeader(value = "Accept", defaultValue = "application/vnd.github+json") String accept,
                                   @RequestHeader(value = "X-GitHub-Api-Version", defaultValue = "2022-11-28") String version);
}

i.s.c.r.netty.NettyClientChannelManager  : can not get cluster name in registry config 'service.vgroupMapping.seata-order-service-fescar-service-group', please make sure registry config correct

i.s.c.r.netty.NettyClientChannelManager  : will connect to 192.168.231.130:8091
i.s.core.rpc.netty.NettyPoolableFactory  : NettyPool create channel to transactionRole:TMROLE,address:192.168.231.130:8091,msg:< RegisterTMRequest{applicationId='seata-order-service', transactionServiceGroup='seata-order-service-fescar-service-group'} >

no available service found in cluster ‘seata-server’, please make sure registry config correct and keep your seata server running

Failed to get available servers: {}

    private List<String> getAvailServerList(String transactionServiceGroup) throws Exception {
        List<InetSocketAddress> availInetSocketAddressList = RegistryFactory.getInstance()
                .lookup(transactionServiceGroup);
        if (CollectionUtils.isEmpty(availInetSocketAddressList)) {
            return Collections.emptyList();
        }

        return availInetSocketAddressList.stream()
                .map(NetUtil::toStringAddress)
                .collect(Collectors.toList());
    }

@Configuration
public class MyFeignConfig {
    @Bean
    public RequestInterceptor requestInterceptor() {
        return template -> {
            // 解决seata的xid未传递
            String xid = RootContext.getXID();
            template.header(RootContext.KEY_XID, xid);

            ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            if (requestAttributes != null) {
                String cookie = requestAttributes.getRequest().getHeader("Cookie");
                template.header("Cookie", cookie);
            }
        };
    }
}