Java之SpringCloud Alibaba【一】【Nacos一篇文章精通系列】

一、微服务介绍

1、系统架构演变

随着互联网的发展，网站应用的规模也在不断的扩大，进而导致系统架构也在不断的进行变化。从互联网早起到现在，系统架构大体经历了下面几个过程:单体应用架构—>垂直应用架构—>分布式架构—>SOA架构—>微服务架构，当然还有悄然兴起的Service Mesh(服务网格化)。
接下来我们就来了解一下每种系统架构是什么样子的，以及各有什么优缺点。

1）单体应用架构

互联网早期，一般的网站应用流量较小，只需一个应用，将所有功能代码都部署在一起就可以，这样可以减少开发、部署和维护的成本。

比如说一个电商系统，里面会包含很多用户管理，商品管理，订单管理，物流管理等等很多模块我们会把它们做成一个web项目，然后部署到一台tomcat服务器上。

2）垂直应用架构

随着访问量的逐渐增大，单一应用只能依靠增加节点来应对，但是这时候会发现并不是所有的模块都会有比较大的访问量.还是以上面的电商为例子，用户访问量的增加可能影响的只是用户和订单模块，但是对消息模块
的影响就比较小.那么此时我们希望只多增加几个订单模块，而不增加消息模块. 此时单体应用就做不到了，垂直应用就应运而生了.所谓的垂直应用架构，就是将原来的一个应用拆成互不相干的几个应用，以提升效率。比如我们可以将上面电商的单体应用拆分成:

• 电商系统(用户管理商品管理订单管理)
• 后台系统(用户管理订单管理客户管理)
• CMS系统(广告管理营销管理)
  

这样拆分完毕之后，一旦用户访问量变大，只需要增加电商系统的节点就可以了，而无需增加后台和CMS的节点。
优点:

• 系统拆分实现了流量分担，解决了并发问题，而且可以针对不同模块进行优化和水扩展.
• 一个系统的问题不会影响到其他系统，提高容错率

缺点:

• 系统之间相互独立，无法进行相互调用。
• 系统之间相互独立，会有重复的开发任务

3）分布式

当垂直应用越来越多，重复的业务代码就会越来越多。

这时候，我们就思考可不可以将重复的优代码抽取出来，做成统一的业务层作为独立的服务，然后由前端控制层调用不同的业务层服务呢?这就产生了新的分布式系统架构。

它将把工程拆分成表现层和服务层两个部分，服务层中包含业务逻辑。

表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。

4）SOA架构

在分布式架构下，当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心对集群进行实时管理。此时，用于资源调度和治理中心(SOA Service Oriented Architecture)是关健。

优点:

• 使用治理中心(ESBldubbo)解决了服务间调用关系的自动调节

缺点:

• 服务间会有依赖关系，一旦某个环节出错会影响较大(服务雪崩)
• 服务关系复杂，运维、测试部署困难

5）微服务框架

微服务架构在某种程度上是面向服务的架构SOA继续发展的下一步，它更加强调服务的"彻底拆分"。

微服务架构与SOA架构的不同
微伤务架的比 SOA架的粒度会更加情细，让专业的人去做专业的事情(专注)，目的提高效率，每个服务于服务之间互不影响，微服务架构中，每个服务必须独立部署，微服务架构更加轻巧，轻量级SOA架构中可能数据库存储会发生共享，微服务强调独每个服务都是单独数据库，保证每个服务于服务之间互不影响.项目体现特征微服务架构比SOA架构更加适合与互联网公司敏捷开发、快速迭代版本，因为粒度非常精细。

优点：

• 服务原子化拆分、独立打包、部署和升级、保证每个微服务清晰的任务划分、利于扩展
• 微服务之间采用Restful等轻量级http协议相互调用

缺点:

• 分布式系统开发的技术成本高（容错、分布式事务等)
• 复杂性更高。各个微服务进行分布式独立部署，当进行模块调用的时候，分布式将会变得更加麻烦。

他说微服务其实是一种架构风格，我们在开发一个应用的时候这个应用应该是由一组小型服务组成，每个小型服务都运行在自己的进程内;小服务之间通过HTP的方式进行互联互通。


微服务架构常见的问题

一旦采用微服务系统架构，就势必会遇到这样几个问题：

• 这么多小服务，如何管理他们？(服务治理 注册中心[服务注册 发现 剔除]) 【nacos】
• 这么多小服务，他们之间如何通讯？【restful rpc dubbo feign】
• 这么多小服务，客户端怎么访问他们？(网关) 【gateway】
• 这么多小服务，一旦出现问题了，应该如何自处理？(容错) 【sentinel】
• 这么多小服务，一旦出现问题了，应该如何排错? (链路追踪) 【skywalking】

对于上面的问题，是任何一个微服务设计者都不能绕过去的，因此大部分的微服务产品都针对每一
个问题提供了相应的组件来解决它们。

6）常见微服务架构

1.dubbo: zookeeper +dubbo + SpringMVC/SpringBoot

• 配套通信方式: rpc
• 注册中心:zookeeper / redis·配置中心: diamond

2.SpringCloud:全家桶+轻松嵌入第三方组件(Netflix)

• 配套通信方式: http restful
• 注册中心: eruka / consul
• 配置中心: config
• 断路器: hystrix·网关:zuul
• 分布式追踪系统: sleuth + zipkin

3.SpringCloud Alibaba

• Spring Cloud以微服务为核心的分布式系统构建标准

分布式系统中的常见模式给了Sping Cloud一个清浙的定位，即"模式"，也就是说 Sping Cloud是针对分布式系统开发所做的通用抽象，是标准摸式的实现。

这个定义非常抽象，看完之后并不能知E道Sping Cloud具体包含什么内容。

再来看一下 Spring官方给出的一个High Light的架构图，就可以对这套模式有更清晰的认识:

可以看到这个图中间就是各个 Micvsevce，也就是我们的这个微服务的实现，周边周围的话就是去国绦这个微服务来去做各种辅助的信息事情。

我们如分布式追踪、服务注册、配置服务等，都络微服务运行时所依硕的必不可少的的支持性功能。

我们可以得出这样一个结论: Spring Cloud是以微服务为核心的分布式系统的一个构建标准。

2、SpringCloud Alibaba介绍

Sping Cou Aliaba致力于提供微服务开发的一站式解决方案。此项目包含开发微服务架构的必需组件，方便开发者通过Spring Cloud编程模型轻松使用这些组件来开发微服务架构。

依托Spring Clou Altaba，您只需要添加一些注解和少量配置，就可以将Spring Cloud 应用接入阿里分布式应用解决方案，通过阿里中间件来迅速搭建分布式应用系统。

根据.Jakarta2019年的调研很告，SpingBoot拥有非常高的占比。熟悉 Jva语言的同学，应该对Sping框架都不会陌生。其倡导的依赖倒置、面向切面编程等特性已经形成了Java语言的事实标准，几乎所有三
方框架都会提供对Spring框架的支持。

Spring Based Framework 已经成为Java语言下的事实标准Architectures for implementing Java systems in the cloud:

• Spring Based Framework已经成为Java语言下的事实标准
• 也是构建微服务的首选框架

3、SpringCloud Alibaba定位

既然说 Sping Cloud是标准，那么自然少不了针对标准的实现。这里，为大家介绍下Spring Cloud Aibab a这套实现。先给出下面这张图帮助大家理解Sping Cloud Alitaba的定位:

这里给大家这么一个公式，这个叫做：“3 加 2”。
3 指的就是图中深色的部分，其实它就是 Spring Cloud 标准，一共有 3 层。中间颜色最深的部分就是及整个微服务最核心的内容，包括了“ RPC 调用”以及“服务注册与发现”。第二层，也就是围绕着核心的这一圈，是一些辅助微服务更好的工作功能，包括了负载均衡、路由、网关、断路器，还有就是追踪等等这些内容。再外层的话，主要是一些分布式云环境里通用能力。

“3 加 2”中的“2”，指的就是上图中最外面这一圈。这一部分就是这个我们 Spring Cloud Alibaba 的一个定义，它其实包含两个部分的内容：

右上部分是对于 Spring Cloud 标准的实现。

例如，我们通过 Dubbo 实现了 RPC 调用功能，通过 Nacos 实现了“服务注册与发现”、“分布式配
置”，通过 Sentinel 实现了断路器等等，这里就不一一列举了。

左下部分是我们 Spring Cloud Alibaba 对阿里云各种服务的集成。可能很多同学会有这样的一个问题：为什么要加上这一部分呢？此时回头审视一下 Spring Cloud ，它仅仅是一个微服务的一个框架。但是在实际生产过程中，单独使用微服务框架其实并不足以支撑我们去构建一个完整的系统。

所以这部分是用阿里帮助开发者完成微服务以外的云产品集成的功能。

这里可能会很多同学会有这么一个担心：是不是使用了 Spring Cloud Alibaba，就会被阿里云平台绑定呢？在此，我们明确的告诉大家，这是不会的。

为什么这么说呢？如上面说的，“3 加 2”中的 2 是被分为两个部分的。其中对 Spring Cloud 的实现是完全独立的，开发者可以只是用这部分实现运行在任何云平台中。

当然，另一部分，由于天然是对阿里云服务的集成，这部分是和平台相关的。这里给开发者充分的自由，选择只是用其中的部分还是全部产品。

当然，我们也非常欢迎开发者选择使用阿里云的全套服务，我们也会尽量保证使用整套产品时的连贯性与开发的便利性。

4、SpringCloud 各套实现对比

Spring Cloud 作为一套标准，它的实现肯定不止一套，那么各套实现都有什么区别呢？我们来一起看一下下面这张图：

可以发现Spring Cloud Alibaba是所有的实现方案中功能最齐全的。尤其是在Netlix停止更新了以后，Spring Cloud Alibaba依然在持续更新和迭代。


从18年7月份Sning Cloud Aitaba 正式提交代码开始，就得到了大家广泛的关注。截止今天，Spring Coud Alitaba一共获得了超过了15万的 sta 数，已经的领先于所有其他实现的总和根据今年X-lab开放实验室刚刚发布的《2020年微服务领域开源数字化报告》，Spring Cloud Alibaba已经成为最活跃Spring Cloud实现。

数据来源《2020年微服务领域开源数字化报告》，公众号后台回复关键词“微服务报告"获取报告全文。

5、SpringCloud 各套实现对比

可以看到除了围绕着 Spring Cloud 的标准实现以外，还有包括的数据、资源、消息、缓存等各种类型的服务。在不同类型的服务下，也有很多具体的产品可供用户选择。

这里罗列典型而非全部产品。更多的内容，可以参考阿里云官网

6、Spring Cloud Alibaba 用户数

截止到今天，Spring Cloud Alibaba 获得了数超过 1.5w 的 star 数。

同时在 Github 上的项目依赖，就是对 Spring Cloud Alibaba 产生依赖关系的产品，也超过了 6000。

最重要的，使用 Spring Cloud Alibaba 的公司超过 1000 家。当然不只是外部的公司在使用，阿里内部也在使用。

经过了双十一的洗礼，其实整个这套框架它的这个稳定性可靠性都得到了印证。

二、基本分布式架构搭建

1、基于SpringBoot的父maven项目

删除对应的src

2、创建订单项目模块

• 创建订单项目
  
  
  完善依赖
  

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

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

package com.itbluebox.order.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/order")
public class OrderController {
    
    

    @RequestMapping("/add")
    public String add(){
    
    
        System.out.println("下单成功");
        return "Hello world";
    }

}

3、创建库存服务模块

@RestController
@RequestMapping("/stock")
public class StockController {
    
    
    @RequestMapping("/reduct")
    public String reduct(){
    
    
        System.out.println("扣减库存");
        return "扣减库存";
    }
}

4、创建订单项目模块的启动类

@SpringBootApplication
public class OrderApplication {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(OrderApplication.class);
    }
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder){
    
    
        RestTemplate restTemplate = builder.build();
        return restTemplate;
    }
}

5、创建库存项目模块的启动类

6、完善项目配置文件

server:
  port: 8011

server:
  port: 8010

7、启动项目

IDEA 打开Run Dashboard

浏览器访问：http://localhost:8010/order/add

三、SpringCloud Alibaba环境搭建

1、SpringCloud Alibaba 依赖 Java 环境来运行。还需要为此配置 Maven环境，请确保是在以下版本环境中安装使用:

1. 64 bit JDK 1.8+；下载 & 配置。 1.8.0_131
2. Maven 3.2.x+；下载 & 配置。 3.6.1
   浏览器打开下面的接口
   https://start.spring.io/actuator/info
   
   我们可以看到不同的SpringBoot版本对应的版本是多少

我们打开github的spring-cloud-alibaba
https://github.com/alibaba/spring-cloud-alibaba

现在我们要确认一下SpringBoot的版本

Spring Cloud Alibaba：Spring Cloud Alibaba 2.2.5.RELEASE
Spring Boot：Spring Boot 2.3.2.RELEASE
Spring Cloud：Hoxton.SR8

2、完善项目的版本

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <modules>
        <module>order</module>
        <module>stock</module>
    </modules>

    <groupId>com.itbluebox.springcloud</groupId>
    <artifactId>springcloudalibaba</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springcloudalibaba</name>
    <description>springcloudalibaba</description>
    <packaging>pom</packaging>

    <properties>
        <java.version>1.8</java.version>
        <spring.cloud.alibaba.version>2.2.5.RELEASE</spring.cloud.alibaba.version>
        <spring.boot.version>2.3.11.RELEASE</spring.boot.version>
        <spring.cloud.version>Hoxton.SR8</spring.cloud.version>
    </properties>

    <dependencies>
        <!--SpringBoot基本场景启动-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--SpringBoot 测试的场景启动-->
        <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>

    <dependencyManagement>
        <!--Spring Cloud alibaba的版本管理， 通过dependency完成继承-->
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring.cloud.alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--SpringBoot的版本管理-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--Spring Cloud的版本管理-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3、通过阿里云的脚手架快速搭建项目（尝试）

https://start.aliyun.com/bootstrap.html

直接在上述的页面当中选择对应内容就可以快速创建对应的内容
也可以通过IDEA集成的方式使用

输入以下内容
https://start.aliyun.com/



项目创建成功

四、Alibaba微服务组件Nacos注册中心

1、什么是Nacos

官方:一个更易于构建云原生应用的动态服务发现(Nacos Discovery )、服务配置(Nacos Config)和服务管理平台。

官网：https://nacos.io/zh-cn/index.html
集 注册中心+配置中心+服务管理 平台

Nacos的关键特性包括:

• 服务发现和服务健康监测
• 动态配置服务
• 动态DNS服务
• 服务及其元数据管理

2、Nacos注册中心

1）注册中心演变及其设计思想

2）核心功能

Nacos Discovery官网

服务注册发现：Nacos Client会通过发送REST请求的方式向Nacos Server注册自己的服务，提供自身的元数据，比如ip地址、端口等信息。

Nacos Server接收到注册请求后，就会把这些元数据信息存储在一个双层的内存Map中。

服务心跳：在服务注册后，Nacos Client会维护一个定时心跳来持续通知Nacos Server，说明服务一直处于可用状态，防止被剔除。

默认5s发送一次心跳。

服务同步：Nacos Server集群之间会互相同步服务实例，用来保证服务信息的一致性。

leader raft

服务发现：服务消费者（Nacos Client）在调用服务提供者的服务时，会发送一个REST请求给Nacos Server，获取上面注册的服务清单，并且缓存在Nacos Client本地，同时会在Nacos Client本地开启一个定时任务定时拉取服务端最新的注册表信息更新到本地缓存服务

健康检查：Nacos Server会开启一个定时任务用来检查注册服务实例的健康情况，对于超过15s没有收到客户端心跳的实例会将它的healthy属性置为false(客户端服务发现时不会发现)，如果某个实例超过30秒没有收到心跳，直接剔除该实例(被剔除的实例如果恢复发送心跳则会重新注册)

主流的注册中心
CAP C 一致性 A可用性 P 分区容错性

3、Nacos Server部署和启动

下载源码编译
源码下载地址: https://github.com/alibaba/nacos/可以用

下载解压，因为在本地环境所以需要设置启动模式为但是，因为默认启动模式是集群

修改\nacos\bin下的startup.cmd

set MODE="standalone"

查看\nacos\conf\application.properties
这里是配置访问地址和端口号

这里是在集群环境下需要配置持久化存储mysql的地址

默认情况下，使用的是内存作为存储的

双击启动

启动成功

访问Nacos
http://192.168.1.5:8848/nacos/index.html

用户名：nacos
密码：nacos

4、搭建Nacos-client服务

1）创建Nacos客户端

复制order和stock



修改并完善对应的pom文件

<artifactId>order-nacos</artifactId>

<module>order</module>
        <module>order-nacos</module>
        <module>stock</module>
        <module>stock-nacos</module>

刷新一下maven

颜色变了添加成功

2）添加nacos服务注册发现的依赖

<!--nacos服务注册发现-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

<!--nacos服务注册发现-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

3）设置上述对应的application.yml

server:
  port: 8020
  # 应用名称 (nacos会将该名称当做服务名称)
spring:
  application:
    name: order-service
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848
      discovery:
        username: nacos
        password: nacos
        namespace: public

server:
  port: 8021
  # 应用名称 (nacos会将该名称当做服务名称) stock-nacos
spring:
  application:
    name: stock-service
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848
      discovery:
        username: nacos
        password: nacos
        namespace: public

4）配置nacos客户端相关内容

@EnableDiscoveryClient可以加也可以不加

package com.itbluebox.order;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
//@EnableDiscoveryClient
public class OrderApplication {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(OrderApplication.class);
    }
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder){
    
    
        RestTemplate restTemplate = builder.build();
        return restTemplate;
    }
}

5）启动对应刚刚添加的两个客户端

打开nacos的服务列表

查看到两个服务被注册

点击详情可以查看到对应的状态

我们将stock服务停止


服务列表当中的stock也就停止了


20秒以后

5、在order-nacos当中通过服务名称调用stock-nacos

@RequestMapping("/add")
    public String add(){
    
    
        System.out.println("下单成功");
        String msg = restTemplate.getForObject("http://stock-service/stock/reduct", String.class);
        return "Hello world"+msg;
    }

我们重新启动运行两个项目


http://localhost:8020/order/add

抛出异常（我们没有添加负载均衡器）

需要添加负载均衡器的注解

 @Bean
    @LoadBalanced
    public RestTemplate restTemplate(RestTemplateBuilder builder){
    
    
        RestTemplate restTemplate = builder.build();
        return restTemplate;
    }

再次访问:http://localhost:8020/order/add

6、演示nacos的负载均衡

@RestController
@RequestMapping("/stock")
public class StockController {
    
    

    @Value("${server.port}")
    String port;

    @RequestMapping("/reduct")
    public String reduct(){
    
    
        System.out.println("扣减库存");
        return "扣减库存："+port;
    }

}

server:
  port: 8022
  # 应用名称 (nacos会将该名称当做服务名称) stock-nacos
spring:
  application:
    name: stock-service
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848
      discovery:
        username: nacos
        password: nacos
        namespace: public

现在启动了两个Stock

我们访问：http://localhost:8020/order/add

刷新页面

上述每次刷新页面返回的结果都是不一样的，实现了负载均衡

7、yml的其他配置项

server:
  port: 8022
  # 应用名称 (nacos会将该名称当做服务名称) stock-nacos
spring:
  application:
    name: stock-service
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848
      discovery:
        username: nacos
        password: nacos
        # namespace: public # 相同特征的服务进行归类分组管理
        #ephemeral: true  #永久实例  默认=true（临时实例）当服务宕机 超过心跳 就会将服务剔除掉
        #ephemeral: false 永久实例当前实例即使挂掉，也依旧存在该实例，不会在20-30秒以后挂掉
        #service：默认读取${spring.application.name}，也可以通过该选项配置
        #group：默认 DEFAULT_GROUP 更细的相同特征的服务进行归类分组管理
        #weight：通常要结合 安装 权重的负载均衡策略，权重越高分配的流量越大
        #metadata : version = 1 #可以结合元数据做扩展

五、Nacos管理界面详细介绍

1、新建命名空间

服务列表可以进行分割管理

我们在对应的配置文件当中就可以设置不同的命名空间

在 Nacos 中，命名空间（Namespace）是一个逻辑上的隔离单位，它将服务和配置信息划分为不同的组。不同命名空间之间具有完全的隔离性，每个命名空间都拥有自己的服务注册表、配置数据和访问权限。

通过将服务和配置信息划分到不同的命名空间中，可以实现以下几个作用：

1、逻辑隔离：不同命名空间之间的服务和配置信息相互隔离，可以将不同业务领域、不同环境（如开发、测试、生产）的服务和配置进行有效分离。这样可以确保不同命名空间中的服务不会相互干扰，提高系统的稳定性和安全性。

2、权限控制：每个命名空间可以配置自己的访问权限，只有具有相应权限的用户或服务可以访问该命名空间中的服务和配置信息。这样可以实现对不同团队或不同角色的访问进行精细化的控制，提高系统的安全性。

3、灰度发布：通过在不同命名空间中部署不同版本的服务，可以实现灰度发布的功能。例如，可以将新版本的服务部署到一个命名空间中进行测试和验证，待验证通过后再将其发布到其他命名空间中，逐步推广到整个系统。这样可以有效降低发布新版本的风险，提高系统的可靠性和稳定性。

2、服务列表当中创建不同的服务

删除对应的内容


**填写服务信息：**在创建服务的界面，填写以下必要的信息：

1、服务名（Service Name）：为服务指定一个唯一的名称。
2、集群名称（Cluster Name）：指定服务所属的集群名称，通常使用默认值即可。
3、IP 地址（IP）：填写服务的 IP 地址。
4、端口（Port）：填写服务的端口号。
5、命名空间（Namespace）：选择服务所属的命名空间。
6、健康检查地址（Health Check URL）：填写服务的健康检查地址，用于检查服务的健康状态。
可以根据需要，填写其他可选信息，如权重、元数据等。

**保存服务：**填写完服务信息后，点击 “保存” 按钮，完成服务的创建。

创建服务后，它将显示在服务列表中，并可通过 Nacos 进行服务的注册和发现。

你可以在服务列表页面对服务进行管理，如编辑服务信息、删除服务、查看服务的实例列表等。

3、查看详情

1、服务名（Service Name）：服务名是在 Nacos 中唯一标识服务的名称。它用于在服务列表中区分不同的服务，使其能够被其他服务或客户端进行服务注册和发现。

2、分组（Group）：分组是对服务进行逻辑上的分类和组织。通过将服务划分到不同的分组中，可以更好地管理和组织服务，使其更易于查找和维护。在 Nacos 中，分组的设置可以帮助实现服务的逻辑隔离和权限控制。（命名空间是比分组更大的分类方式，分组更加细的分类方式）

3、保护阈值（Protect Threshold）：保护阈值是与服务实例相关的保护机制。当服务实例的健康状态或可用性低于保护阈值时，Nacos 将不会将请求路由到该实例。这是为了保护系统的稳定性，避免将请求发送到不健康或不可用的服务实例，从而减少系统故障的风险。（雪崩保护）
雪崩保护：


重新启动两个Stock

• 保护阈值 设置 0-1之间的值，例如可以设置0.5

• 临时阈值 spring.cloud.nacos.discovery.ephemeral: false，当服务宕机了也不会从服务列表当中剔除
  

• 永久阈值 spring.cloud.nacos.discovery.ephemeral: true，当服务宕机了也不会从服务列表当中剔除
  
  
  这里我们强制8022端口对应的服务停止运行
  
  对应的服务状态依旧存在。
  
  如果设置保护阈值
  健康实例/总实例数 < 保护阈值（依旧会把不健康的服务提供给服务，预防高峰期间的并发）
  1/2 < 0.6

• 权重：权重越大给微服务分配的权重就越大
  
  对应设置服务下线就不会调用了
  
  
  启动项目
  
  保证所有的服务都是上线并且健康状态
  

4、元数据（Metadata）：元数据是与服务实例关联的额外信息。它可以存储与实例相关的任何自定义信息，如版本号、环境标识、扩展配置等。通过元数据，可以为每个服务实例提供更多的描述性信息，帮助进行更精细化的服务管理和调度。



访问：http://localhost:8020/order/add

我们停止运行8022端口

再次访问：http://localhost:8020/order/add


我们让8021下线

我们再次访问：http://localhost:8020/order/add

刷新页面

5、服务路由类型（Service Routing Type）：根据你的提问，没有提供服务路由类型的信息。
服务路由类型是用于描述服务实例的路由策略，它决定了请求将如何被路由到不同的服务实例。
例如，随机路由将请求随机分发到可用的实例，轮询路由按照轮询顺序依次分发请求。
服务路由类型可以根据系统的需求进行配置，以实现负载均衡和流量控制等功能。

6、集群（Cluster）：集群用于标识服务所属的不同实例集合。
在 Nacos 中，可以为同一个服务创建多个集群，每个集群可以包含相同或不同的服务实例。
通过将服务部署到不同的集群中，可以实现高可用性和负载均衡的策略。
在提供服务时，Nacos 可以根据集群的配置选择合适的实例进行路由。

7、元数据过滤（Metadata Filter）：元数据过滤功能用于在服务列表中根据元数据进行过滤和筛选服务。通过指定特定的元数据键值对，可以仅获取包含特定元数据的服务。这对于按照自定义的标签或属性对服务进行分类、查询和选择非常有用。元数据过滤功能可以帮助用户根据实际需求快速定位和筛选出符合条件的服务。

4、订阅者列表

对应的两个Java的服务进程

netstat -aon|findstr "55829"

5、权限控制

用户管理，角色管理，权限管理
修改密码，新建用户

6、集群管理

节点列表

六、Nacos集群环境部署

https://nacos.io/zh-cn/docs/cluster-mode-quick-start.html

1、预备环境准备

请确保是在环境中安装使用:
1、64 bit OS Linux/Unix/Mac，推荐使用Linux系统。
2、64 bit JDK 1.8+；下载.配置。
3、Maven 3.2.x+；下载.配置。
4、3个或3个以上Nacos节点才能构成集群。

2、下载源码或者安装包

你可以通过两种方式来获取 Nacos。
从 Github 上下载源码方式
在Linux Centos7当中

cd /usr/local/

mkdir nacos

cd nacos/

wget https://github.com/alibaba/nacos/releases/download/1.4.1/nacos-server-1.4.1.tar.gz

等待下载完成

tar -zxvf nacos-server-1.4.1.tar.gz

得到

3、单机搭建伪集群

1）单机搭建伪集群，复制nacos安装包，修改为nacos8849,nacos8850，nacos8851

mv nacos nacos8849

cp -r nacos8849 nacos8850

cp -r nacos8849 nacos8851

2）以nacos8849为例，进入nacos8849目录

cd nacos8849

cd conf

2.1 修改conflapplication.properties的配置，使用外置数据源要使用mysql5.7+

vim application.properties

#使用外置mysql数据源
spring.datasource.platform=mysql
###Count of DB:
db.num=1
###Connect URL of DB :
db.url.O=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout-1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&usesSL=false&serverTimezone=UTC
db.user.O=root
db.password . 0=root

在这里执行我们下载好的nacos包当中对应的SQL文件

执行nacos-mysql.sql

2.1 将conflcluster.conf.example改为cluster.conf、添加节点配置

cp cluster.conf.example cluster.conf

cd ../bin/

vim startup.sh

JAVA_OPT="${JAVA_OPT} -server -Xms521m -Xms512m -Xmn256m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"

启动nacos8849

[root@localhost bin]# ./startup.sh

tail -f ../logs/start.out

3、单机搭建伪集群

cd /usr/local/nacos

cp ./nacos8849/conf/application.properties ./nacos8850/conf/application.properties

cp ./nacos8849/conf/application.properties ./nacos8851/conf/application.properties

cp ./nacos8849/conf/cluster.conf ./nacos8850/conf/cluster.conf

cp ./nacos8849/conf/cluster.conf ./nacos8851/conf/cluster.conf

cp ./nacos8849/bin/startup.sh ./nacos8850/bin/startup.sh

cp ./nacos8849/bin/startup.sh ./nacos8851/bin/startup.sh

vim ./nacos8850/conf/application.properties

vim ./nacos8851/conf/application.properties

然后分别启动8850和8851

sh ./nacos8850/bin/startup.sh

sh ./nacos8851/bin/startup.sh

分别访问对应的nacos访问，查看自己Linux订单IP地址

http://192.168.180.128:8850/nacos/index.html#/login

http://192.168.180.128:8851/nacos/index.html#/login

http://192.168.180.128:8849/nacos/index.html#/login

4、安装nginx

http://nginx.org/en/download.html

下载完上传到Linux当中

tar -zxvf nginx-1.24.0.tar.gz

cd /usr/local/nginx-1.24.0

./configure

make

make install

vim /usr/local/nginx/conf/nginx.conf

upstream nacoscluster {
    
    
	server 127.0.0.1:8850;
	server 127.0.0.1:8849;
	server 127.0.0.1:8851;
}
server {
    
    
	listen	8847;
	server_name localhost;
	
	location /nacos/ {
    
    
		proxy_pass http://nacoscluster/nacos/;
	}
}

启动nginx

cd /usr/local/nginx/sbin/

./nginx

访问：http://192.168.180.128:8847/nacos/index.html#/login

5、修改微服务项目当中的yml

src/main/resources/application.yml

server-addr: 192.168.180.128:8847

src/main/resources/application.yml

server-addr: 192.168.180.128:8847

安装之前的方式启动相关的微服务

http://192.168.180.128:8847/nacos/index.html#/serviceManagement?dataId=&group=&appName=&namespace=

https://nacos.io/zh-cn/docs/quick-start-docker.html

七、微服务负载均衡器Ribbon

1、什么是Ribbon

目前主流的负载方案分为以下两种:

• 集中式负载均衡，在消费者和服务提供方中间使用独立的代理方式进行负载，有硬件的(比如F5)，也有软件的(比如Nginx).。客户端根据自己的请求情况做负载均衡，Ribbon就属于客户端自己做负载均衡。
  SpringCloud Ribbon是基于Netflix Ribbon实现的一套客户觉的负载均工具，Ribbon客户式组件提供一系列的完善的配置，如超时，重试等。通过Load Balancer获取到服务提供的所有机器实例，R
  ibbon会自动基于某种规则
  (轮询，随机)去调用这些服务。Ribbon也可以实现我们自己的负载均衡算法。

1）客户端的负载均衡

你i 如SpringCloud 中的Ribbon，客户端会有一个服务器地址列表，在发送清求前通过负载均衡算法选择一个服务器，然后进行方问，这是客户端负载均衡;即在客户端就进行负载均衡算法分配

2）服务端的负载均衡

仍例如Nginx，通过Nginx进行负载均衡，先发送请求，然后通过负载均衡算法，在多个服务器之间选择一个进行访问;即在服务器端再进行负载均衡算法分配。

3）常见的负载均衡算法

• 随机，通过随机选择服务进行执行，一般这种方式使用较少;
• 轮训，负载均衡默认实现方式，请求来之后排队处理;
• 加权轮训，通过对服务器性能的分型，给高配置，低负载的服务器分配更高的权重，均衡各个服务器的压力;
• 地址Hash，通过客户端请求的地址的HASH值取模映射进行服务器调度。ip —>hash
• 最小链接数，即使请求均衡了，压力不一定会均衡，最小连接数法就是根据服务器的情况，比如I请求积压数等参数，将请求分配到当前压力最小的服务器上。最小活跃数

2、Nacos使用Ribbon

nacos-discovery依赖了Ribbon，可以不用再引入Ribbon依赖

3、Ribbon负载均衡策略

IRule
这是所有负载均衡策略的父接口，里边的核心方法就是choose方法，用来选择一个服务实例。
AbstractLoadBalancerRule
AbstractLoadBalancerRule是一个抽象类，里边主要定义了一个ILoadBalancer，就是我们上文所说的负载均衡器，负载均衡器的功能我们在上文已经说的很详细了，这里
就不再赘述，这里定义它的目的主要是辅助负责均衡策略选取合适的服务端实例。

• RandomRule
  看名字就知道，这种负载均衡策路就是随机选择一个服务实例，看源码我们知道，在RandomRule的无参构造方法中初始化了一个Random对象，然后在它重写的choose方法又调用了choose(LoadBalancer lb, Object key)这个重载的choose方法，在这个重载的choose方法中，每次利用random对象生成一个不大于服务实例总数的随机数，并将该数作为下标所以获取一个服务实例。

• RoundRobinRule
  RoundRobinRule这种负载均衡策略叫做线性轮询负载均衡策略。这个类的choose(ILoadBalancer lb, Object key)函数整体逻辑是这样的:开启一个计数器count，在while循环中遍历服务清单，获取清单之前先通过incrementAndGetNodulo方法获取一个下标，这个下标是一个不断自增长的数先加1然后和服务清单总数取模之后获取到的(所以这个下标从来不会越界)，拿着下标再去服务清单列表中取服务，每次循环计数器都会加1，如果连续10次都没有取到服务，则会报一个警告No availble alive servers after 10 trie from load bal:ancer: XXXX。

• RetryRule(在轮询的基础上进行重试)
  看名字就知道这种负载均衡策略带有重试功能。首先RetryRule中又定义了一个subRule，它的实现类是RoundRabinRule，然后在RetryRule的choose(LoadBalancerlb,Object key)方法
  中，每次还是采用RoundRobinRule中的choose规则来选择一个服务实例，如果选到的实例正常就返回，如果选择的服务实例为nul或者已经失效，则在失效时间deadlinee之前不断的进行重试
  (重试时获取服务的策略还是RoundRobinRule中定义的策略)，如果超过了deadline还是没取到则会返回一个null。

• WeightedResponseTimeRule(权重一nacos的NacosRule，Nacos还扩展了一个自己的基于配置的权重扩展)WeightedResponseTimeRule是RoundRobinRule的一个子类，在WeightedResponseTimeRule中对RoundRobinRule的功能进行了扩展，WeightedResponseTimeRule中会根据每一个实例的运行情况来给计算出该实例的一个权重，然后在挑选实例的时候则根据权重进行挑选，这样能够实现更优的实例调用。WeightedResponseTimeRule中有一个名叫
  DynamicServerlWleightTrask的定时任务，默认情况下每隔30秒会计算一次各个服务实例的权重，权重的计算规则也很简单，如果一个服务的平均响应时间越短则权重越大,那么该服务实例被选中执行任务的概率也就越大。

• ClientConfigEnabledRoundRobinRule
  ClientConfigEnabledRoundRobinRule选择策略的实现很简单，内部定义了RoundRobinRule, choose方法还是采用了RoundRobinRule的choose方法，所以它的选择策略和RoundRobinRule的选择策略一致，不赘述。

• BestAvailableRule
  BestAvailableRule继承自ClientConfigEnabledRoundRobinRule，它在ClientConfigEnabledRoundRobinRule的基础上主要增加了根据(oadBalancerStats中保存
  的服务实例的状态信息来过滤掉失效的服务实例的功能，然后顺便找出并发请求最小的服务实例来使用。然而loadBalancerStats有可能为null，如果loadBalancerStats为null，则BestAvailableRule将采用它的父类即ClientConfigEnabledRoundRobinRule的服务选取策略（线性轮询)。

• ZoneAvoidanceRule(默认规则，复合判断server所在区域的性能和server的可用性选择服务器。)ZoneAvoidanceRule是PredicateBasedRule的一个实现类，只不过这里多一个过滤条件ZoneAvoidanceRule中的过滤条件是以ZoneAvoidancePredicate为主过滤条件和以。

• AvaiailtyPredicate为次过滤条件组成的一个叫做CompositePredicate的组合过滤条件，过滤成功之后，继续采用线性轮询(RoundRobinRule)的方式从过游结果中
  选择一个出来。

• AvailabilityFilteringRule (先过滤掉故障实例，再选择并发较小的实例)
  过滤掉一直连接失败的被标记为crcuittriped的后端Sever，并过滤掉那些高并发的后端Server或者使用一个AvailabilityPredicate来包含过滤sever的逻辑，其实就是检查status里记录的各个Server的运行状态。

4、修改默认负载均衡策略

全局配置：调用其他微服务，一律使用指定的负载均衡算法

1）配置类

复制之前的order-nacos修改为

<artifactId>order-ribbon</artifactId>

     <module>order-ribbon</module>

package com.itbluebox.ribbon;

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

@Configuration
public class RibbonRandomRuleConfig {
    
    

    //方法名一定要叫iRule
    @Bean
    public IRule iRule(){
    
    
        return new RandomRule();
    }
}

  port: 8030

package com.itbluebox.order;

import com.itbluebox.ribbon.RibbonRandomRuleConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.cloud.netflix.ribbon.RibbonClients;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
//@EnableDiscoveryClient
@RibbonClients(value = {
    
    
        @RibbonClient(name = "stock-service",configuration = RibbonRandomRuleConfig.class)
})
public class OrderApplication {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(OrderApplication.class);
    }
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(RestTemplateBuilder builder){
    
    
        RestTemplate restTemplate = builder.build();
        return restTemplate;
    }
}

启动order-ribbon
http://localhost:8030/order/add

刷新页面

刷新页面以后我们发现有重复的端口，因为当前模式是随机访问对应的端口，之前是轮训，现在是随机因此有同一个端口重复出现的概率

2）配置文件

将刚刚添加到启动类上的内容给注释掉

stock-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule

修改对应的权重，权重越高对应的访问频率就越高

刷新页面我们发现对应22出现的概率比较高




流量测试

5、自定义负载均衡策略

1）默认调用的时候启动对应的负载均衡器

package com.itbluebox.ribbon.rule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class CustomRule extends AbstractLoadBalancerRule {
    
    

    @Override
    public Server choose(Object o) {
    
    
        //获取当前请求的服务的实例
        ILoadBalancer loadBalancer = this.getLoadBalancer();
        //获得当前请求的服务实例
        List<Server> reachableServers = loadBalancer.getReachableServers();
        int random = ThreadLocalRandom.current().nextInt(reachableServers.size());
        Server server = reachableServers.get(random);
        return server;
    }
    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) {
    
    

    }


}

    NFLoadBalancerRuleClassName: com.itbluebox.ribbon.rule.CustomRule

http://localhost:8030/order/add

2）启动的时候加载负载均衡器

当中自定义负载均衡器是在第一次调用的时候才加载对应的负载均衡器
下面我们设置为在启动的时候加载负载均衡器

ribbon:
  eager-load:
    # 开启ribbon饥饿加载
    enabled: true
    # 配置mall-user使用ribbon饥饿加载，多个使用逗号非分割
    clients: stock-service

八、微服务负载均衡器LoadBalancer

1、什么是SpringCloud LoadBalancer

Spring Cloud LoadBalancer是Spring Cloud官方自己提供的客户端负载均衡器,用来替代Ribbon.
Spring官方提供了两种负载均衡的客户端
RestTemplate
RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程
ttp服务的方法，能够大大提高客户端的编写效率。默认情况下，RestTemplate默认依赖jdk的HTTP连接工具。

WebClient
WebCient是从Sprng WVebFlox 5 O城版本开始提供的一个非阻塞的基于响应式‘期程的进行Hti请求的客户端工具。它的响应式编的基于Reaco的]。WebClenm中提供了标崔-tp请求方式对应的ge. :
ost、put、delete等方法，可以用来发起相应的请求。

2、RestTemplate整合LoadBalancer

1）引入依赖

<dependency>
	<groupId>org.springframework.cloud</ groupId>
	<artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
<!--提供了RestTemplate支持-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<! -- nacos服务注册与发现移除ribbon支持-->
<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
	<exclusions>
		<exclusion>
		<groupId>org.springframework.cloud</ groupId>
			<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
		</exclusion>
	</exclusions>
</dependency>

注意: nacos-discovery中引入了ribbon，需要移除ribbon的包如果不移除，
也可以在yml中配置不使用ribbon

spring:
	application:
		name: mall-user-loadbalancer-demo
	cloud:
		nacos:
			discovery:
				server-addr: 127.0.0.1:8848
			#不使用ribbon
		loadbalancer:
			ribbon:
			enabled: false

原理:默认情况下，如果同时拥有RtbtonLcdBalancrdCin和lBlocinaLcedalancrClen，为了保韩向后兼容性，将使用RbtoL oadBalancedClen。要覆盖它，可以设置sring coud.loadcbalane.ribbon.enabled属性为false。

2）复制一个工程用于演示

<artifactId>order-loadbalance</artifactId>

 <module>order-loadbalance</module>

3）排除ribbon依赖，添加loadbalanncer依赖

<!--nacos服务注册发现-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <exclusions>
                <!--将ribbon排除-->
                <exclusion>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-stater-netflix-ribbon</artifactId>
                </exclusion>
            </exclusions>
        </dependency>


        <!--添加loadbalanncer依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>

server:
  port: 8031
  # 应用名称 (nacos会将该名称当做服务名称)
spring:
  application:
    name: order-service
  cloud:
    nacos:
      server-addr: 192.168.180.128:8847
      discovery:
        username: nacos
        password: nacos
        namespace: public
    loadbalancer:
      ribbon:
        enabled: false

访问：http://localhost:8031/order/add