自定义负载均衡策略

package org.example.myrule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 自定义负载均衡策略: 每个服务访问5次.
 */
public class CustomizeRule extends AbstractLoadBalancerRule {

    private int limit = 2;

    // map的 key 是服务名. Server是当前服务名下访问的服务.
    private Map<String, CurrentServerInfo> serverMap = new ConcurrentHashMap<>();

    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) { }

    @Override
    public Server choose(Object key) {
        ILoadBalancer balancer = getLoadBalancer();
        // 获取到当前调用的服务名(ms-provider)下的所有的服务
        List<Server> serverList = balancer.getAllServers();

        // 没有服务可用
        if(null == serverList || serverList.size() == 0) {
            return null;
        }

        // 表示就一个服务
        if(serverList.size() == 1) {
            return serverList.get(0);
        }

        Server firstServer = serverList.get(0);

        // DEFAULT_GROUP@@ms-provider  通过 firstServer.getMetaInfo().getAppName()
        String serviceName = firstServer.getMetaInfo().getAppName().split("@@")[1];

        synchronized (serviceName.intern()) {
            // 获取当前这个服务名下的服务的调用信息
            CurrentServerInfo serverInfo = serverMap.get(serviceName);
            if (null == serverInfo) { // 表示针对该服务首次调用
                serverInfo = new CurrentServerInfo(firstServer.getId(), firstServer, 1);
                serverMap.put(serviceName, serverInfo);
                return firstServer;
            } else {  // 不是首次调用.
                Integer num = serverInfo.getNum(); //获取当前服务调用的次数
                if (num >= limit) {  //超过调用次数限制
                    for (int i = 0; i < serverList.size(); i++) {
                        Server server = serverList.get(i);
                        if (server.getId().equals(serverInfo.getId())) {
                            if (i != serverList.size() - 1) {  // 表示不是最后一个服务, 取下一个
                                Server nextServer = serverList.get(i + 1);
                                // 取下一个服务, 那么下一个服务就是首次调用
                                CurrentServerInfo nextServerInfo = new CurrentServerInfo(nextServer.getId(), nextServer, 1);
                                serverMap.put(serviceName, nextServerInfo);
                                return nextServer; //取下一个
                            } else { // 是最后一个服务, 取第0个
                                Server zeroServer = serverList.get(0);
                                CurrentServerInfo zeroServerInfo = new CurrentServerInfo(zeroServer.getId(), zeroServer, 1);
                                serverMap.put(serviceName, zeroServerInfo);
                                return zeroServer; //取下一个
                            }
                        }
                    }
                } else { // 如果没有超过
                    serverInfo.setNum(num + 1);
                    return serverInfo.getServer();
                }
            }
        }
        return null;
    }
}

import com.netflix.loadbalancer.Server;


public class CurrentServerInfo {
    private String id;
    private Server server;
    private Integer num;

    public CurrentServerInfo() {
    }

    public CurrentServerInfo(String id, Server server, Integer num) {
        this.id = id;
        this.server = server;
        this.num = num;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Server getServer() {
        return server;
    }

    public void setServer(Server server) {
        this.server = server;
    }

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }
}