spring cloud ribbon 使用说明

太过爱你忘了你带给我的痛 2023-07-06 11:49 16阅读 0赞

### spring cloud ribbon 使用说明 ###

## ##

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**配置类**

**RibbonAutoConfiguration**

@Configuration
    @Conditional({RibbonAutoConfiguration.RibbonClassesConditions.class})
    @RibbonClients
    @AutoConfigureAfter(name = {"org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration"})
    @AutoConfigureBefore({LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class})
    @EnableConfigurationProperties({RibbonEagerLoadProperties.class, ServerIntrospectorProperties.class})
    public class RibbonAutoConfiguration {
    
        @Autowired(required = false)
        private List<RibbonClientSpecification> configurations = new ArrayList();
    
        @Autowired
        private RibbonEagerLoadProperties ribbonEagerLoadProperties;  //立即加载ribbon客户端，默认为false
    
        public RibbonAutoConfiguration() {
        }
    
        @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})
        public LoadBalancerClient loadBalancerClient() {
            return new RibbonLoadBalancerClient(this.springClientFactory());
        }//负载均衡客户端默认创建RibbonLoadBalancerClient
    
        @Bean
        @ConditionalOnClass(name = {"org.springframework.retry.support.RetryTemplate"})
        @ConditionalOnMissingBean
        public LoadBalancedRetryFactory loadBalancedRetryPolicyFactory(final SpringClientFactory clientFactory) {
            return new RibbonLoadBalancedRetryFactory(clientFactory);
        }//负载均衡客户端重试，需导入spring-retry
    
        @Bean
        @ConditionalOnMissingBean
        public PropertiesFactory propertiesFactory() {
            return new PropertiesFactory();
        }//设置属性：负载均衡策略、实例健康检查策略等
    
        @Bean
        @ConditionalOnProperty({"ribbon.eager-load.enabled"})
        public RibbonApplicationContextInitializer ribbonApplicationContextInitializer() {
            return new RibbonApplicationContextInitializer(this.springClientFactory(), this.ribbonEagerLoadProperties.getClients());
        }
    
        static class RibbonClassesConditions extends AllNestedConditions {
            RibbonClassesConditions() {
                super(ConfigurationPhase.PARSE_CONFIGURATION);
            }
    
            @ConditionalOnClass({Ribbon.class})
            static class RibbonPresent {
                RibbonPresent() {
                }
            }
    
            @ConditionalOnClass({AsyncRestTemplate.class})
            static class AsyncRestTemplatePresent {
                AsyncRestTemplatePresent() {
                }
            }
    
            @ConditionalOnClass({RestTemplate.class})
            static class RestTemplatePresent {
                RestTemplatePresent() {
                }
            }
    
            @ConditionalOnClass({IClient.class})
            static class IClientPresent {
                IClientPresent() {
                }
            }
        }
    
        private static class OnRibbonRestClientCondition extends AnyNestedCondition {
            OnRibbonRestClientCondition() {
                super(ConfigurationPhase.REGISTER_BEAN);
            }
    
            @ConditionalOnProperty({"ribbon.restclient.enabled"})
            static class RibbonProperty {
                RibbonProperty() {
                }
            }
    
        }
    
        @Target({ElementType.TYPE, ElementType.METHOD})
        @Retention(RetentionPolicy.RUNTIME)
        @Documented
        @Conditional({RibbonAutoConfiguration.OnRibbonRestClientCondition.class})
        @interface ConditionalOnRibbonRestClient {
        }
    
        @Configuration(proxyBeanMethods = false)
        @ConditionalOnClass({HttpRequest.class})
        @RibbonAutoConfiguration.ConditionalOnRibbonRestClient
        protected static class RibbonClientHttpRequestFactoryConfiguration {
            @Autowired
            private SpringClientFactory springClientFactory;
    
            protected RibbonClientHttpRequestFactoryConfiguration() {
            }
    
            @Bean
            public RestTemplateCustomizer restTemplateCustomizer(final RibbonClientHttpRequestFactory ribbonClientHttpRequestFactory) {
                return (restTemplate) -> {
                    restTemplate.setRequestFactory(ribbonClientHttpRequestFactory);
                };
            }
    
            @Bean
            public RibbonClientHttpRequestFactory ribbonClientHttpRequestFactory() {
                return new RibbonClientHttpRequestFactory(this.springClientFactory);
            }
        }
    }

**LoadBalancerClient：负载均衡客户端，默认使用RibbonLoadBalancerClient**

public interface LoadBalancerClient extends ServiceInstanceChooser {
    
        <T> T execute(String serviceId, LoadBalancerRequest<T> request) throws IOException;
        <T> T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest<T> request) throws IOException; 
                                              //执行客户端请求
    
        URI reconstructURI(ServiceInstance instance, URI original);  //将serviceInstance转换为host:port形式
    }
    
    **********************
    ServiceInstanceChooser：选取客户端
    
    public interface ServiceInstanceChooser {
        ServiceInstance choose(String serviceId); //根据serviceId选取serviceInstance实例
    }

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**配置属性**

**PropertiesFactory**

public class PropertiesFactory {
        @Autowired
        private Environment environment;
        private Map<Class, String> classToProperty = new HashMap();
    
        public PropertiesFactory() {
            this.classToProperty.put(ILoadBalancer.class, "NFLoadBalancerClassName"); //负载均衡器
            this.classToProperty.put(IPing.class, "NFLoadBalancerPingClassName"); //实例检查
            this.classToProperty.put(IRule.class, "NFLoadBalancerRuleClassName"); //负载均衡策略
            this.classToProperty.put(ServerList.class, "NIWSServerListClassName");//实例列表
            this.classToProperty.put(ServerListFilter.class, "NIWSServerListFilterClassName");  //实例过滤
        }
    
        public boolean isSet(Class clazz, String name) {
            return StringUtils.hasText(this.getClassName(clazz, name));
        }
    
        public String getClassName(Class clazz, String name) {
            if (this.classToProperty.containsKey(clazz)) {
                String classNameProperty = (String)this.classToProperty.get(clazz);
                String className = this.environment.getProperty(name + "." + "ribbon" + "." + classNameProperty);
                return className;
            } else {
                return null;
            }
        }

**RibbonClientConfiguration：ribbon客户端配置**

@Configuration(proxyBeanMethods = false)
    @EnableConfigurationProperties
    @Import({HttpClientConfiguration.class, OkHttpRibbonConfiguration.class, RestClientRibbonConfiguration.class, HttpClientRibbonConfiguration.class})
    public class RibbonClientConfiguration {
        public static final int DEFAULT_CONNECT_TIMEOUT = 1000;  //连接超时时间
        public static final int DEFAULT_READ_TIMEOUT = 1000;     //请求超市时间
        public static final boolean DEFAULT_GZIP_PAYLOAD = true; //请求压缩，默认为true
    
        @RibbonClientName
        private String name = "client";
    
        @Autowired
        private PropertiesFactory propertiesFactory;
    
        public RibbonClientConfiguration() {
        }
    
        @Bean
        @ConditionalOnMissingBean
        public IClientConfig ribbonClientConfig() {
            DefaultClientConfigImpl config = new DefaultClientConfigImpl();
            config.loadProperties(this.name);
            config.set(CommonClientConfigKey.ConnectTimeout, 1000);
            config.set(CommonClientConfigKey.ReadTimeout, 1000);
            config.set(CommonClientConfigKey.GZipPayload, true);
            return config;
        }//客户端配置，默认使用DefaultClientConfigImpl
    
        @Bean
        @ConditionalOnMissingBean
        public IRule ribbonRule(IClientConfig config) {
            if (this.propertiesFactory.isSet(IRule.class, this.name)) {
                return (IRule)this.propertiesFactory.get(IRule.class, config, this.name);
            } else {
                ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
                rule.initWithNiwsConfig(config);
                return rule;
            }
        }//负载均衡策略，默认使用ZoneAvoidanceRule
    
        @Bean
        @ConditionalOnMissingBean
        public IPing ribbonPing(IClientConfig config) {
            return (IPing)(this.propertiesFactory.isSet(IPing.class, this.name) ? (IPing)this.propertiesFactory.get(IPing.class, config, this.name) : new DummyPing());
        }//实例检查，默认使用DummyPing
    
        @Bean
        @ConditionalOnMissingBean
        public ServerList<Server> ribbonServerList(IClientConfig config) {
            if (this.propertiesFactory.isSet(ServerList.class, this.name)) {
                return (ServerList)this.propertiesFactory.get(ServerList.class, config, this.name);
            } else {
                ConfigurationBasedServerList serverList = new ConfigurationBasedServerList();
                serverList.initWithNiwsConfig(config);
                return serverList;
            }
        }//从proprttiesFactory中获取实例列表
    
        @Bean
        @ConditionalOnMissingBean
        public ServerListUpdater ribbonServerListUpdater(IClientConfig config) {
            return new PollingServerListUpdater(config);
        }//实例更新，默认使用PollingServerListUpdater
    
        @Bean
        @ConditionalOnMissingBean
        public ILoadBalancer ribbonLoadBalancer(IClientConfig config, ServerList<Server> serverList, ServerListFilter<Server> serverListFilter, IRule rule, IPing ping, ServerListUpdater serverListUpdater) {
            return (ILoadBalancer)(this.propertiesFactory.isSet(ILoadBalancer.class, this.name) ? (ILoadBalancer)this.propertiesFactory.get(ILoadBalancer.class, config, this.name) : new ZoneAwareLoadBalancer(config, rule, ping, serverList, serverListFilter, serverListUpdater));
        }//负载均衡器，默认使用ZoneAwareLoadBalancer
    
        @Bean
        @ConditionalOnMissingBean
        public ServerListFilter<Server> ribbonServerListFilter(IClientConfig config) {
            if (this.propertiesFactory.isSet(ServerListFilter.class, this.name)) {
                return (ServerListFilter)this.propertiesFactory.get(ServerListFilter.class, config, this.name);
            } else {
                ZonePreferenceServerListFilter filter = new ZonePreferenceServerListFilter();
                filter.initWithNiwsConfig(config);
                return filter;
            }
        }//实例过滤器，默认使用ZonePreferenceServerListFilter
    
        @Bean
        @ConditionalOnMissingBean
        public RibbonLoadBalancerContext ribbonLoadBalancerContext(ILoadBalancer loadBalancer, IClientConfig config, RetryHandler retryHandler) {
            return new RibbonLoadBalancerContext(loadBalancer, config, retryHandler);
        }
    
        @Bean
        @ConditionalOnMissingBean
        public RetryHandler retryHandler(IClientConfig config) {
            return new DefaultLoadBalancerRetryHandler(config);
        }//实例重试配置

**DefaultClientConfigImpl：默认的客户端配置**

public class DefaultClientConfigImpl implements IClientConfig {
        public static final Boolean DEFAULT_PRIORITIZE_VIP_ADDRESS_BASED_SERVERS;
        public static final String DEFAULT_NFLOADBALANCER_PING_CLASSNAME = "com.netflix.loadbalancer.DummyPing";
        public static final String DEFAULT_NFLOADBALANCER_RULE_CLASSNAME = "com.netflix.loadbalancer.AvailabilityFilteringRule";
        public static final String DEFAULT_NFLOADBALANCER_CLASSNAME = "com.netflix.loadbalancer.ZoneAwareLoadBalancer";
        public static final boolean DEFAULT_USEIPADDRESS_FOR_SERVER;
        public static final String DEFAULT_CLIENT_CLASSNAME = "com.netflix.niws.client.http.RestClient";
        public static final String DEFAULT_VIPADDRESS_RESOLVER_CLASSNAME = "com.netflix.client.SimpleVipAddressResolver";
        public static final String DEFAULT_PRIME_CONNECTIONS_URI = "/";
        public static final int DEFAULT_MAX_TOTAL_TIME_TO_PRIME_CONNECTIONS = 30000;
        public static final int DEFAULT_MAX_RETRIES_PER_SERVER_PRIME_CONNECTION = 9;
        public static final Boolean DEFAULT_ENABLE_PRIME_CONNECTIONS;
        public static final int DEFAULT_MAX_REQUESTS_ALLOWED_PER_WINDOW = 2147483647;
        public static final int DEFAULT_REQUEST_THROTTLING_WINDOW_IN_MILLIS = 60000;
        public static final Boolean DEFAULT_ENABLE_REQUEST_THROTTLING;
        public static final Boolean DEFAULT_ENABLE_GZIP_CONTENT_ENCODING_FILTER;
        public static final Boolean DEFAULT_CONNECTION_POOL_CLEANER_TASK_ENABLED;
        public static final Boolean DEFAULT_FOLLOW_REDIRECTS;
        public static final float DEFAULT_PERCENTAGE_NIWS_EVENT_LOGGED = 0.0F;
    
        public static final int DEFAULT_MAX_AUTO_RETRIES_NEXT_SERVER = 1; //切换到其余实例次数
        public static final int DEFAULT_MAX_AUTO_RETRIES = 0;  //默认最大重试次数
        public static final int DEFAULT_BACKOFF_INTERVAL = 0;
        public static final int DEFAULT_READ_TIMEOUT = 5000;   //默认请求超时时间
        public static final int DEFAULT_CONNECTION_MANAGER_TIMEOUT = 2000;
        public static final int DEFAULT_CONNECT_TIMEOUT = 2000; //默认连接超时时间
    
        public static final Boolean DEFAULT_ENABLE_CONNECTION_POOL;
        public static final int DEFAULT_MAX_CONNECTIONS_PER_HOST = 50;
        public static final int DEFAULT_MAX_TOTAL_CONNECTIONS = 200;
        public static final float DEFAULT_MIN_PRIME_CONNECTIONS_RATIO = 1.0F;
        public static final String DEFAULT_PRIME_CONNECTIONS_CLASS = "com.netflix.niws.client.http.HttpPrimeConnection";
        public static final String DEFAULT_SEVER_LIST_CLASS = "com.netflix.loadbalancer.ConfigurationBasedServerList";
        public static final String DEFAULT_SERVER_LIST_UPDATER_CLASS = "com.netflix.loadbalancer.PollingServerListUpdater";
        public static final int DEFAULT_CONNECTION_IDLE_TIMERTASK_REPEAT_IN_MSECS = 30000;
        public static final int DEFAULT_CONNECTIONIDLE_TIME_IN_MSECS = 30000;
        protected volatile Map<String, Object> properties;
        protected Map<IClientConfigKey<?>, Object> typedProperties;
        private static final Logger LOG;
        private String clientName;
        private VipAddressResolver resolver;
        private boolean enableDynamicProperties;
        public static final int DEFAULT_POOL_MAX_THREADS = 200;
        public static final int DEFAULT_POOL_MIN_THREADS = 1;
        public static final long DEFAULT_POOL_KEEP_ALIVE_TIME = 900L;
        public static final TimeUnit DEFAULT_POOL_KEEP_ALIVE_TIME_UNITS;
        public static final Boolean DEFAULT_ENABLE_ZONE_AFFINITY;
        public static final Boolean DEFAULT_ENABLE_ZONE_EXCLUSIVITY;
        public static final int DEFAULT_PORT = 7001;
        public static final Boolean DEFAULT_ENABLE_LOADBALANCER;
        public static final String DEFAULT_PROPERTY_NAME_SPACE = "ribbon";
        private String propertyNameSpace;
        public static final Boolean DEFAULT_OK_TO_RETRY_ON_ALL_OPERATIONS;
        public static final Boolean DEFAULT_ENABLE_NIWS_EVENT_LOGGING;
        public static final Boolean DEFAULT_IS_CLIENT_AUTH_REQUIRED;
        private final Map<String, DynamicStringProperty> dynamicProperties;

**DefaultLoadBalancerRetryHandler：实例重试**

public class DefaultLoadBalancerRetryHandler implements RetryHandler {
        private List<Class<? extends Throwable>> retriable = Lists.newArrayList(new Class[]{ConnectException.class, SocketTimeoutException.class});
        private List<Class<? extends Throwable>> circuitRelated = Lists.newArrayList(new Class[]{SocketException.class, SocketTimeoutException.class});
        protected final int retrySameServer;
        protected final int retryNextServer;
        protected final boolean retryEnabled;
    
        public DefaultLoadBalancerRetryHandler() {
            this.retrySameServer = 0;
            this.retryNextServer = 0;
            this.retryEnabled = false;
        }

**LoadBalancerRetryProperties：重试默认开启**

@ConfigurationProperties("spring.cloud.loadbalancer.retry")
    public class LoadBalancerRetryProperties {
        private boolean enabled = true;

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**配置格式**

**全局配置：**ribbon.key=value

**指定客户端配置：**client\_name.ribbon.key=value

**常用配置**

ribbon.ConnectTimeout: 1000             //连接超时时间
    ribbon.ReadTimeout: 1000                //请求超时时间
    ribbon.OkToRetryOnAllOperations: true   //对所有的操作失败都重试
    ribbon.MaxAutoRetries: 2                //当前客户端失败重试次数
    ribbon.MaxAutoRetriesNextServer: 2      //尝试连接其余实例的个数

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**负载均衡器**

**ILoadBalancer：负载均衡接口**

public interface ILoadBalancer {
    
        void addServers(List<Server> var1);  //添加实例
        Server chooseServer(Object var1);    //选择实例
    
        void markServerDown(Server var1);    //标记实例不可用
    
        List<Server> getReachableServers();  //获取可用实例
        List<Server> getAllServers();        //获取所有实例
    }

**AbstractLoadBalancer**

public abstract class AbstractLoadBalancer implements ILoadBalancer {
        public AbstractLoadBalancer() {
        }
    
        public Server chooseServer() {
            return this.chooseServer((Object)null);
        }
    
        public abstract List<Server> getServerList(AbstractLoadBalancer.ServerGroup var1);
    
        public abstract LoadBalancerStats getLoadBalancerStats();
    
        public static enum ServerGroup {
            ALL,             //所有实例
            STATUS_UP,       //可用实例
            STATUS_NOT_UP;   //不可用实例
    
            private ServerGroup() {
            }
        }
    }

**NoOpLoadBalancer：不添加、返回任何实例**

public class NoOpLoadBalancer extends AbstractLoadBalancer {
        static final Logger logger = LoggerFactory.getLogger(NoOpLoadBalancer.class);
    
        public NoOpLoadBalancer() {
        }
    
        public void addServers(List<Server> newServers) {
            logger.info("addServers to NoOpLoadBalancer ignored");
        }
    
        public Server chooseServer(Object key) {
            return null;
        }
    
        public LoadBalancerStats getLoadBalancerStats() {
            return null;
        }
    
        public List<Server> getServerList(ServerGroup serverGroup) {
            return Collections.emptyList();
        }
    
        public void markServerDown(Server server) {
            logger.info("markServerDown to NoOpLoadBalancer ignored");
        }
    
        public List<Server> getServerList(boolean availableOnly) {
            return null;
        }
    
        public List<Server> getReachableServers() {
            return null;
        }
    
        public List<Server> getAllServers() {
            return null;
        }
    }

**BaseLoadBalancer：基础负载均衡器**

private static Logger logger = LoggerFactory.getLogger(BaseLoadBalancer.class);
        private static final IRule DEFAULT_RULE = new RoundRobinRule();  //默认使用线性轮询策略
        private static final BaseLoadBalancer.SerialPingStrategy DEFAULT_PING_STRATEGY = new BaseLoadBalancer.SerialPingStrategy((SyntheticClass_1)null);
                                                                        //实例健康检测默认使用线性轮询
        private static final String DEFAULT_NAME = "default";
        private static final String PREFIX = "LoadBalancer_";
        protected IRule rule;
        protected IPingStrategy pingStrategy;
        protected IPing ping;
        @Monitor(
            name = "LoadBalancer_AllServerList",
            type = DataSourceType.INFORMATIONAL
        )
        protected volatile List<Server> allServerList;
        @Monitor(
            name = "LoadBalancer_UpServerList",
            type = DataSourceType.INFORMATIONAL
        )
        protected volatile List<Server> upServerList;
        protected ReadWriteLock allServerLock;
        protected ReadWriteLock upServerLock;
        protected String name;
        protected Timer lbTimer;
        protected int pingIntervalSeconds;
        protected int maxTotalPingTimeSeconds;
        protected Comparator<Server> serverComparator;
        protected AtomicBoolean pingInProgress;
        protected LoadBalancerStats lbStats;
        private volatile Counter counter;
        private PrimeConnections primeConnections;
        private volatile boolean enablePrimingConnections;
        private IClientConfig config;
        private List<ServerListChangeListener> changeListeners;
        private List<ServerStatusChangeListener> serverStatusListeners;

**DynamicServerListLoadBalancer：运行期更新实例，并可过滤实例**

public class DynamicServerListLoadBalancer<T extends Server> extends BaseLoadBalancer {
        private static final Logger LOGGER = LoggerFactory.getLogger(DynamicServerListLoadBalancer.class);
        boolean isSecure;
        boolean useTunnel;
        protected AtomicBoolean serverListUpdateInProgress;
        volatile ServerList<T> serverListImpl;
        volatile ServerListFilter<T> filter;
        protected final UpdateAction updateAction;
        protected volatile ServerListUpdater serverListUpdater;
    
    **************
    构造方法
    
        public DynamicServerListLoadBalancer() {
        public DynamicServerListLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping, ServerList<T> serverList, ServerListFilter<T> filter, ServerListUpdater serverListUpdater) {
        public DynamicServerListLoadBalancer(IClientConfig clientConfig) {
    
    **************
    普通方法
    
        public void initWithNiwsConfig(IClientConfig clientConfig) {
        void restOfInit(IClientConfig clientConfig) {
    
        public void setServersList(List lsrv) {
        protected void setServerListForZones(Map<String, List<Server>> zoneServersMap) {
    
        public void setServerListImpl(ServerList<T> niwsServerList) {
        public ServerList<T> getServerListImpl() {
    
        public void setFilter(ServerListFilter<T> filter) {
        public ServerListFilter<T> getFilter() {  //实例过滤器
    
        public void setServerListUpdater(ServerListUpdater serverListUpdater) {
        public ServerListUpdater getServerListUpdater() {  //健康实例更新
    
        public void forceQuickPing() {            //健康检测
        public void stopServerListRefreshing() {  //停止实例更新
        public void updateListOfServers() {       //实例更新
    
        public String getLastUpdate() {
        public long getDurationSinceLastUpdateMs() {  //上次更新的时间间隔，单位为毫秒

**ZoneAwareLoadBalancer：每个zone设置负载均衡器进行实例选择，默认使用的负载均衡器**

public class ZoneAwareLoadBalancer<T extends Server> extends DynamicServerListLoadBalancer<T> {
        private ConcurrentHashMap<String, BaseLoadBalancer> balancers = new ConcurrentHashMap();
        private static final Logger logger = LoggerFactory.getLogger(ZoneAwareLoadBalancer.class);
        private volatile DynamicDoubleProperty triggeringLoad;
        private volatile DynamicDoubleProperty triggeringBlackoutPercentage;
        private static final DynamicBooleanProperty ENABLED = DynamicPropertyFactory.getInstance().getBooleanProperty("ZoneAwareNIWSDiscoveryLoadBalancer.enabled", true);
    
        void setUpServerList(List<Server> upServerList) {
            this.upServerList = upServerList;
        }
    
    ***************
    构造方法
    
        public ZoneAwareLoadBalancer() {
        public ZoneAwareLoadBalancer(IClientConfig clientConfig, IRule rule, IPing ping, ServerList<T> serverList, ServerListFilter<T> filter, ServerListUpdater serverListUpdater) {
        public ZoneAwareLoadBalancer(IClientConfig niwsClientConfig) {
    
    
    ***************
    普通方法
    
        protected void setServerListForZones(Map<String, List<Server>> zoneServersMap) {
        public Server chooseServer(Object key) {
        BaseLoadBalancer getLoadBalancer(String zone) {
        public void setRule(IRule rule) {

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**负载均衡策略**

**IRule：负载均衡策略接口**

public interface IRule {
        Server choose(Object var1);
    
        void setLoadBalancer(ILoadBalancer var1);
    
        ILoadBalancer getLoadBalancer();
    }

**AbstractLoadBalancerRule**

public abstract class AbstractLoadBalancerRule implements IRule, IClientConfigAware {
        private ILoadBalancer lb;
    
        public AbstractLoadBalancerRule() {
        }
    
        public void setLoadBalancer(ILoadBalancer lb) {
            this.lb = lb;
        }
    
        public ILoadBalancer getLoadBalancer() {
            return this.lb;
        }
    }

**RandomRule：随机选择实例**

**RoundRobinRule：线性轮询**

**RetryRule：使用线性轮询，选到可用实例则返回，否则重试**

**WeightedResponseTimeRule：线性轮询，各实例设置权重**

**ClientConfigEnabledRoundRobinRule：使用线性轮询选择实例**

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

**PredicateBasedRule：过滤后再选择实例**

public abstract class PredicateBasedRule extends ClientConfigEnabledRoundRobinRule {
        public PredicateBasedRule() {
        }
    
        public abstract AbstractServerPredicate getPredicate();
    
        public Server choose(Object key) {
            ILoadBalancer lb = this.getLoadBalancer();
            Optional<Server> server = this.getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
            return server.isPresent() ? (Server)server.get() : null;
        }
    }

**BestAvailableRule：遍历服务列表，返回连接最少的实例**

**AvailabilityFilteringRule：线性遍历列表选择实例，若满足过滤条件则返回实例，否则继续选择满足条件的实例**

public class AvailabilityFilteringRule extends PredicateBasedRule {
        private AbstractServerPredicate predicate = CompositePredicate.withPredicate(new AvailabilityPredicate(this, (IClientConfig)null)).addFallbackPredicate(AbstractServerPredicate.alwaysTrue()).build();
    
        public AvailabilityFilteringRule() {
        }
    
        public void initWithNiwsConfig(IClientConfig clientConfig) {
            this.predicate = CompositePredicate.withPredicate(new AvailabilityPredicate(this, clientConfig)).addFallbackPredicate(AbstractServerPredicate.alwaysTrue()).build();
        }
    
        @Monitor(
            name = "AvailableServersCount",
            type = DataSourceType.GAUGE
        )
        public int getAvailableServersCount() {
            ILoadBalancer lb = this.getLoadBalancer();
            List<Server> servers = lb.getAllServers();
            return servers == null ? 0 : Collections2.filter(servers, this.predicate.getServerOnlyPredicate()).size();
        }
    
        public Server choose(Object key) {
            int count = 0;
    
            for(Server server = this.roundRobinRule.choose(key); count++ <= 10; server = this.roundRobinRule.choose(key)) {
                if (this.predicate.apply(new PredicateKey(server))) {
                    return server;
                }
            }
    
            return super.choose(key);
        }
    
        public AbstractServerPredicate getPredicate() {
            return this.predicate;
        }
    }

**ZoneAvoidanceRule：先根据过滤条件过滤实例，再对过滤后的实例列表线性遍历**

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**负载均衡操作**

**@Loadbalanced：****将该注解加在restTemplate上可实现负载均衡**

@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Qualifier
    public @interface LoadBalanced {
    }

**RestTemplate：请求操作类**

public class RestTemplate extends InterceptingHttpAccessor implements RestOperations {
    
        public RestTemplate() {
        public RestTemplate(ClientHttpRequestFactory requestFactory) {
        public RestTemplate(List<HttpMessageConverter<?>> messageConverters) {
    
    ***************
    get操作
    
        public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
        public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
        public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException {
    
        public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
        public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
        public <T> ResponseEntity<T> getForEntity(URI url, Class<T> responseType) throws RestClientException {
    
    
    ***************
    header操作
    
        public HttpHeaders headForHeaders(String url, Object... uriVariables) throws RestClientException {
        public HttpHeaders headForHeaders(String url, Map<String, ?> uriVariables) throws RestClientException {
        public HttpHeaders headForHeaders(URI url) throws RestClientException {
    
    
    ***************
    post操作
    
        public URI postForLocation(String url, @Nullable Object request, Object... uriVariables) throws RestClientException {
        public URI postForLocation(String url, @Nullable Object request, Map<String, ?> uriVariables) throws RestClientException {
        public URI postForLocation(URI url, @Nullable Object request) throws RestClientException {
    
        public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables) throws RestClientException {
        public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
        public <T> T postForObject(URI url, @Nullable Object request, Class<T> responseType) throws RestClientException {
    
        public <T> ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables) throws RestClientException {
        public <T> ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
        public <T> ResponseEntity<T> postForEntity(URI url, @Nullable Object request, Class<T> responseType) throws RestClientException {
    
    
    ***************
    put 操作
    
        public void put(String url, @Nullable Object request, Object... uriVariables) throws RestClientException {
        public void put(String url, @Nullable Object request, Map<String, ?> uriVariables) throws RestClientException {
        public void put(URI url, @Nullable Object request) throws RestClientException {
    
    
    ***************
    patch操作
    
        public <T> T patchForObject(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables) throws RestClientException {
        public <T> T patchForObject(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
        public <T> T patchForObject(URI url, @Nullable Object request, Class<T> responseType) throws RestClientException {
    
    
    ***************
    delete操作
    
        public void delete(String url, Object... uriVariables) throws RestClientException {
        public void delete(String url, Map<String, ?> uriVariables) throws RestClientException {
        public void delete(URI url) throws RestClientException {
    
    
    ***************
    options操作
    
        public Set<HttpMethod> optionsForAllow(String url, Object... uriVariables) throws RestClientException {
        public Set<HttpMethod> optionsForAllow(String url, Map<String, ?> uriVariables) throws RestClientException {
        public Set<HttpMethod> optionsForAllow(URI url) throws RestClientException {
    
    
    ***************
    exchange操作
    
        public <T> ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException {
        public <T> ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
    
        public <T> ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Object... uriVariables) throws RestClientException {
        public <T> ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
    
        public <T> ResponseEntity<T> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType) throws RestClientException {
        public <T> ResponseEntity<T> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType) throws RestClientException {
    
        public <T> ResponseEntity<T> exchange(RequestEntity<?> requestEntity, Class<T> responseType) throws RestClientException {
        public <T> ResponseEntity<T> exchange(RequestEntity<?> requestEntity, ParameterizedTypeReference<T> responseType) throws RestClientException {
    
    
    ***************
    execute 操作
    
        public <T> T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables) throws RestClientException {
        public <T> T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Map<String, ?> uriVariables) throws RestClientException {
        public <T> T execute(URI url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {