tl-微服务专题08-Ribbon&Feign源码深入分析

ゝ一纸荒年。 2023-07-04 14:22 8阅读 0赞

**目录**

一、LoadBalancerClient

二、DynamicServerListLoadBalancer

三、RestTemplate是如何和Ribbon结合的

总结

四、Ribbon调用流程总图

五、Ribbon源码总图

六、Feign源码总图

--------------------

# **一、LoadBalancerClient** #

在Riibon中一个非常重要的组件为LoadBalancerClient，它作为负载均衡的一个客户端。它在spring-cloud-commons包下：的LoadBalancerClient是一个接口，它继承ServiceInstanceChooser，它的实现类是RibbonLoadBalancerClient，这三者之间的关系如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70][]

由这篇笔记《springcloud ribbon的负载均衡注解 @LoadBalanced的实现原理（@Qulifier注解的使用）》：  [https://blog.csdn.net/itwxming/article/details/102833584][https_blog.csdn.net_itwxming_article_details_102833584]

我们发现，@LoadBalanced实现负载均衡的原理入口是： **LoadBalancerAutoConfiguration类的代码中，用RestTempllate的拦截器，使用RestTemplateCustomizer对所有标注了@LoadBalanced的RestTemplate Bean添加了一个LoadBalancerInterceptor拦截器，而这个拦截器的作用就是对请求的URI进行转换获取到具体应该请求哪个服务实例ServiceInstance。**

如下图，则客户端 **负载均衡起作用顺序**为：

**RestTempllate >> LoadBalancerInterceptor  >>  LoadBalancerClient**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 1][]

RibbonAutoConfiguration类的部分代码如下：

@Configuration
    @ConditionalOnClass({ IClient.class, RestTemplate.class, AsyncRestTemplate.class, Ribbon.class})
    @RibbonClients
    @AutoConfigureAfter(name = "org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration")//在eureka基础上使用，所以在其之后自动装配。
    @AutoConfigureBefore({LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class})//在负载均衡LoadBalancerAutoConfiguration前配置。
    @EnableConfigurationProperties({RibbonEagerLoadProperties.class, ServerIntrospectorProperties.class})
    public class RibbonAutoConfiguration {
    
    	@Autowired(required = false)
    	private List<RibbonClientSpecification> configurations = new ArrayList<>();
    
    	@Autowired
    	private RibbonEagerLoadProperties ribbonEagerLoadProperties;
    
    	@Bean
    	public HasFeatures ribbonFeature() {
    		return HasFeatures.namedFeature("Ribbon", Ribbon.class);
    	}
    
    	@Bean
    	public SpringClientFactory springClientFactory() {
    		SpringClientFactory factory = new SpringClientFactory();
    		factory.setConfigurations(this.configurations);
    		return factory;
    	}
    
    	@Bean
    	@ConditionalOnMissingBean(LoadBalancerClient.class)//注入实现bean。
    	public LoadBalancerClient loadBalancerClient() {
    		return new RibbonLoadBalancerClient(springClientFactory());
    	}

其中LoadBalancerClient接口，有如下三个方法，其中**excute()为执行请求，reconstructURI()用来重构url**：

import org.springframework.cloud.client.ServiceInstance;
    
    import java.io.IOException;
    import java.net.URI;
    
    /**
     * Represents a client side load balancer
     * @author Spencer Gibb
     */
    public interface LoadBalancerClient extends ServiceInstanceChooser {
    
    	/**
    	 * execute request using a ServiceInstance from the LoadBalancer for the specified
    	 * service
    	 * @param serviceId the service id to look up the LoadBalancer
    	 * @param request allows implementations to execute pre and post actions such as
    	 * incrementing metrics
    	 * @return the result of the LoadBalancerRequest callback on the selected
    	 * ServiceInstance
    	 */
    	<T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;
    
    	/**
    	 * execute request using a ServiceInstance from the LoadBalancer for the specified
    	 * service
    	 * @param serviceId the service id to look up the LoadBalancer
    	 * @param serviceInstance the service to execute the request to
    	 * @param request allows implementations to execute pre and post actions such as
    	 * incrementing metrics
    	 * @return the result of the LoadBalancerRequest callback on the selected
    	 * ServiceInstance
    	 */
    	<T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException;
    
    	/**
    	 * Create a proper URI with a real host and port for systems to utilize.
    	 * Some systems use a URI with the logical serivce name as the host,
    	 * such as http://myservice/path/to/service.  This will replace the
    	 * service name with the host:port from the ServiceInstance.
    	 * @param instance
    	 * @param original a URI with the host as a logical service name
    	 * @return a reconstructed URI
    	 */
    	URI reconstructURI(ServiceInstance instance, URI original);
    }

ServiceInstanceChooser接口，主要有一个方法，用来根据serviceId来获取ServiceInstance，代码如下:

package org.springframework.cloud.client.loadbalancer;
    
    import org.springframework.cloud.client.ServiceInstance;
    
    /**
     * Implemented by classes which use a load balancer to choose a server to
     * send a request to.
     *
     * @author Ryan Baxter
     */
    public interface ServiceInstanceChooser {
    
        /**
         * Choose a ServiceInstance from the LoadBalancer for the specified service
         * @param serviceId the service id to look up the LoadBalancer
         * @return a ServiceInstance that matches the serviceId
         */
        ServiceInstance choose(String serviceId);
    }

LoadBalancerClient的实现类为RibbonLoadBalancerClient，且只有这一个，这个类是非常重要的一个类，最终的负载均衡的请求处理，由它来执行。它的源码如下：

package org.springframework.cloud.netflix.ribbon;
    
    import java.io.IOException;
    import java.net.URI;
    import java.util.Collections;
    import java.util.Map;
    
    import com.netflix.client.config.IClientConfig;
    import com.netflix.loadbalancer.ILoadBalancer;
    import com.netflix.loadbalancer.Server;
    
    import org.springframework.cloud.client.DefaultServiceInstance;
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
    import org.springframework.cloud.client.loadbalancer.LoadBalancerRequest;
    import org.springframework.util.Assert;
    import org.springframework.util.ReflectionUtils;
    
    import static org.springframework.cloud.netflix.ribbon.RibbonUtils.updateToSecureConnectionIfNeeded;
    
    /**
     * @author Spencer Gibb
     * @author Dave Syer
     * @author Ryan Baxter
     * @author Tim Ysewyn
     */
    public class RibbonLoadBalancerClient implements LoadBalancerClient {
    
    	private SpringClientFactory clientFactory;
    
    	public RibbonLoadBalancerClient(SpringClientFactory clientFactory) {
    		this.clientFactory = clientFactory;
    	}
    
    	@Override
    	public URI reconstructURI(ServiceInstance instance, URI original) {
    		Assert.notNull(instance, "instance can not be null");
    		String serviceId = instance.getServiceId();
    		RibbonLoadBalancerContext context = this.clientFactory
    				.getLoadBalancerContext(serviceId);
    
    		URI uri;
    		Server server;
    		if (instance instanceof RibbonServer) {
    			RibbonServer ribbonServer = (RibbonServer) instance;
    			server = ribbonServer.getServer();
    			uri = updateToSecureConnectionIfNeeded(original, ribbonServer);
    		} else {
    			server = new Server(instance.getScheme(), instance.getHost(), instance.getPort());
    			IClientConfig clientConfig = clientFactory.getClientConfig(serviceId);
    			ServerIntrospector serverIntrospector = serverIntrospector(serviceId);
    			uri = updateToSecureConnectionIfNeeded(original, clientConfig,
    					serverIntrospector, server);
    		}
    		return context.reconstructURIWithServer(server, uri);
    	}
    
    	@Override
    	public ServiceInstance choose(String serviceId) {
    		Server server = getServer(serviceId);
    		if (server == null) {
    			return null;
    		}
    		return new RibbonServer(serviceId, server, isSecure(server, serviceId),
    				serverIntrospector(serviceId).getMetadata(server));
    	}
    
    	@Override
    	public <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException {
    		ILoadBalancer loadBalancer = getLoadBalancer(serviceId);
    		Server server = getServer(loadBalancer);
    		if (server == null) {
    			throw new IllegalStateException("No instances available for " + serviceId);
    		}
    		RibbonServer ribbonServer = new RibbonServer(serviceId, server, isSecure(server,
    				serviceId), serverIntrospector(serviceId).getMetadata(server));
    
    		return execute(serviceId, ribbonServer, request);
    	}
    
    	@Override
    	public <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException {
    		Server server = null;
    		if(serviceInstance instanceof RibbonServer) {
    			server = ((RibbonServer)serviceInstance).getServer();
    		}
    		if (server == null) {
    			throw new IllegalStateException("No instances available for " + serviceId);
    		}
    
    		RibbonLoadBalancerContext context = this.clientFactory
    				.getLoadBalancerContext(serviceId);
    		RibbonStatsRecorder statsRecorder = new RibbonStatsRecorder(context, server);
    
    		try {
    			T returnVal = request.apply(serviceInstance);
    			statsRecorder.recordStats(returnVal);
    			return returnVal;
    		}
    		// catch IOException and rethrow so RestTemplate behaves correctly
    		catch (IOException ex) {
    			statsRecorder.recordStats(ex);
    			throw ex;
    		}
    		catch (Exception ex) {
    			statsRecorder.recordStats(ex);
    			ReflectionUtils.rethrowRuntimeException(ex);
    		}
    		return null;
    	}
    
    	private ServerIntrospector serverIntrospector(String serviceId) {
    		ServerIntrospector serverIntrospector = this.clientFactory.getInstance(serviceId,
    				ServerIntrospector.class);
    		if (serverIntrospector == null) {
    			serverIntrospector = new DefaultServerIntrospector();
    		}
    		return serverIntrospector;
    	}
    
    	private boolean isSecure(Server server, String serviceId) {
    		IClientConfig config = this.clientFactory.getClientConfig(serviceId);
    		ServerIntrospector serverIntrospector = serverIntrospector(serviceId);
    		return RibbonUtils.isSecure(config, serverIntrospector, server);
    	}
    
    	protected Server getServer(String serviceId) {
    		return getServer(getLoadBalancer(serviceId));
    	}
    
    	protected Server getServer(ILoadBalancer loadBalancer) {
    		if (loadBalancer == null) {
    			return null;
    		}
    		return loadBalancer.chooseServer("default"); // TODO: better handling of key
    	}
    
    	protected ILoadBalancer getLoadBalancer(String serviceId) {
    		return this.clientFactory.getLoadBalancer(serviceId);
    	}
    
    	public static class RibbonServer implements ServiceInstance {
    		private final String serviceId;
    		private final Server server;
    		private final boolean secure;
    		private Map<String, String> metadata;
    
    		public RibbonServer(String serviceId, Server server) {
    			this(serviceId, server, false, Collections.<String, String> emptyMap());
    		}
    
    		public RibbonServer(String serviceId, Server server, boolean secure,
    				Map<String, String> metadata) {
    			this.serviceId = serviceId;
    			this.server = server;
    			this.secure = secure;
    			this.metadata = metadata;
    		}
    
    		@Override
    		public String getServiceId() {
    			return this.serviceId;
    		}
    
    		@Override
    		public String getHost() {
    			return this.server.getHost();
    		}
    
    		@Override
    		public int getPort() {
    			return this.server.getPort();
    		}
    
    		@Override
    		public boolean isSecure() {
    			return this.secure;
    		}
    
    		@Override
    		public URI getUri() {
    			return DefaultServiceInstance.getUri(this);
    		}
    
    		@Override
    		public Map<String, String> getMetadata() {
    			return this.metadata;
    		}
    
    		public Server getServer() {
    			return this.server;
    		}
    
    		@Override
    		public String getScheme() {
    			return this.server.getScheme();
    		}
    
    		@Override
    		public String toString() {
    			final StringBuilder sb = new StringBuilder("RibbonServer{");
    			sb.append("serviceId='").append(serviceId).append('\'');
    			sb.append(", server=").append(server);
    			sb.append(", secure=").append(secure);
    			sb.append(", metadata=").append(metadata);
    			sb.append('}');
    			return sb.toString();
    		}
    	}
    
    }

其中比较关键的部分：

……省略……
    
        @Override
    	public ServiceInstance choose(String serviceId) {
    		Server server = getServer(serviceId);
    		if (server == null) {
    			return null;
    		}
    		return new RibbonServer(serviceId, server, isSecure(server, serviceId),
    				serverIntrospector(serviceId).getMetadata(server));
    	}
    
    ……省略……
        protected Server getServer(String serviceId) {
    		return getServer(getLoadBalancer(serviceId));
    	}
    
    	protected Server getServer(ILoadBalancer loadBalancer) {
    		if (loadBalancer == null) {
    			return null;
    		}
    		return loadBalancer.chooseServer("default"); // TODO: better handling of key
    	}
    
    	protected ILoadBalancer getLoadBalancer(String serviceId) {
    		return this.clientFactory.getLoadBalancer(serviceId);
    	}
    ……省略……

在RibbonLoadBalancerClient的源码中，其中choose()方法是选择具体服务实例的一个方法。该方法通过getServer()方法去获取实例，经过源码跟踪，最终交给了ILoadBalancer类去选择服务实例。

/**
     * Interface that defines the operations for a software loadbalancer. A typical
     * loadbalancer minimally need a set of servers to loadbalance for, a method to
     * mark a particular server to be out of rotation and a call that will choose a
     * server from the existing list of server.
     * 
     * @author stonse
     * 
     */
    public interface ILoadBalancer {
    
    	/**
    	 * Initial list of servers.
    	 * This API also serves to add additional ones at a later time
    	 * The same logical server (host:port) could essentially be added multiple times
    	 * (helpful in cases where you want to give more "weightage" perhaps ..)
    	 * 
    	 * @param newServers new servers to add
    	 */
    	public void addServers(List<Server> newServers);
    	
    	/**
    	 * Choose a server from load balancer.
    	 * 
    	 * @param key An object that the load balancer may use to determine which server to return. null if 
    	 *         the load balancer does not use this parameter.
    	 * @return server chosen
    	 */
    	public Server chooseServer(Object key);
    	
    	/**
    	 * To be called by the clients of the load balancer to notify that a Server is down
    	 * else, the LB will think its still Alive until the next Ping cycle - potentially
    	 * (assuming that the LB Impl does a ping)
    	 * 
    	 * @param server Server to mark as down
    	 */
    	public void markServerDown(Server server);
    	
    	/**
    	 * @deprecated 2016-01-20 This method is deprecated in favor of the
    	 * cleaner {@link #getReachableServers} (equivalent to availableOnly=true)
    	 * and {@link #getAllServers} API (equivalent to availableOnly=false).
    	 *
    	 * Get the current list of servers.
    	 *
    	 * @param availableOnly if true, only live and available servers should be returned
    	 */
    	@Deprecated
    	public List<Server> getServerList(boolean availableOnly);
    
    	/**
    	 * @return Only the servers that are up and reachable.
         */
        public List<Server> getReachableServers();
    
        /**
         * @return All known servers, both reachable and unreachable.
         */
    	public List<Server> getAllServers();
    }

其中，addServers()方法是添加一个Server集合；chooseServer()方法是根据key 去 获 取 Server；markServerDown() 方 法 用 来 标 记 某 个 服 务 下 线 ；getReachableServers()获取可用的Server集合；getAllServers()获取所有的Server集合。

而其中的public Server chooseServer(Object key);的实现，BaseLoadBalancer中实现如下：

public Server chooseServer(Object key) {
            if (counter == null) {
                counter = createCounter();
            }
            counter.increment();
            if (rule == null) {
                return null;
            } else {
                try {
                    return rule.choose(key);
                } catch (Exception e) {
                    logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", name, key, e);
                    return null;
                }
            }
        }

其中用到了Rule：默认RoundRobinRule轮询。

private final static IRule DEFAULT_RULE = new RoundRobinRule();
        
    
        protected IRule rule = DEFAULT_RULE;

# 二、**DynamicServerListLoadBalancer** #

ILoadBalancer的继承类为 BaseLoadBalancer ， 它 的 实 现 类 为DynamicServerListLoadBalancer，这三者之间的关系如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 2][]

查看上述三个类的源码，可用发现，配置以下信息，IClientConfig、IRule、IPing 、 ServerList 、 ServerListFilter 和 ILoadBalancer ，查看BaseLoadBalancer类，它默认的情况下，实现了以下配置：

1.  IClientConfig ribbonClientConfig: DefaultClientConfigImpl配置 
2.  IRule ribbonRule: RoundRobinRule 路由策略 
3.  IPing ribbonPing: DummyPing 
4.  ServerList ribbonServerList: ConfigurationBasedServerList 
5.  ServerListFilter ribbonServerListFilter: ZonePreferenceServerListFilter 
6.  ILoadBalancer ribbonLoadBalancer: ZoneAwareLoadBalancer

IClientConfig 用于对客户端或者负载均衡的配置 ，它的默认实现类为DefaultClientConfigImpl。

IRule用于复杂均衡的策略，它有三个方法，其中choose()是根据key 来获取 server,setLoadBalancer() 和 getLoadBalancer() 是 用 来设 置 和 获 取ILoadBalancer的，它的源码如下：

public interface IRule{
        /*
         * choose one alive server from lb.allServers or
         * lb.upServers according to key
         * 
         * @return choosen Server object. NULL is returned if none
         *  server is available 
         */
    
        public Server choose(Object key);
        
        public void setLoadBalancer(ILoadBalancer lb);
        
        public ILoadBalancer getLoadBalancer();    
    }

IRule有很多默认的实现类，这些实现类根据不同的算法和逻辑来处理负载均衡。Ribbon实现的IRule有一下。在大多数情况下，这些默认的实现类是可以满足需求的，如果有特性的需求，可以自己实现。

1.  BestAvailableRule 选择最小请求数 
2.  ClientConfigEnabledRoundRobinRule 轮询 
3.  RandomRule 随机选择一个server 
4.  RoundRobinRule 轮询选择server 
5.  RetryRule 根据轮询的方式重试WeightedResponseTimeRule根据响应时间去分配一个weight，weight越低，被选择的可能性就越低。
6.  ZoneAvoidanceRule 根据server的zone区域和可用性来轮询选择

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 3][]

IPing是用来想server发生”ping”，来判断该server是否有响应，从而判断该server是否可用。它有一个isAlive()方法，它的源码如下：

/**
     * Interface that defines how we "ping" a server to check if its alive
     * @author stonse
     *
     */
    public interface IPing {
        
        /**
         * Checks whether the given <code>Server</code> is "alive" i.e. should be
         * considered a candidate while loadbalancing
         * 
         */
        public boolean isAlive(Server server);
    }

IPing 的 实 现 类 有 PingUrl 、 PingConstant 、 NoOpPing 、 DummyPing 和NIWSDiscoveryPing。他们之间的关系如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 4][]

1.  PingUrl 真实的去ping 某个url，判断其是否alive 
2.  PingConstant 固定返回某服务是否可用，默认返回true，即可用 
3.  NoOpPing 不去ping,直接返回true,即可用。 
4.  DummyPing 直接返回true，并实现了initWithNiwsConfig方法。

ServerList是定义获取所有的server的注册列表信息的接口，它的代码如下：

/**
     * Interface that defines the methods sed to obtain the List of Servers
     * @param <T>
     */
    public interface ServerList<T extends Server> {
    
        public List<T> getInitialListOfServers();
        
        /**
         * Return updated list of servers. This is called say every 30 secs
         * (configurable) by the Loadbalancer's Ping cycle
         * 
         */
        public List<T> getUpdatedListOfServers();   
    
    }

ServerListFilter接口，定于了可根据配置去过滤或者根据特性动态获取符合条件的server列表的方法，代码如下：

/**
     * This interface allows for filtering the configured or dynamically obtained
     * List of candidate servers with desirable characteristics.
     * 
     * @author stonse
     * 
     * @param <T>
     */
    public interface ServerListFilter<T extends Server> {
    
        public List<T> getFilteredListOfServers(List<T> servers);
    
    }

阅读DynamicServerListLoadBalancer的源码，DynamicServerListLoadBalancer的构造函数中有个initWithNiwsConfig()方

法。在该方法中，经过一系列的初始化配置，最终执行了restOfInit()方法。其代码如下：

public DynamicServerListLoadBalancer(IClientConfig clientConfig) {
            initWithNiwsConfig(clientConfig);
        }
        
        @Override
        public void initWithNiwsConfig(IClientConfig clientConfig) {
            try {
                super.initWithNiwsConfig(clientConfig);
                String niwsServerListClassName = clientConfig.getPropertyAsString(
                        CommonClientConfigKey.NIWSServerListClassName,
                        DefaultClientConfigImpl.DEFAULT_SEVER_LIST_CLASS);
    
                ServerList<T> niwsServerListImpl = (ServerList<T>) ClientFactory
                        .instantiateInstanceWithClientConfig(niwsServerListClassName, clientConfig);
                this.serverListImpl = niwsServerListImpl;
    
                if (niwsServerListImpl instanceof AbstractServerList) {
                    AbstractServerListFilter<T> niwsFilter = ((AbstractServerList) niwsServerListImpl)
                            .getFilterImpl(clientConfig);
                    niwsFilter.setLoadBalancerStats(getLoadBalancerStats());
                    this.filter = niwsFilter;
                }
    
                String serverListUpdaterClassName = clientConfig.getPropertyAsString(
                        CommonClientConfigKey.ServerListUpdaterClassName,
                        DefaultClientConfigImpl.DEFAULT_SERVER_LIST_UPDATER_CLASS
                );
    
                this.serverListUpdater = (ServerListUpdater) ClientFactory
                        .instantiateInstanceWithClientConfig(serverListUpdaterClassName, clientConfig);
    
                restOfInit(clientConfig);
            } catch (Exception e) {
                throw new RuntimeException(
                        "Exception while initializing NIWSDiscoveryLoadBalancer:"
                                + clientConfig.getClientName()
                                + ", niwsClientConfig:" + clientConfig, e);
            }
        }

在restOfInit()方法上，有一个 updateListOfServers()的方法，该方法是用来获取所有的ServerList的。

void restOfInit(IClientConfig clientConfig) {
            boolean primeConnection = this.isEnablePrimingConnections();
            // turn this off to avoid duplicated asynchronous priming done in BaseLoadBalancer.setServerList()
            this.setEnablePrimingConnections(false);
            enableAndInitLearnNewServersFeature();
    
            updateListOfServers();
            if (primeConnection && this.getPrimeConnections() != null) {
                this.getPrimeConnections()
                        .primeConnections(getReachableServers());
            }
            this.setEnablePrimingConnections(primeConnection);
            LOGGER.info("DynamicServerListLoadBalancer for client {} initialized: {}", clientConfig.getClientName(), this.toString());
        }

进 一 步 跟 踪 updateListOfServers() 方法的源码，最终由 serverListImpl.getUpdatedListOfServers()获取所有的服务列表的，代码如下：

@VisibleForTesting
        public void updateListOfServers() {
            List<T> servers = new ArrayList<T>();
            if (serverListImpl != null) {
                servers = serverListImpl.getUpdatedListOfServers();
                LOGGER.debug("List of Servers for {} obtained from Discovery client: {}",
                        getIdentifier(), servers);
    
                if (filter != null) {
                    servers = filter.getFilteredListOfServers(servers);
                    LOGGER.debug("Filtered List of Servers for {} obtained from Discovery client: {}",
                            getIdentifier(), servers);
                }
            }
            updateAllServerList(servers);
        }

而serverListImpl是ServerList接口的具体实现类。跟踪代码，ServerList的实现类 为 DiscoveryEnabledNIWSServerList ， 在ribbon-eureka.jar 的com.netflix.niws.loadbalancer下。其中DiscoveryEnabledNIWSServerList有getInitialListOfServers()和getUpdatedListOfServers()方法，具体代码如下：

@Override
        public List<DiscoveryEnabledServer> getInitialListOfServers(){
            return obtainServersViaDiscovery();
        }
    
        @Override
        public List<DiscoveryEnabledServer> getUpdatedListOfServers(){
            return obtainServersViaDiscovery();
        }

继 续 跟 踪 源 码 ， obtainServersViaDiscovery()，是根据eurekaClientProvider.get()来回去EurekaClient，再根据EurekaClient来获取注册列表信息，代码如下：

private List<DiscoveryEnabledServer> obtainServersViaDiscovery() {
            List<DiscoveryEnabledServer> serverList = new ArrayList<DiscoveryEnabledServer>();
    
            if (eurekaClientProvider == null || eurekaClientProvider.get() == null) {
                logger.warn("EurekaClient has not been initialized yet, returning an empty list");
                return new ArrayList<DiscoveryEnabledServer>();
            }
    
            EurekaClient eurekaClient = eurekaClientProvider.get();
            if (vipAddresses!=null){
                for (String vipAddress : vipAddresses.split(",")) {
                    // if targetRegion is null, it will be interpreted as the same region of client
                    List<InstanceInfo> listOfInstanceInfo = eurekaClient.getInstancesByVipAddress(vipAddress, isSecure, targetRegion);
                    for (InstanceInfo ii : listOfInstanceInfo) {
                        if (ii.getStatus().equals(InstanceStatus.UP)) {
    
                            if(shouldUseOverridePort){
                                if(logger.isDebugEnabled()){
                                    logger.debug("Overriding port on client name: " + clientName + " to " + overridePort);
                                }
    
                                // copy is necessary since the InstanceInfo builder just uses the original reference,
                                // and we don't want to corrupt the global eureka copy of the object which may be
                                // used by other clients in our system
                                InstanceInfo copy = new InstanceInfo(ii);
    
                                if(isSecure){
                                    ii = new InstanceInfo.Builder(copy).setSecurePort(overridePort).build();
                                }else{
                                    ii = new InstanceInfo.Builder(copy).setPort(overridePort).build();
                                }
                            }
    
                            DiscoveryEnabledServer des = new DiscoveryEnabledServer(ii, isSecure, shouldUseIpAddr);
                            des.setZone(DiscoveryClient.getZone(ii));
                            serverList.add(des);
                        }
                    }
                    if (serverList.size()>0 && prioritizeVipAddressBasedServers){
                        break; // if the current vipAddress has servers, we dont use subsequent vipAddress based servers
                    }
                }
            }
            return serverList;
        }

其中eurekaClientProvider的实现类是LegacyEurekaClientProvider，它是一个获取eurekaClient类，通过静态的方法去获取eurekaClient，其代码如下：

/**
     * A legacy class to provide eurekaclient via static singletons
     */
    class LegacyEurekaClientProvider implements Provider<EurekaClient> {
    
        private volatile EurekaClient eurekaClient;
    
        @Override
        public synchronized EurekaClient get() {
            if (eurekaClient == null) {
                eurekaClient = DiscoveryManager.getInstance().getDiscoveryClient();
            }
    
            return eurekaClient;
        }
    }

EurekaClient的实现类为DiscoveryClient，在之前已经分析了它具有服务注册、获取服务注册列表等的全部功能。

由此可见，负载均衡器是从EurekaClient获取服务信息，并根据IRule去路由，并且根据IPing去判断服务的可用性。

那么现在还有个问题，负载均衡器多久一次去获取一次从Eureka Client获取注册信息呢。

在BaseLoadBalancer类下，BaseLoadBalancer的构造函数，该构造函数开启了一个PingTask任务，代码如下：

public BaseLoadBalancer(String name, IRule rule, LoadBalancerStats stats,
                IPing ping, IPingStrategy pingStrategy) {
    	
            ...//代码省略
            setupPingTask();
            ...//代码省略
        }

setupPingTask()的具体代码逻辑，它开启了ShutdownEnabledTimer执行PingTask任务，在默认情况下pingIntervalSeconds为10，即每10秒钟，想EurekaClient发送一次”ping‘’。

void setupPingTask() {
            if (canSkipPing()) {
                return;
            }
            if (lbTimer != null) {
                lbTimer.cancel();
            }
            lbTimer = new ShutdownEnabledTimer("NFLoadBalancer-PingTimer-" + name,
                    true);
            lbTimer.schedule(new PingTask(), 0, pingIntervalSeconds * 1000);
            forceQuickPing();
        }

PingTask源码，即new一个Pinger对象，并执行runPinger()方法。

/**
         * TimerTask that keeps runs every X seconds to check the status of each
         * server/node in the Server List
         * 
         * @author stonse
         * 
         */
        class PingTask extends TimerTask {
            public void run() {
                try {
                	new Pinger(pingStrategy).runPinger();
                } catch (Exception e) {
                    logger.error("LoadBalancer [{}]: Error pinging", name, e);
                }
            }
        }

查看Pinger的runPinger()方法，最终根据 pingerStrategy.pingServers(ping, allServers)来获取服务的可用性，如果该返回结果，如之前相同，则不去向EurekaClient获取注册列表，如果不同则通知ServerStatusChangeListener或者changeListeners发生了改变，进行更新或者重新拉取。

/**
         * Class that contains the mechanism to "ping" all the instances
         * 
         * @author stonse
         *
         */
        class Pinger {
    
            private final IPingStrategy pingerStrategy;
    
            public Pinger(IPingStrategy pingerStrategy) {
                this.pingerStrategy = pingerStrategy;
            }
    
            public void runPinger() throws Exception {
                if (!pingInProgress.compareAndSet(false, true)) { 
                    return; // Ping in progress - nothing to do
                }
                
                // we are "in" - we get to Ping
    
                Server[] allServers = null;
                boolean[] results = null;
    
                Lock allLock = null;
                Lock upLock = null;
    
                try {
                    /*
                     * The readLock should be free unless an addServer operation is
                     * going on...
                     */
                    allLock = allServerLock.readLock();
                    allLock.lock();
                    allServers = allServerList.toArray(new Server[allServerList.size()]);
                    allLock.unlock();
    
                    int numCandidates = allServers.length;
                    results = pingerStrategy.pingServers(ping, allServers);
    
                    final List<Server> newUpList = new ArrayList<Server>();
                    final List<Server> changedServers = new ArrayList<Server>();
    
                    for (int i = 0; i < numCandidates; i++) {
                        boolean isAlive = results[i];
                        Server svr = allServers[i];
                        boolean oldIsAlive = svr.isAlive();
    
                        svr.setAlive(isAlive);
    
                        if (oldIsAlive != isAlive) {
                            changedServers.add(svr);
                            logger.debug("LoadBalancer [{}]:  Server [{}] status changed to {}", 
                        		name, svr.getId(), (isAlive ? "ALIVE" : "DEAD"));
                        }
    
                        if (isAlive) {
                            newUpList.add(svr);
                        }
                    }
                    upLock = upServerLock.writeLock();
                    upLock.lock();
                    upServerList = newUpList;
                    upLock.unlock();
    
                    notifyServerStatusChangeListener(changedServers);
                } finally {
                    pingInProgress.set(false);
                }
            }
        }

**由此可见，LoadBalancerClient是在初始化的时候，会向Eureka获取服务注册列表，并且向通过10s一次向EurekaClient发送“ping”，来判断服务的可用性，如果服务的可用性发生了改变或者服务数量和之前的不一致，则更新或者重新拉取。LoadBalancerClient有了这些服务注册列表，就可以根据具体的IRule 来进行负载均衡。**

# 三、**RestTemplate是如何和Ribbon结合的**  #

结合：springcloud ribbon的负载均衡注解 @LoadBalanced的实现原理（@Qulifier注解的使用）：[https://blog.csdn.net/itwxming/article/details/102833584][https_blog.csdn.net_itwxming_article_details_102833584]

最后，为什么在RestTemplate加一个@LoadBalance注解就可以开启负载均衡呢？

@ LoadBalanced

RestTemplate  restTemplate()  \{

return new RestTemplate();

全局搜索@LoadBalanced有哪些类用到了LoadBalanced有哪些类用到了， 发现LoadBalancerAutoConfiguration类，即LoadBalancer自动配置类。如下，参考旧版易理解代码：

@Configuration
    @ConditionalOnClass(RestTemplate.class)
    @ConditionalOnBean(LoadBalancerClient.class)
    @EnableConfigurationProperties(LoadBalancerRetryProperties.class)
    public class LoadBalancerAutoConfiguration {
        @LoadBalanced
        @Autowired(required = false)
        private List<RestTemplate> restTemplates = Collections.emptyList();
    }
    
        @Bean
        public SmartInitializingSingleton loadBalancedRestTemplateInitializer(final List<RestTemplateCustomizer> customizers) {
            return new SmartInitializingSingleton() {
                @Override
                public void afterSingletonsInstantiated() {
                    for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
                        for (RestTemplateCustomizer customizer : customizers) {
                            customizer.customize(restTemplate);
                        }
                    }
                }
            };
        }
    
        @Configuration
        @ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
        static class LoadBalancerInterceptorConfig {
            @Bean
            public LoadBalancerInterceptor ribbonInterceptor(LoadBalancerClient loadBalancerClient, LoadBalancerRequestFactory requestFactory) {
                return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
            }
    
            @Bean
            @ConditionalOnMissingBean
            public RestTemplateCustomizer restTemplateCustomizer(final LoadBalancerInterceptor loadBalancerInterceptor) {
                return new RestTemplateCustomizer() {
                    @Override
                    public void customize(RestTemplate restTemplate) {
                        List<ClientHttpRequestInterceptor> list = new ArrayList<>(restTemplate.getInterceptors());
                        list.add(loadBalancerInterceptor);
                        restTemplate.setInterceptors(list);
                    }
                };
            }
        }
    }

在该类中，首先维护了一个被@LoadBalanced修饰的RestTemplate对象的List，在初始化的过程中，通过调用customizer.customize(restTemplate)方法来给RestTemplate增加拦截器LoadBalancerInterceptor。而LoadBalancerInterceptor，用于实时拦截，在LoadBalancerInterceptor这里实现来负载均衡。LoadBalancerInterceptor的拦截方法如下：

@Override
    	public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
    			final ClientHttpRequestExecution execution) throws IOException {
    		final URI originalUri = request.getURI();
    		String serviceName = originalUri.getHost();
    		Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
    		return this.loadBalancer.execute(serviceName, requestFactory.createRequest(request, body, execution));
    	}

## **总结** ##

综上所述，Ribbon的负载均衡，主要通过LoadBalancerClient来实现的，而LoadBalancerClient具体交给了ILoadBalancer来处理，ILoadBalancer通过配置IRule、IPing等信息，并向EurekaClient获取注册列表的信息，并默认10秒一次向EurekaClient发送“ping”,进而检查是否更新服务列表，最后，得到注册列表后，ILoadBalancer根据IRule的策略进行负载均衡。而RestTemplate 被@LoadBalance注解后，能实现负载均衡，主要是维护了一个被@LoadBalance注解的RestTemplate列表，并给列表中的RestTemplate添加拦截器，进而交给负载均衡器去处理。

# 四、Ribbon调用流程总图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 5][]

# 五、Ribbon源码总图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 6][]

# 六、Feign源码总图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 7][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200529151714560.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_itwxming_article_details_102833584]: https://blog.csdn.net/itwxming/article/details/102833584
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200212010804516.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200529161404415.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200529161850522.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200529162047931.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200529160459142.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200529160654281.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2020052917163583.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n,size_16,color_FFFFFF,t_70