package com.netflix.loadbalancer;

import java.util.List;

/**
 *  定义软件负载均衡的操作接口，一个典型的负载负载均衡实现需要一组服务器进行。通常一个方法来标记特定的服务器不循环
 * 一个调用将现有的服务器列表中选择一个服务器来进行提供服务。
 * 
 * @author stonse
 * 
 */
public interface ILoadBalancer {

	/**
	 * 向服务器初始列表中增加新的服务提供者地址列表（host:port）
	 * @param 添加新服务提供者
	 */
	public void addServers(List<Server> newServers);
	
	/**
	 * 从负载均衡器中选择一个服务器
	 * 
	 * @param 负载均衡器将可用于确定返回那个服务器的对象，如为空则
	 *         负载均衡器将不会使用此参数
	 * @return 选择服务器
	 */
	public Server chooseServer(Object key);
	
	/**
	 * 由负载均衡器的客户端掉应来通知某个服务器暂停服务，否则 ILoadBalancer 依然认为他可以提供服务
	 * 直到下一次检测的周提
	 * 
	 * @param 标记已经暂停服务的服务器
	 */
	public void markServerDown(Server server);
	
	/**
	 * @deprecated    getServerList 在 2016-01-20 就被弃用，取而代之的则是 getReachableServers 以及 getAllServer API。
	 *
	 * @param 如果为 true 则只应用返回可用的服务器
	 */
	@Deprecated
	public List<Server> getServerList(boolean availableOnly);

	/**
	 * @return 返回获取到可用的服务提供者列表
     */
    public List<Server> getReachableServers();

    /**
     * @return 获取所有看到服务提供者列表
     */
	public List<Server> getAllServers();
}

package com.netflix.loadbalancer;

import java.util.List;

/**
 * AbstractLoadBalancer contains features required for most loadbalancing
 * implementations.
 * 
 * An anatomy of a typical LoadBalancer consists of 1. A List of Servers (nodes)
 * that are potentially bucketed based on a specific criteria. 2. A Class that
 * defines and implements a LoadBalacing Strategy via <code>IRule</code> 3. A
 * Class that defines and implements a mechanism to determine the
 * suitability/availability of the nodes/servers in the List.
 * 
 * 
 * @author stonse
 * 
 */
public abstract class AbstractLoadBalancer implements ILoadBalancer {
    
    public enum ServerGroup{
        ALL,
        STATUS_UP,
        STATUS_NOT_UP        
    }
        
    /**
     * delegate to {@link #chooseServer(Object)} with parameter null.
     */
    public Server chooseServer() {
    	return chooseServer(null);
    }

    
    /**
     * List of servers that this Loadbalancer knows about
     * 
     * @param serverGroup Servers grouped by status, e.g., {@link ServerGroup#STATUS_UP}
     */
    public abstract List<Server> getServerList(ServerGroup serverGroup);
    
    /**
     * Obtain LoadBalancer related Statistics
     */
    public abstract LoadBalancerStats getLoadBalancerStats();    
}

@Monitor(name = PREFIX + "AllServerList", type = DataSourceType.INFORMATIONAL)
protected volatile List<Server> allServerList = Collections
        .synchronizedList(new ArrayList<Server>());
@Monitor(name = PREFIX + "UpServerList", type = DataSourceType.INFORMATIONAL)
protected volatile List<Server> upServerList = Collections
        .synchronizedList(new ArrayList<Server>());

package com.netflix.loadbalancer;

import com.netflix.client.config.IClientConfig;

/**
 * Default simple implementation that marks the liveness of a Server
 * 
 * @author stonse
 * 
 */
public class DummyPing extends AbstractLoadBalancerPing {

    public DummyPing() {
    }

    public boolean isAlive(Server server) {
        return true;
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

package com.netflix.loadbalancer;

/**
 * No Op Ping
 * @author stonse
 *
 */
public class NoOpPing implements IPing {

    @Override
    public boolean isAlive(Server server) {
        return true;
    }

}

package com.netflix.loadbalancer;

/**
 * A utility Ping Implementation that returns whatever its been set to return
 * (alive or dead)
 * @author stonse
 *
 */
public class PingConstant implements IPing {
		boolean constant = true;

		public void setConstant(String constantStr) {
				constant = (constantStr != null) && (constantStr.toLowerCase().equals("true"));
		}

		public void setConstant(boolean constant) {
				this.constant = constant;
		}

		public boolean getConstant() {
				return constant;
		}

		public boolean isAlive(Server server) {
				return constant;
		}
}

public Server choose(ILoadBalancer lb, Object key) {
    if (lb == null) {
        log.warn("no load balancer");
        return null;
    }

private int incrementAndGetModulo(int modulo) {
    for (;;) {
        int current = nextServerCyclicCounter.get();
        int next = (current + 1) % modulo;
        if (nextServerCyclicCounter.compareAndSet(current, next))
            return next;
    }
}

    Server server = null;
    int count = 0;
    while (server == null && count++ < 10) {
        List<Server> reachableServers = lb.getReachableServers();
        List<Server> allServers = lb.getAllServers();
        int upCount = reachableServers.size();
        int serverCount = allServers.size();

        if ((upCount == 0) || (serverCount == 0)) {
            log.warn("No up servers available from load balancer: " + lb);
            return null;
        }

        int nextServerIndex = incrementAndGetModulo(serverCount);
        server = allServers.get(nextServerIndex);

        if (server == null) {
            /* Transient. */
            Thread.yield();
            continue;
        }

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

        // Next.
        server = null;
    }

    if (count >= 10) {
        log.warn("No available alive servers after 10 tries from load balancer: "
                + lb);
    }
    return server;
}

if (((answer == null) || (!answer.isAlive()))
		&& (System.currentTimeMillis() < deadline)) {
	/* pause and retry hoping it's transient */
	Thread.yield();
} else {
	break;
}

public Server choose(ILoadBalancer lb, Object key) {
    if (lb == null) {
        return null;
    }
    Server server = null;

    while (server == null) {
        // get hold of the current reference in case it is changed from the other thread
        List<Double> currentWeights = accumulatedWeights;
        if (Thread.interrupted()) {
            return null;
        }
        List<Server> allList = lb.getAllServers();

        int serverCount = allList.size();

        if (serverCount == 0) {
            return null;
        }

        int serverIndex = 0;

        // last one in the list is the sum of all weights
        double maxTotalWeight = currentWeights.size() == 0 ? 0 : currentWeights.get(currentWeights.size() - 1); 
        // No server has been hit yet and total weight is not initialized
        // fallback to use round robin
        if (maxTotalWeight < 0.001d) {
            server =  super.choose(getLoadBalancer(), key);
            if(server == null) {
                return server;
            }
        } else {
            // generate a random weight between 0 (inclusive) to maxTotalWeight (exclusive)
            double randomWeight = random.nextDouble() * maxTotalWeight;
            // pick the server index based on the randomIndex
            int n = 0;
            for (Double d : currentWeights) {
                if (d >= randomWeight) {
                    serverIndex = n;
                    break;
                } else {
                    n++;
                }
            }

            server = allList.get(serverIndex);
        }

        if (server == null) {
            /* Transient. */
            Thread.yield();
            continue;
        }

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

        // Next.
        server = null;
    }
    return server;
}

        try {
            logger.info("Weight adjusting job started");
            AbstractLoadBalancer nlb = (AbstractLoadBalancer) lb;
            LoadBalancerStats stats = nlb.getLoadBalancerStats();
            if (stats == null) {
                // no statistics, nothing to do
                return;
            }
            double totalResponseTime = 0;
            // find maximal 95% response time
            for (Server server : nlb.getAllServers()) {
                // this will automatically load the stats if not in cache
                ServerStats ss = stats.getSingleServerStat(server);
                totalResponseTime += ss.getResponseTimeAvg();
            }
            // weight for each server is (sum of responseTime of all servers - responseTime)
            // so that the longer the response time, the less the weight and the less likely to be chosen
            Double weightSoFar = 0.0;
            
            // create new list and hot swap the reference
            List<Double> finalWeights = new ArrayList<Double>();
            for (Server server : nlb.getAllServers()) {
                ServerStats ss = stats.getSingleServerStat(server);
                double weight = totalResponseTime - ss.getResponseTimeAvg();
                weightSoFar += weight;
                finalWeights.add(weightSoFar);   
            }
            setWeights(finalWeights);
        } catch (Exception e) {
            logger.error("Error calculating server weights", e);
        } finally {
            serverWeightAssignmentInProgress.set(false);
        }

    }
}

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;
            }

            int index = rand.nextInt(serverCount);
            server = upList.get(index);

            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;

    }

public class ClientConfigEnabledRoundRobinRule extends AbstractLoadBalancerRule {

    RoundRobinRule roundRobinRule = new RoundRobinRule();

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        roundRobinRule = new RoundRobinRule();
    }

    @Override
    public void setLoadBalancer(ILoadBalancer lb) {
    	super.setLoadBalancer(lb);
    	roundRobinRule.setLoadBalancer(lb);
    }
    
    @Override
    public Server choose(Object key) {
        if (roundRobinRule != null) {
            return roundRobinRule.choose(key);
        } else {
            throw new IllegalArgumentException(
                    "This class has not been initialized with the RoundRobinRule class");
        }
    }

}

public Server choose(Object key) {
    if (loadBalancerStats == null) {
        return super.choose(key);
    }
    List<Server> serverList = getLoadBalancer().getAllServers();
    int minimalConcurrentConnections = Integer.MAX_VALUE;
    long currentTime = System.currentTimeMillis();
    Server chosen = null;
    for (Server server: serverList) {
        ServerStats serverStats = loadBalancerStats.getSingleServerStat(server);
        if (!serverStats.isCircuitBreakerTripped(currentTime)) {
            int concurrentConnections = serverStats.getActiveRequestsCount(currentTime);
            if (concurrentConnections < minimalConcurrentConnections) {
                minimalConcurrentConnections = concurrentConnections;
                chosen = server;
            }
        }
    }
    if (chosen == null) {
        return super.choose(key);
    } else {
        return chosen;
    }
}

public Optional<Server> chooseRandomlyAfterFiltering(List<Server> servers) {
    List<Server> eligible = getEligibleServers(servers);
    if (eligible.size() == 0) {
        return Optional.absent();
    }
    return Optional.of(eligible.get(random.nextInt(eligible.size())));
}

/**
 * Choose a server in a round robin fashion after the predicate filters a list of servers. Load balancer key 
 * is presumed to be null.
 */
public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers) {
    List<Server> eligible = getEligibleServers(servers);
    if (eligible.size() == 0) {
        return Optional.absent();
    }
    return Optional.of(eligible.get(nextIndex.getAndIncrement() % eligible.size()));
}

/**
 * Choose a random server after the predicate filters list of servers given list of servers and
 * load balancer key. 
 *  
 */
public Optional<Server> chooseRandomlyAfterFiltering(List<Server> servers, Object loadBalancerKey) {
    List<Server> eligible = getEligibleServers(servers, loadBalancerKey);
    if (eligible.size() == 0) {
        return Optional.absent();
    }
    return Optional.of(eligible.get(random.nextInt(eligible.size())));
}

/**
 * Choose a server in a round robin fashion after the predicate filters a given list of servers and load balancer key. 
 */
public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers, Object loadBalancerKey) {
    List<Server> eligible = getEligibleServers(servers, loadBalancerKey);
    if (eligible.size() == 0) {
        return Optional.absent();
    }
    return Optional.of(eligible.get(nextIndex.getAndIncrement() % eligible.size()));
}
    public static AbstractServerPredicate ofKeyPredicate(final Predicate<PredicateKey> p) {
    return new AbstractServerPredicate() {
        @Override
        @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "NP")
        public boolean apply(PredicateKey input) {
            return p.apply(input);
        }            
    };        
}

/**
 * Create an instance from a predicate.
 */
public static AbstractServerPredicate ofServerPredicate(final Predicate<Server> p) {
    return new AbstractServerPredicate() {
        @Override
        @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "NP")
        public boolean apply(PredicateKey input) {
            return p.apply(input.getServer());
        }            
    };        
}

static String randomChooseZone(Map<String, ZoneSnapshot> snapshot,
        Set<String> chooseFrom) {
    if (chooseFrom == null || chooseFrom.size() == 0) {
        return null;
    }
    String selectedZone = chooseFrom.iterator().next();
    if (chooseFrom.size() == 1) {
        return selectedZone;
    }
    int totalServerCount = 0;
    for (String zone : chooseFrom) {
        totalServerCount += snapshot.get(zone).getInstanceCount();
    }
    int index = random.nextInt(totalServerCount) + 1;
    int sum = 0;
    for (String zone : chooseFrom) {
        sum += snapshot.get(zone).getInstanceCount();
        if (index <= sum) {
            selectedZone = zone;
            break;
        }
    }
    return selectedZone;
}

if (availableZones.size() == 1) {
    return availableZones;
}

if (((double) zoneSnapshot.getCircuitTrippedCount())
                        / instanceCount >= triggeringBlackoutPercentage
                        || loadPerServer < 0) {
                    availableZones.remove(zone);
                    limitedZoneAvailability = true;
                }

if (Math.abs(loadPerServer - maxLoadPerServer) < 0.000001d) {
    // they are the same considering double calculation
    // round error
    worstZones.add(zone);
} else if (loadPerServer > maxLoadPerServer) {
    maxLoadPerServer = loadPerServer;
    worstZones.clear();
    worstZones.add(zone);
}

    String zoneToAvoid = randomChooseZone(snapshot, worstZones);
    if (zoneToAvoid != null) {
        availableZones.remove(zoneToAvoid);
    }
    return availableZones;

}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;

import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**
 * 启动类，通过 @LoadBalanced 来开启客户端的负载均衡
 * @author kunlun
 * @date 2021/06/22
 */
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }


    /**
     *  实例化 RestTemplate
     * @return RestTemplate
     */
    @LoadBalanced
    @Bean
    RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置类，通过 @RibbonClient 注解来配置服务名以及实例化
 * @author kunlun
 * @date 2021/06/29
 */
@Configuration
@RibbonClient(name = "service-provider", configuration = RibbonClientConfiguration.class)
public class RibbonConfig {

    /**
     * 实例化 Ribbon 的随机策略（RandomRule）
     * @return RandomRule
     */
    @Bean
    public IRule irule() {
        return new RandomRule();
    }
}

package com.example.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.text.SimpleDateFormat;
import java.util.Date;

@RestController
public class TestController {

    @Autowired
    private LoadBalancerClient loadBalancerClient;

    Date date = new Date();

    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd hh:mm:ss");

    @GetMapping("/hey")
    public String hey() {
        ServiceInstance serviceInstance = loadBalancerClient.choose("service-provider");
        String callService = "Host: " + serviceInstance.getHost() + " Port: " + serviceInstance.getPort() + " Date:" + simpleDateFormat.format(date);
        return callService;
    }

}

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

/**
 * 启动类，通过 @EnableDiscoveryClient 实现服务中心，以及 @EnableFeignClients 来支持 Feign
 * @author kunlun
 * @date 2021/7/1
 */
@EnableDiscoveryClient
@EnableFeignClients
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

package com.example.demo.config;

import feign.Contract;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 自定义 Feign 配置
 * @author kunlun
 * @date 2021/7/1
 */
@Configuration
public class FeignConfig {

    /**
     * 将 Spring cloud MVC Netfilx Controller 改为 feign.Contract.Defaull
     * 之后契约将默认改为 Feign 原生契约，之后可以使用默认注解
     * @return feign.Contract.Defaull
     */
    @Bean
    public Contract contract() {
        return new Contract.Default();
    }
}

package com.example.demo;

import feign.RequestLine;
import org.springframework.cloud.openfeign.FeignClient;
import com.example.demo.config.FeignConfig;

/**
 * FeignClient 接口
 * @author kunlun
 * @date 2021/7/1
 */
@FeignClient(contextId = "feignClient", name = "service-provider", configuration = FeignConfig.class)
public interface FeignClientInterface {

    /**
     * 通过 @RequestLine 将 Spring MVC 注解修改为原生的 @RequestLine
     * @return @RequestLine
     */
    @RequestLine("GET /hey")
    public String hey();

}

package com.example.demo.controller;

import com.example.demo.FeignClientInterface;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 调用接口以此来提供服务
 * @author kunlun
 * @date 2021/7/1
 */
@RestController
public class FeignController {

    @Autowired
    FeignClientInterface feignClientInterface;

    @GetMapping("/hey")
    public String index() {
        return feignClientInterface.hey();
    }
}

package com.example.demo.config;

import feign.Contract;
import feign.Logger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 自定义 Feign 配置
 * @author kunlun
 * @date 2021/7/1
 */
@Configuration
public class FeignConfig {

    /**
     * 将 Spring cloud MVC Controller 改为 feign.Contract.Defaull
     * 之后契约将默认改为 Feign 原生契约，之后可以使用默认注解
     * @return feign.Contract.Defaull
     */
    @Bean
    public Contract contract() {
        return new Contract.Default();
    }

    /**
     * 日志管理器记录等级为 FULL
     * @return Logger.Level.Full
     */
    @Bean
    Logger.Level level() {
        return Logger.Level.FULL;
    }
}