SpringCloud 自定义端云互联路由配置

compileOnly 'org.springframework.boot:spring-boot-autoconfigure:2.1.12.RELEASE'
compileOnly 'org.springframework:spring-context:5.1.13.RELEASE'
compileOnly 'org.springframework.cloud:spring-cloud-starter-openfeign:2.2.1.RELEASE'
compileOnly 'org.springframework.cloud:spring-cloud-starter-netflix-ribbon:2.2.1.RELEASE'
compile group: 'org.projectlombok', name: 'lombok', version: '1.18.10'
annotationProcessor 'org.projectlombok:lombok:1.18.8'

@Slf4j
@AllArgsConstructor
@NoArgsConstructor
public class DevRibbonRule extends AbstractLoadBalancerRule {


    /**
     * 本地IP集合,可以只写ip前缀,例如:112.95
     */
    private List<String> localIpList;


    /**
     * Randomly choose from all living servers
     */
    @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers();
            List<Server> allList = lb.getAllServers();

            int serverCount = allList.size();
            if (serverCount == 0) {
                /*
                 * No servers. End regardless of pass, because subsequent passes
                 * only get more restrictive.
                 */
                return null;
            }

            Optional<Server> localOptional = localRandomOne(upList);
            if (localOptional.isPresent()) {
                server = localOptional.get();
            } else {
                Optional<Server> randomOptional = nonLocalRandomOne(upList);
                if (randomOptional.isPresent()) {
                    server = randomOptional.get();
                }
            }


            if (server == null) {
                /*
                 * The only time this should happen is if the server list were
                 * somehow trimmed. This is a transient condition. Retry after
                 * yielding.
                 */
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }

            // Shouldn't actually happen.. but must be transient or a bug.
            server = null;
            Thread.yield();
        }

        return server;

    }


    /**
     * 从所有实例中随机取一个开发者本机的实例
     */
    private Optional<Server> localRandomOne(List<Server> allValidServers) {
        List<Server> localServerList = getLocalServer(allValidServers);
        if (CollectionUtils.isEmpty(localServerList)) {
            return Optional.empty();
        }
        int randomIndex = chooseRandomInt(localServerList.size());
        return Optional.of(localServerList.get(randomIndex));
    }


    /**
     * 从所有实例中排除掉开发者本机的实例后随机取一个
     */
    private Optional<Server> nonLocalRandomOne(List<Server> allValidServers) {
        List<Server> localServerList = getLocalServer(allValidServers);
        List<Server> nonLocalServerList = allValidServers.stream().filter(item -> !localServerList.contains(item)).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(nonLocalServerList)) {
            return Optional.empty();
        }
        int randomIndex = chooseRandomInt(nonLocalServerList.size());
        return Optional.of(nonLocalServerList.get(randomIndex));
    }


    private List<Server> getLocalServer(List<Server> allServers) {
        return allServers.stream().filter(serverItem -> {
            String hostItem = serverItem.getHost();
            for (String localIpItem : localIpList) {
                if (hostItem.contains(localIpItem)) {
                    return true;
                }
            }
            return false;
        }).collect(Collectors.toList());
    }


    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }


    @Override
    public Server choose(Object key) {
        Server currentServer = choose(getLoadBalancer(), key);
        log.info("本次调用的实例 ：Server : {}, key = {}, host : {}, port = {}", currentServer.toString(), key, currentServer.getHost(), currentServer.getPort());
        return currentServer;
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub

    }
}

@Configuration
@Slf4j
public class FeignConfiguration {

    @Bean
    Logger.Level feignLoggerLevel() {
        //这里记录所有，根据实际情况选择合适的日志level
        return Logger.Level.FULL;
    }


    @ConditionalOnProperty(value = "dev.ribbon.rule.enable")
    @Bean
    public IRule ribbonRule(@Value("#{'${dev.ribbon.rule.host.list:}'.split(',')}") List<String> localIpList) {
        log.info("localIpList = {}", localIpList);
        return new DevRibbonRule(localIpList);
    }
}

@Configuration(proxyBeanMethods = false)
@Import(FeignConfiguration.class)
public class CommonFeignAutoConfiguration {
}

# 需放在 META-INF 文件夹中, 文件名为 : spring.factories
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.zuopeng.common.feign.CommonFeignAutoConfiguration