温故知新（四）Ribbon执行流程解析

最新推荐文章于 2022-11-21 17:03:01 发布
最新推荐文章于 2022-11-21 17:03:01 发布
阅读量1.3k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w1054993544/article/details/89088696
版权

一、准备

  • ribbon版本2.2.5
  • 运行启动lesson1的Provider工程
    在这里插入图片描述
    端口号为6667的返回“i am provider1”，端口号为6668的返回“i am provider2”。
  • 新建lesson3，只引入ribbon。
     <dependencies>
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon</artifactId>
            <version>2.2.5</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-core</artifactId>
            <version>2.2.5</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-httpclient</artifactId>
            <version>2.2.5</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-loadbalancer</artifactId>
            <version>2.2.5</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.archaius</groupId>
            <artifactId>archaius-core</artifactId>
            <version>0.7.4</version>
        </dependency>
        <dependency>
            <groupId>commons-configuration</groupId>
            <artifactId>commons-configuration</artifactId>
            <version>1.8</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>16.0.1</version>
        </dependency>
    </dependencies>

在这里插入图片描述
application.properties中列出我们的服务：
sample-client.ribbon.listOfServers=localhost:6667,localhost:6668
Client代码如下：

public class Client {
    public static void main(String[] args) throws Exception{
        ConfigurationManager.loadPropertiesFromResources("application.properties");//1
        System.out.println(ConfigurationManager.getConfigInstance().getProperty("sample-client.ribbon.listOfServers"));
        RestClient client = (RestClient) ClientFactory.getNamedClient("sample-client");//2
        HttpRequest request = HttpRequest.newBuilder().uri("/provider").build();//3
        for (int i = 0; i < 10; i++)  {
            HttpResponse response = client.executeWithLoadBalancer(request); // 4
            System.out.println("Status code for " + response.getRequestedURI() + "  :" + response.getStatus()+" entity: "+response.getEntity(String.class));
        }
    }
}

执行结果如下：
在这里插入图片描述
实现了负载均衡。

二、执行流程解析

public class Client {
    public static void main(String[] args) throws Exception{
        ConfigurationManager.loadPropertiesFromResources("application.properties");//1
        System.out.println(ConfigurationManager.getConfigInstance().getProperty("sample-client.ribbon.listOfServers"));
        RestClient client = (RestClient) ClientFactory.getNamedClient("sample-client");//2
        HttpRequest request = HttpRequest.newBuilder().uri("/provider").build();//3
        for (int i = 0; i < 10; i++)  {
            HttpResponse response = client.executeWithLoadBalancer(request); // 4
            System.out.println("Status code for " + response.getRequestedURI() + "  :" + response.getStatus()+" entity: "+response.getEntity(String.class));
        }
    }
}
  • 编号为1的加载配置信息。
  • 编号为2的获取RestClient
  • 编号为3的创建一个请求
  • 编号为4的执行请求

2.1loadPropertiesFromResources

ConfigurationManager主要用来做配置管理，loadPropertiesFromResources加载配置文件，并把配置信息写入ConcurrentMapConfiguration，为后续的请求做准备。

 public static void loadPropertiesFromResources(String path) 
            throws IOException {
       .......................
        while (resources.hasMoreElements()) {
            URL url = resources.nextElement();
            InputStream fin = url.openStream();
            Properties props = ConfigurationUtils.loadPropertiesFromInputStream(fin);
            if (instance instanceof AggregatedConfiguration) {
                String name = getConfigName(url);
                ConcurrentMapConfiguration config = new ConcurrentMapConfiguration();
                config.loadProperties(props);
                ((AggregatedConfiguration) instance).addConfiguration(config, name);
            } else {
                ConfigurationUtils.loadProperties(props, instance);
            }
        }
    }

因为properties中设置sample-client.ribbon.listOfServers=localhost:6667,localhost:6668，那么会把key=sample-client.ribbon.listOfServers，value=localhost:6667,localhost:6668的put到ConcurrentMapConfiguration的map,其他变量类似。

2.2RestClient

RestClient client = (RestClient) ClientFactory.getNamedClient(“sample-client”);通过client name来获取RestClient，

    public static synchronized IClient getNamedClient(String name) {
        return getNamedClient(name, DefaultClientConfigImpl.class);
    }
    
    public static synchronized IClient getNamedClient(String name, Class<? extends IClientConfig> configClass) {
    	if (simpleClientMap.get(name) != null) {
    	    return simpleClientMap.get(name);
    	}
        try {
            return createNamedClient(name, configClass);
        } catch (ClientException e) {
            throw new RuntimeException("Unable to create client", e);
        }
    }
    public static synchronized IClient createNamedClient(String name, Class<? extends IClientConfig> configClass) throws ClientException {
    	IClientConfig config = getNamedConfig(name, configClass);
        return registerClientFromProperties(name, config);
    }

其中DefaultClientConfigImpl是默认的client的配置实现类，如默认MaxTotalConnections，ConnectTimeout，ConnectionManagerTimeout，ReadTimeout等。
最终调用ClientFactory的getNamedConfig获取ClientConfig，调用registerClientFromProperties通过反射获取client和loadbalance

2.2.1创建IClientConfig
    public static IClientConfig getNamedConfig(String name, Class<? extends IClientConfig> clientConfigClass) {
        IClientConfig config = namedConfig.get(name);
        if (config != null) {
            return config;
        } else {
            try {
                config = (IClientConfig) clientConfigClass.newInstance();
                config.loadProperties(name);
            } catch (InstantiationException | IllegalAccessException e) {
                logger.error("Unable to create named client config '{}' instance for config class {}", name,
                        clientConfigClass, e);
                return null;
            }
            config.loadProperties(name);
            IClientConfig old = namedConfig.putIfAbsent(name, config);
            if (old != null) {
                config = old;
            }
            return config;
        }
    }

config = (IClientConfig) clientConfigClass.newInstance();通过反射获取DefaultClientConfigImpl实例，
通过config.loadProperties(name);加载name（当前为sample-client）为前缀的配置，然后替换默认配置。

    @Override
	public void loadProperties(String restClientName){
        enableDynamicProperties = true;
        setClientName(restClientName);
        loadDefaultValues();
        Configuration props = ConfigurationManager.getConfigInstance().subset(restClientName);
        for (Iterator<String> keys = props.getKeys(); keys.hasNext(); ){
            String key = keys.next();
            String prop = key;
            try {
                if (prop.startsWith(getNameSpace())){
                    prop = prop.substring(getNameSpace().length() + 1);
                }
                setPropertyInternal(prop, getStringValue(props, key));
            } catch (Exception ex) {
                throw new RuntimeException(String.format("Property %s is invalid", prop));
            }
        }
    }

Configuration props = ConfigurationManager.getConfigInstance().subset(restClientName);获取配置的子集，然后通过setPropertyInternal设置相应属性，
在这里插入图片描述
因为设置properties中设置sample-client.ribbon.listOfServers=localhost:6667,localhost:6668，通过上面的转换后，setPropertyInternal中prop = listOfServers，getStringValue为localhost:6667,localhost:6668，即sample-client的服务列表设置为localhost:6667,localhost:6668。到这里已经创建好了IClientConfig。

2.2.2创建IClient

通过registerClientFromProperties创建IClient.

 public static synchronized IClient<?, ?> registerClientFromProperties(String restClientName, IClientConfig clientConfig) throws ClientException { 
    	IClient<?, ?> client = null;
    	ILoadBalancer loadBalancer = null;
    	if (simpleClientMap.get(restClientName) != null) {
    		throw new ClientException(
    				ClientException.ErrorType.GENERAL,
    				"A Rest Client with this name is already registered. Please use a different name");
    	}
    	try {
    	    //1.获取RestCliet
    		String clientClassName = (String) clientConfig.getProperty(CommonClientConfigKey.ClientClassName);
    		//2.通过反射获取RestCliet实例，通过initWithNiwsConfig设置相关配置项
    		client = (IClient<?, ?>) instantiateInstanceWithClientConfig(clientClassName, clientConfig);
    		//3.通过反射创建负载均衡器
    		boolean initializeNFLoadBalancer = Boolean.parseBoolean(clientConfig.getProperty(
    				CommonClientConfigKey.InitializeNFLoadBalancer, DefaultClientConfigImpl.DEFAULT_ENABLE_LOADBALANCER).toString());
    		if (initializeNFLoadBalancer) {
    			loadBalancer  = registerNamedLoadBalancerFromclientConfig(restClientName, clientConfig);
    		}
    		if (client instanceof AbstractLoadBalancerAwareClient) {
    			((AbstractLoadBalancerAwareClient) client).setLoadBalancer(loadBalancer);
    		}
    	} catch (Throwable e) {
    		String message = "Unable to InitializeAndAssociateNFLoadBalancer set for RestClient:"
    				+ restClientName;
    		logger.warn(message, e);
    		throw new ClientException(ClientException.ErrorType.CONFIGURATION, 
    				message, e);
    	}
    	simpleClientMap.put(restClientName, client);
    	Monitors.registerObject("Client_" + restClientName, client);
    	logger.info("Client Registered:" + client.toString());
    	return client;
    }

通过client = (IClient<?, ?>) instantiateInstanceWithClientConfig(clientClassName, clientConfig);
创建restclient，

 @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        super.initWithNiwsConfig(clientConfig);
        this.ncc = clientConfig;
        this.restClientName = ncc.getClientName();
        this.isSecure = getBooleanFromConfig(ncc, CommonClientConfigKey.IsSecure, this.isSecure);
        this.isHostnameValidationRequired = getBooleanFromConfig(ncc, CommonClientConfigKey.IsHostnameValidationRequired, this.isHostnameValidationRequired);
        this.isClientAuthRequired = getBooleanFromConfig(ncc, CommonClientConfigKey.IsClientAuthRequired, this.isClientAuthRequired);
        this.bFollowRedirects = getBooleanFromConfig(ncc, CommonClientConfigKey.FollowRedirects, true);
        this.ignoreUserToken = getBooleanFromConfig(ncc, CommonClientConfigKey.IgnoreUserTokenInConnectionPoolForSecureClient, this.ignoreUserToken);

        this.config = new DefaultApacheHttpClient4Config();
        this.config.getProperties().put(
                ApacheHttpClient4Config.PROPERTY_CONNECT_TIMEOUT,
                Integer.parseInt(String.valueOf(ncc.getProperty(CommonClientConfigKey.ConnectTimeout))));
        this.config.getProperties().put(
                ApacheHttpClient4Config.PROPERTY_READ_TIMEOUT,
                Integer.parseInt(String.valueOf(ncc.getProperty(CommonClientConfigKey.ReadTimeout))));

        this.restClient = apacheHttpClientSpecificInitialization();
        this.setRetryHandler(new HttpClientLoadBalancerErrorHandler(ncc));
    }

最终的Client是apacheHttpClient。
创建负载均衡
loadBalancer = registerNamedLoadBalancerFromclientConfig(restClientName, clientConfig);
BaseLoadBalancer中

void initWithConfig(IClientConfig clientConfig, IRule rule, IPing ping) {
        //略。。。。
        // cross associate with each other
        // i.e. Rule,Ping meet your container LB
        // LB, these are your Ping and Rule guys ...
        setRule(rule);
        setPing(ping);
        setLoadBalancerStats(new LoadBalancerStats(clientName));
        rule.setLoadBalancer(this);
      //略。。。。

    }

这里引入是Ribbon的核心的几个接口，IRule，IPing等，这几个接口在后续结合Spring Cloud的来一起分析。
到这里整个Resclient就创建完成了。

执行

通过调用client.executeWithLoadBalancer(request);执行请求，Http请求过程中，会使用到上面介绍的LoadBalance，RetryHandler等。到这里Ribbon就执行完了。

源码地址

我很爱吃榴莲
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Ribbon执行流程
qq_43357821的博客
12-25 570
@LoadBalanced @Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @Qualifier public @interface LoadBalanced { } 是一个标志注解，标记RestTemplate后 @LoadBalanced public RestTemplate restTe
Ribbon的调用流程
qq_29860591的博客
10-08 492
Ribbon的调用流程 Ribbon在Netflix组件是非常重要的一个组件，在Zuul中使用Ribbon做负载均衡，以及Feign组件的结合等。在Spring Cloud 中，作为开发中，做的最多的可能是将RestTemplate和Ribbon相结合，你可能会这样写： @Bean @LoadBalanced public RestTemplate restTemplate(...
Ribbon 源码执行流程
Willdas博客
06-02 309
Ribbon 源码执行流程
Ribbon负载均衡工作流程、策略修改及饥饿加载
人生快意事，读的好书，觅得良友
10-17 502
Ribbon负载均衡工作流程、策略修改及饥饿加载
SpringCloud系列（二）Ribbon 负载均衡的原理及详细流程
Fug_Lee的博客
11-21 470
其实 Ribbon 负载均衡可以认为是一种策略，也可以说是某种规则，当消费者发起请求时，就会被负载均衡拦截器给拦截到，然后获取到请求中的 id，再按照某种规则选择某个服务，继而修改请求 url，再次发起请求，这时候才获取到提供者的服务；
计算机小数表示.温故知新.pdf
最新发布
12-22
计算机小数表示 计算机小数表示是一种在计算机中表示小数的方法，分为定点表示法和浮点表示法两种。定点表示法是指小数点的位置固定不变，而浮点表示法是指小数点的位置可以浮动。浮点表示法可以表示更大的数值范围...
温故知新中国文化网页模板
01-22
【温故知新中国文化网页模板】是一个以中国传统文化为主题的网页设计资源，旨在帮助设计师们创造出具有中国特色、富有文化底蕴的网站。这个模板集古典与现代设计元素于一体，将中国传统美学融入到网页界面中，使得...
数学：吃透课本温故知新.docx
10-14
第四，定期复习以减少遗忘。学习数学就像磨刀一样，需要经常性的练习和回顾。对于公式、定理和法则，要通过反复查看和应用，使其深植于心。这样不仅能够增强记忆，还能在应用中发现新的理解和见解。 最后，培养独立...
Spring温故知新六AOP向切面程
05-09
【Spring AOP 向切面编程详解】 ...通过代理模式和切面编程，我们可以更灵活地控制代码执行的流程，而不必在多个地方重复相同的逻辑。这在大型项目中尤为重要，因为它可以减少代码冗余，提高开发效率。
jsp,servlet,filter温故知新
03-28
JSP的本质是Servlet，由服务器负责解析并转换为Servlet执行。在JSP页面中，我们可以使用以下元素： 1. **脚本元素**：`<% %>` 用于编写Java代码，可以是声明、表达式或脚本块。 2. **指令元素**：如`<%@ page %>`, ...
ribbon-2.2.5.jar
02-21
ribbon-2.2.5.jar
十五.SpringCloud源码剖析-Ribbon工作流程
墨家巨子@俏如来
10-08 952
11111
疯狂SpringCloud微服务架构实战 (Ribbon -- 负载均衡)
伱糸淂忄
06-08 356
1. 负载均衡 负载均衡是分布式架构的重点，负载均衡机制决定着整个服务集群的性能与稳定。Eureka 服务实例可以进行集群部署，每个实例都均衡处理服务请求，那么这些请求是如何被分摊到各个服务实例中的呢~~~~ 2. Ribbon 简介 Ribbon 是 Netflix 下的负载均衡项目，它在集群中为各个客户端的通信提供了支持，它主要实现中间层应用程序的负载均衡。Ribbon 提供了以下特性： 负载均衡器，可以支持插拔式的负载均衡规则； 对多种协议提供支持，例如 HTTP...
自定义注解，忽略用户token
shixiansen6535的博客
01-02 1153
package com.len.core.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /**...
定时任务篇
weixin_52165531的博客
09-01 121
1.加注解：@IgnoreUserToken 定时任务是在服务于服务之间的调用，因此需要忽略用户权限问题 2.在api项目中配置路由，定时任务要调用到我们写的接口，所以将所有对外开放的接口放到api中，并配置路由地址 3.在定时任务里面写上handler，执行定时任务，在里面调用api的service调用推送方法。 注：定时任务一般是使用get请求，异步定时。 ...
[享学Ribbon] 二十四、Ribbon具有负载均衡能力的客户端：AbstractLoadBalancerAwareClient
架构师：通透，才能写出好代码！
03-22 2485
Ribbon不仅仅是负载均衡，负载均衡只是它的一个最核心、最出名的模块而已。在聊`ribbon-core`的时候我们知道它有个核心API是`IClient`，它表示发送一个请求得到一个响应，不规定发送方式、协议等。 因为Ribbon最核心的功能就是负载均衡，因此本文我们将了解到它这个具有负载均衡能力的客户端：`AbstractLoadBalancerAwareClient`，它所在的jar是：`ribbon-loadbalancer`。
Eureka 源码解析 —— Eureka-Client 初始化（一）之 EurekaInstanceConfig
天黑了
12-13 2790
摘要: 原创出处 http://www.iocoder.cn/Eureka/eureka-client-init-first/ 「芋道源码」欢迎转载，保留摘要，谢谢！本文主要基于 Eureka 1.8.X 版本 1. 概述 2. EurekaInstanceConfig 2.1 类关系图 2.2 配置属性 2.3 AbstractInstanceConfig 2.4 PropertiesInsta
Ribbon负载均衡机制及自定义规则
qq_36594703的博客
09-10 947
Spring Cloud Ribbon是一个基于HTTP 和TCP的客户端负载均衡工具，他基于NetflixRibbon实现。通过SpringCloud的封装，可以让我们轻松的将面向服务的Rest模板请求自动转换成客户端负载均衡的服务调用。 负载均衡是对系统的高可用、网络压力的环节和处理能力扩容的重要手段之一。我们常说的负载均衡都指的是服务端负载均衡，其中分为硬件负载均衡和软件负载均衡。硬件负载均...
Ribbon 框架简介及搭建（没有与SpringCloud整合，独立使用）
weixin_30740581的博客
10-18 288
Ribbon简介 1. 负载均衡框架，支持可插拔式的负载均衡规则 2. 支持多种协议，如HTTP、UDP等 3. 提供负载均衡客户端 Ribbon子模块 1. ribbon-core（ribbon的核心，主要包含负载均衡器、负载均衡接口、客户端接口、内置负载均衡实现API） 2. ribbon-eureka（为eureka客户端提供的客户端实现类） 3. ribbon-h...
SpringCloud系列(五)——Ribbon实现
Radom&7
04-14 518
上篇SpringCloud系列(四)——Ribbon负载均衡介绍了Ribbon负载均衡，都是理论性的东西，接下来用代码实现一下。 新建一个简单的Springboot项目——ribbon-service，然后编写一个方法，开启两个端口启动项目。 @RequestMapping(value = "/person", method = RequestMethod.GET, ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值