SpringCloud学习-Nacos服务注册与负载均衡调用

什么是Nacos?

an easy-to-use dynamic service discovery, configuration and service management platform for building cloud native applications
一个易于使用的动态服务发现、配置和服务管理平台，用于构建云本地应用程序

安装Nacos

因为 Nacos 是一个Springboot 程序（nacos-server.jar），因此必须有java环境

下载Nacos

Nacos 下载地址：https://github.com/alibaba/nacos/releases

启动

下载后，解压，进入bin目录，执行 startup.cmd（windows环境）
linux: sh startup.sh -m standalone

登录

启动后进入：http://localhost:8848/nacos 启动的时候，窗口也有打印

用户名：nacos 密码：nacos

登录Nacos

配置管理

发现什么都没有，那是因为还没有服务注册进来

Nacos 服务管理

服务注册与发现

新建两个 SpringCloud 工程，一个作为 服务提供者(nacos-provider 端口：8858) ，一个作为 服务消费者（nacos-consumer 端口：8859）

-- > 消费者 调用 提供者 的接口，返回给页面

创建工程

pom 依赖 两个工程的依赖一样

    <!--Springboot 版本信息-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>


    <!--SpringCloud版本信息-->
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR6</spring-cloud.version>
    </properties>

    <!--相关依赖-->
    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter</artifactId>
        </dependency>

        <!--nacos依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>0.9.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

服务配置

提供者application.yml 配置

server:
  port : 8858
spring:
  application:
    name: nacos-provider
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

消费者application.yml 配置

server:
  port: 8859
spring:
  application:
    name: nacos-consumer
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

启动类上开启客户端发现(两个工程一样配置)

@EnableDiscoveryClient

@SpringBootApplication
@EnableDiscoveryClient
public class NacosxxxApplication {

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

验证服务注册发现

服务列表
标识连上nacos的启动日志

能看到这行日志，那么就一定连上nacos了

服务调用

在 nacos-provider 工程添加一个接口

@RestController
public class NacosProviderController {

    @GetMapping("hello")
    public String hello(String people) {

        return "hello:" + people;
    }

}

在 nacos-consumer 工程也添加一个接口

@RestController
public class ConsumerController {

    @Resource
    private RestTemplate restTemplate;

    @GetMapping("hello")
    public String getHello(String name) {

        String url = "http://localhost:8858/hello?people=" + name;

        return restTemplate.getForObject(url, String.class);
    }
}

这里用到了 RestTemplate ，简单理解，就是spring 帮我们封装的一个 http 请求工具，但功能不止这一点

可以参考这篇文章了解下（百度上搜的大神的）：https://www.cnblogs.com/javazhiyin/p/9851775.html

将 RestTemplate 注入到 Spring 的Bean管理，作为单例使用，减小开销

@SpringBootApplication
@EnableDiscoveryClient
public class NacosConsumerApplication {

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

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

重启工程，在浏览器调用
http://localhost:8859/hello?name=world

此时会返回 hello:world

证明服务调用成功

进阶-负载均衡调用

现在想使用 nacos 提供者的应用名（在注册中心注册的应用名），作为 调用地址，如下：

    @GetMapping("hello")
    public String getHello(String name) {

//        String url = "http://localhost:8858/hello?people=" + name;
        String url = "http://nacos-provider/hello?people=" + name;
        
        return restTemplate.getForObject(url, String.class);
    }

在 NacosConsumerApplication 启动类里，RestTemplate 的 Bean 上加入 @LoadBalanced

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

重启后即可验证

不加 @LoadBalanced 会怎样？
报错呗
如下
java.net.UnknownHostException: nacos-provider
因为走到了不该走的地方

image.png

@LoadBalanced 的作用是什么？

启动 负载均衡

为什么有这能力呢？

先看看 RestTemplate 的定义

public class RestTemplate extends InterceptingHttpAccessor implements RestOperations {}

RestTemplate 的定义就是继承 InterceptingHttpAccessor

org.springframework.web.client.RestTemplate#doExecute
org.springframework.http.client.support.HttpAccessor#createRequest
org.springframework.http.client.support.InterceptingHttpAccessor#getRequestFactory

重点在这里

List<ClientHttpRequestInterceptor> interceptors = getInterceptors();

这个拦截器是在哪初始化的？
在InterceptingHttpAccessor类里，有下面这个方法

public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) {}

通过idea 能发现在这里进行了调用

org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration.LoadBalancerInterceptorConfig#restTemplateCustomizer

org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration

类定义

// 标识是一个配置类
@Configuration(proxyBeanMethods = false)
// 生效条件为 RestTemplate.class存在
@ConditionalOnClass(RestTemplate.class)
// 生效条件为 有实现 LoadBalancerClient 的 bean 存在
@ConditionalOnBean(LoadBalancerClient.class)
// 使 使用了 @EnableConfigurationProperties注解的类生效
// 我们使用RestTemplate可以不用管，看代码定义，应该是使用 RetryTemplate 才会生效
@EnableConfigurationProperties(LoadBalancerRetryProperties.class)
public class LoadBalancerAutoConfiguration {
}

这个类里，重要的有两处：

1.restTemplates 属性
    //注入当前IOC环境中所有被@LoadBalanced注解标注的RestTemplate实例对象
    @LoadBalanced
    @Autowired(required = false)
    private List<RestTemplate> restTemplates = Collections.emptyList();

在这里，我们就知道为什么需要在 实例化 RestTemplate 的时候，加入 @LoadBalanced 了

2.LoadBalancerInterceptorConfig
org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration.LoadBalancerInterceptorConfig

1.在这里创建了一个 LoadBalancerInterceptor（这个拦截器的作用主要就是在客户端发起请求时进行拦截，从而实现客户端负载均衡的能力）

2.RestTemplateCustomizer 方法内部给 每个 restTemplate （也就是被@LoadBalanced标记了的 RestTemplate ）设置了 拦截器
这一步也就是我们为什么能在这里获取到 拦截器的原因

org.springframework.http.client.support.InterceptingHttpAccessor#getRequestFactory

此时返回了 org.springframework.http.client.InterceptingClientHttpRequestFactory
再创建 InterceptingClientHttpRequest 对象


org.springframework.http.client.InterceptingClientHttpRequestFactory#createRequest

InterceptingClientHttpRequest 对象里封装了 interceptors ，作用是什么，后面来说

org.springframework.http.client.InterceptingClientHttpRequest#executeInternal

org.springframework.http.client.InterceptingClientHttpRequest#executeInternal

这里会构造一个带拦截器的 InterceptingRequestExecution 对象，他的作用是：
对请求进行拦截，实现负载均衡

org.springframework.http.client.InterceptingClientHttpRequest.InterceptingRequestExecution

org.springframework.http.client.InterceptingClientHttpRequest.InterceptingRequestExecution#execute
org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient

这里回答了前面 “InterceptingClientHttpRequest 对象里封装了 interceptors ，作用是什么，后面来说”

接着看：


org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient#execute
Server server = this.getServer(loadBalancer, hint);

在这里对进行的服务器转ip的操作，也就是实现负载均衡的地方

具体逻辑：
1.内部维护了一个 nextIndex （并发原子类）
使用一次则值+1，然后通过这个值与 modulo （服务提供者数量）进行取余
这是一种轮询负载解决方案，每个服务器执行的次数都会达到一致

    private final AtomicInteger nextIndex = new AtomicInteger();
取余

2.根据第一步返回的数字（可认为集合下标），就能从所有的服务提供者里获取要摇执行服务的提供者ip

选取服务提供者

debug看下结果：


健康的服务提供者

至此：我们通过 服务名 转换 为 ip 去调用服务，就完成了
后面的就是正常的通过 ip 去进行请求了

总结

学到了怎么通过Nacos实现服务注册
通过跟踪 RestTemplate 的请求过程，了解到了 负载均衡 的基本实现原理
还有更深层次的逻辑等着探索

路漫漫其修远兮

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

友情链接更多精彩内容