image.png

image.png

image.png

一、Eureka服务器注册与发现

image.png

1、什么是Eureka?

1.Eureka:怎么读?
2.Netflix在设计Eureka时，遵循的就是AP原则。
3.Eureka是Netflix的一个子模块，也是核心模块之一。Eureka是一个基于REST的服务，用于定位服务，以实现云端中间层服务发现和故障转移，服务注册与发现对于微服务来说是非常重要的，有了服务发现与注册，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了，功能类似于Dubbo的注册中心，比如Zookeeper;

2、原理讲解：

Eureka的基本架构：
1、SpringCloud封装了NetFlix公司开发的Eureka模块来实现服务注册和发现(对比Zookeeper)
2、 Eureka采用了C-S的架构设计，EurekaServer作为服务注册功能的服务器，他是服务注册中心
3、而系统中的其他微服务。使用Eureka的客户端连接到EurekaServer并维持心跳连接。这样系统的维护人员就可以通过EurekaServer来监控系统中各个微服务是否正常运行，SpringCloud的一些其他模块（比如Zuul)就可以通过EurekaServer来发现系统中的其他微服务，并执行相关的逻辑
4、和Dubbo架构对比
image.png
image.png
5、Eureka包含两个组件: Eureka Server和Eureka Client 。尤里卡包含两个组件：尤里卡服务器和尤里卡客户端。
6、Eureka Server提供服务注册服务，各个节点启动后，会在EurekaServer中进行注册，这样Eureka Server中的服务注册表中将会村粗所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。提供服务注册服务，各个节点启动后，会在EurekaServer中进行注册，这样Eureka服务器中的服务注册表中将会村粗所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。
7、Eureka Client是一个ava客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用轮询负载算法的负载均衡器。在应用启动后，将会向EurekaServer发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除掉（默认周期为90秒)

三大角色：
1、Eureka Server:提供服务的注册于发现。尤里卡服务器：提供服务的注册于发现。
2、Service Provider:将自身服务注册到Eureka中，从而使消费方能够找到。服务提供商：将自身服务注册到eureka中，从而使消费方能够找到。
3、Service Consumer:服务消费方从Eureka中获取注册服务列表，从而找到消费服务。服务消费者：服务消费方从eureka中获取注册服务列表，从而找到消费服务。

自我保护机制：
1、一句话总结:某时刻某一个微服务不可以用了，eureka不会立刻清理，依旧会对该微服务的信息进行保存!
2、·默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例(默认90秒)。但是当网络分区故障发生时，微服务与Eureka之间无法正常通行，以上行为可能变得非常危险了—因为微服务本身其实是健康的，此时本不应该注销这个服务。Eureka通过**自我保护机制州来解决这个问题—当EurekaServer节点在短时间内丢失过多客户端时(可能发生了网络分区故障)，那么这个节点就会进入自我保护模式。一旦进入该模式，EurekaServer就会保护服务注册表中的信息，不再删除服务注册表中的数据（也就是不会注销任何微服务)。当网络故障恢复后，该EurekaServer节点会自动退出自我保护模式。
3、·在自我保护模式中，EurekaServer会保护服务注册表中的信息，不再注销任何服务实例。当它收到的心跳数重新恢复到阈值以上时，该EurekaServer节点就会自动退出自我保护模式。它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话:好死不如赖活着·
4、·综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留），也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮和稳定·
5、·在SpringCloud中，可以使用eureka.server.enable-se1f-preservation = false禁用自我保护模式【不推荐关闭自我保护机制】·

二、Eureka的使用：

image.png

项目架构图：

image.png

1、项目实现步骤：

1.1 创建父工程并导入依赖：

  1.   <dependencyManagement>
  2.         <dependencies>
  3.             <!--springcloud 的依赖-->
  4.             <dependency>
  5.                 <groupId>org.springframework.cloud</groupId>
  6.                 <artifactId>spring-cloud-dependencies</artifactId>
  7.                 <version>Greenwich.SR1</version>
  8.                 <type>pom</type>
  9.                 <scope>import</scope>
  10.             </dependency>
  11.             <!--springboot-->
  12.             <dependency>
  13.                 <groupId>org.springframework.boot</groupId>
  14.                 <artifactId>spring-boot-dependencies</artifactId>
  15.                 <version>2.1.4.RELEASE</version>
  16.                 <type>pom</type>
  17.                 <scope>import</scope>
  18.             </dependency>
  19.             <!--数据库-->
  20.             <dependency>
  21.                 <groupId>mysql</groupId>
  22.                 <artifactId>mysql-connector-java</artifactId>
  23.                 <version>5.1.46</version>
  24.             </dependency>
  25.             <dependency>
  26.                 <groupId>com.alibaba</groupId>
  27.                 <artifactId>druid</artifactId>
  28.                 <version>1.2.8</version>
  29.             </dependency>
  30.             <!--springboot启动器-->
  31.             <dependency>
  32.                 <groupId>org.mybatis.spring.boot</groupId>
  33.                 <artifactId>mybatis-spring-boot-starter</artifactId>
  34.                 <version>2.1.3</version>
  35.             </dependency>
  36.             <!--junit-->
  37.             <dependency>
  38.                 <groupId>junit</groupId>
  39.                 <artifactId>junit</artifactId>
  40.                 <version>4.13.2</version>
  41.                 <scope>test</scope>
  42.             </dependency>
  43.             <!--lombok-->
  44.             <dependency>
  45.                 <groupId>org.projectlombok</groupId>
  46.                 <artifactId>lombok</artifactId>
  47.                 <version>1.18.20</version>
  48.             </dependency>
  49.             <dependency>
  50.                 <groupId>log4j</groupId>
  51.                 <artifactId>log4j</artifactId>
  52.                 <version>1.2.17</version>
  53.             </dependency>
  54.         </dependencies>

1.2 创建Dept实体类springcloud-api 项目工程：

image.png
Dept.java

  2. @Data
  3. @NoArgsConstructor
  4. @Accessors(chain = true)//链式写法
  5. public class Dept implements Serializable {
  6.     private Long deptId;
  7.     private String deptName;
  8.     //数据是存在那个数据库下的字段~微服务   一个服务对应一个数据库同一个信息可能存在不同的数据库
  9.     private String dbSource;
  10.     private Dept(String deptName){
  11.         this.deptName = deptName;
  12.     }
  13. }

1.3 创建服务提供者工程 springcloud-provider-dept-8001:

项目结构：
image.png

1.3.1 导入相关依赖：

  2. <dependencies>
  3.         <!--我们需要拿到实体类（自己写的api项目）-->
  4.         <dependency>
  5.             <groupId>com.tang</groupId>
  6.             <artifactId>springcloud-api</artifactId>
  7.             <version>1.0-SNAPSHOT</version>
  8.         </dependency>
  9.         <dependency>
  10.             <groupId>junit</groupId>
  11.             <artifactId>junit</artifactId>
  12.             <scope>test</scope>
  13.         </dependency>
  14.         <dependency>
  15.             <groupId>mysql</groupId>
  16.             <artifactId>mysql-connector-java</artifactId>
  17.         </dependency>
  18.         <dependency>
  19.             <groupId>com.alibaba</groupId>
  20.             <artifactId>druid</artifactId>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>org.mybatis.spring.boot</groupId>
  24.             <artifactId>mybatis-spring-boot-starter</artifactId>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-test</artifactId>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-web</artifactId>
  33.         </dependency>
  34.         <!--Eureka依赖-->
  35.         <dependency>
  36.             <groupId>org.springframework.cloud</groupId>
  37.             <artifactId>spring-cloud-starter-eureka</artifactId>
  38.             <version>1.4.7.RELEASE</version>
  39.         </dependency>
  40.         <!--监控依赖-->
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-actuator</artifactId>
  44.         </dependency>
  45.     </dependencies>

1.3.2 创建controller控制类：

  1. @RestController
  2. public class DeptController {
  3.     //获取一些配置的信息，得到具体的微服务
  4.     @Autowired
  5.     private DiscoveryClient client;
  6.     @Autowired
  7.     private DeptService deptService;
  8.     @PostMapping("/dept/addDept")
  9.     public  int addDept(Dept dept){
  10.         return deptService.addDept(dept);
  11.     }
  12.     @GetMapping("/dept/quaryDept/{id}")
  13.     public Dept queryDept(@PathVariable("id") Long deptId){
  14.         System.out.println("deptId = " + deptId);
  15.         Dept dept = deptService.queryDept(deptId);
  16.         System.out.println("dept = " + dept);
  17.         return dept;
  18.     }
  19.     @GetMapping("/dept/queryAllDept")
  20.     public List<Dept> addDept(){
  21.         return deptService.queryAllDept();
  22.     }
  25.     /**
  26.      * 注册进来的微服务~ 获取一些信息
  27.      * 注意：要在启动类上加注解 @EnableDiscoveryClient 用来发现服务
  28.      */
  29.     @GetMapping("/dept/discovery")
  30.     public Object discovery(){
  31.         //获取微服务列表清单
  32.         List<String> services = client.getServices();
  33.         System.out.println("services = " + services);
  35.         //得到一个具体的微服务信息，通过具体的微服务id
  36.         List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");
  37.         for (ServiceInstance instance : instances) {
  38.             System.out.println(
  39.                     instance.getServiceId()+"\t"+
  40.                     instance.getInstanceId()+"\t"+
  41.                             instance.getHost()+"\t"+
  42.                             instance.getPort()+"\t"+
  43.                             instance.getMetadata()+"\t"+
  44.                             instance.getUri()
  45.             );
  46.         }
  47.         return this.client;
  48.     }
  49. }

1.3.3创建Mapper：

  1. @Mapper
  2. @Repository
  3. public interface DeptMapper {
  4.     /**
  5.      * 添加部门信息
  6.      * @param dept
  7.      * @return
  8.      */
  9.     int addDept(Dept dept);
  11.     /**
  12.      * 查询单个部门信息
  13.      * @param deptId
  14.      * @return
  15.      */
  16.     Dept queryDept(@Param("deptId") Long deptId);
  18.     /**
  19.      * 查询所有部门信息
  20.      * @return
  21.      */
  22.     List<Dept> queryAllDept();
  23. }

1.3.3 配置mybatis-config.xml配置文件：

  1. <?xml version="1.0" encoding="utf8" ?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <!--核心配置文件-->
  6. <configuration>
  7.         <!--开启二级缓存-->
  8.         <settings>
  9.             <setting name="cacheEnabled" value="true"/>
  10.         </settings>
  12. </configuration>

1.3.4 配置Springboot配置文件（application.yml）:

  1. server:
  2.   port: 8001
  4. #mybatis配置
  5. mybatis:
  6.   type-aliases-package: com.tang.springcloud.pojo
  7.   mapper-locations: classpath:mybatis/mapper/*.xml #mapper文件位置
  8.   config-location: classpath:mybatis/mybatis-config.xml #mybatis配置文件位置
  9. #spring配置
  10. spring:
  11.   application:
  12.     name: springcloud-provider-dept
  13.   datasource:
  14.     type: com.alibaba.druid.pool.DruidDataSource
  15.     driver-class-name: com.mysql.jdbc.Driver
  16.     url: jdbc:mysql://localhost:3306/db01cloud?useUnicode=true&characterEncoding=utf-8&useSSL=true
  17.     username: root
  18.     password: root
  20. #eureka的配置  服务注册到哪里、
  21. eureka:
  22.   client:
  23.     service-url:
  24.       defaultZone: http://localhost:7001/eureka/  #注册中心的地址
  25.   instance:
  26.     instence-id: springcloud-provider-dept8001 #修改eureka视图上的默认描述信息
  28. info:
  29.   app.name: tangtang
  30.   company.name: www.tang.com

ps: info:
app.name: tangtang
company.name: www.tang.com
是配置这里点击出现的数据：
image.png

1.3.5 配置启动类：

  1. @SpringBootApplication
  2. @EnableEurekaClient //在服务启动自动注册到服务
  3. @EnableDiscoveryClient //服务发现 用来做查询服务信息
  4. public class DeptProvider_8001 {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(DeptProvider_8001.class,args);
  7.     }
  8. }

1.4 创建消费者工程 springboot-consumer-80 :

项目结构：
image.png

1.4.1 创建RestTemplate实例对象：

  1. @Configuration
  2. public class ConfigBean {
  3.     @Bean
  4.     public RestTemplate getRestTemplate() {
  5.         return new RestTemplate();
  6.     }
  7. }

ps:这里的RestTemplate是用来做请求的发送和接收请求返回结果的.

1.4.2 导入依赖：

  1.   <dependencies>
  2.           导入的是自己定义的apiBean项目
  3.         <dependency>
  4.             <groupId>com.tang</groupId>
  5.             <artifactId>springcloud-api</artifactId>
  6.             <version>1.0-SNAPSHOT</version>
  7.         </dependency>
  8.         <dependency>
  9.             <groupId>org.springframework.boot</groupId>
  10.             <artifactId>spring-boot-starter-web</artifactId>
  11.         </dependency>
  12.     </dependencies>

1.4.3 使用RestTemplate来创建请求的发送（这里没有service业务）：

ps:这里调用的是服务提供者的项目工程里面的业务逻辑和数据库的数据的查询.

  1. @RestController
  2. public class DeptConsumerController {
  3.     /**
  4.      * 理解：消费者，不应该有service层
  5.      * restTemplate...供我们使用就行了，注测到spring容器中
  6.      * （url.实体：Map，Class<T>responseType）
  7.      */
  8.     //请求地址
  9.     private static final String REST_URL_PERFIX="http://localhost:8001";
  10.     /**
  11.      * RestTemplate 是提供多种便捷访问远程http服务的方法，简单的Restful服务模板~
  12.      */
  13.     @Autowired
  14.     private RestTemplate restTemplate;
  17.     @RequestMapping("/consumer/dept/queryDept/{id}")
  18.     public Dept getdept(@PathVariable("id")Long deptId){
  19.         return restTemplate.getForObject(REST_URL_PERFIX + "/dept/queryDept/"+deptId,Dept.class);
  20.     }
  21.     @RequestMapping("/consumer/dept/queryAllDept")
  22.     public List<Dept> getdeptAll(){
  23.         return restTemplate.getForObject(REST_URL_PERFIX + "/dept/queryAllDept",List.class);
  24.     }
  25.     @RequestMapping("/consumer/dept/addDept")
  26.     public int addept(Dept dept){
  27.         return restTemplate.getForObject(REST_URL_PERFIX + "/dept/addDept",int.class,dept);
  28.     }
  30. }

注： @RequestMapping(“/consumer/dept/queryDept/{id}”) 请求是消费者发送的请求路径
restTemplate.getForObject(REST_URL_PERFIX + “/dept/queryAllDept”,List.class)：{
1》REST_URL_PERFIX + “/dept/queryAllDept”：指的是服务提供者controller的请求路径
2》List.class :指的是服务提供者方法=返回的数据类型
}

1.4.4 application.yml配置文件：

  1. server:
  2.   port: 80

1.4.5 启动类：

  1. @SpringBootApplication
  2. public class DeptConsumer_80{
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(DeptConsumer_80.class,args);
  5.     }
  6. }

1.5 创建服务注册中心工程 springcloud-eureka-7001：

项目结构：

image.png

1.5.1 导入依赖：

  1.  <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-eureka-server</artifactId>
  5.             <version>1.4.6.RELEASE</version>
  6.         </dependency>
  7.     </dependencies>

1.5.2 配置application.yml配置文件：

  1. server:
  2.   port: 7001
  5. #Eureka配置
  6. eureka:
  7.   instance:
  8.     hostname: localhost #Eureka服务端的实例名称
  9.   client:
  10.     register-with-eureka: false #表示是否向eureka注册中心注册自己
  11.     fetch-registry: false #如果为false表示自己是注册中心
  12.     service-url: #监控页面
  13.       defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #监控页面访问地址

image.png

1.5.3 配置启动类：

  1. @SpringBootApplication
  2. @EnableEurekaServer //服务端启动类，可以接受别人注册进来~ http://localhost:7001/(访问页面请求)
  3. public class EurekaServer_7001 {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(EurekaServer_7001.class,args);
  6.     }
  7. }

三、集群的配置：

项目结构：
image.png
需要修改的地方：
1.下面结构都一样，修改application.yml配置里面的端口号为不一样的信息
2.defaultZone：配置其它服务的地址

1、导入相关依赖：

  1.          <dependency>
  2.             <groupId>org.springframework.cloud</groupId>
  3.             <artifactId>spring-cloud-starter-eureka-server</artifactId>
  4.             <version>1.4.6.RELEASE</version>
  5.         </dependency>

2、配置application.yml配置文件：

  1. server:
  2.   port: 7001
  5. #Eureka配置
  6. eureka:
  7.   instance:
  8.     hostname: localhost #Eureka服务端的实例名称
  9.   client:
  10.     register-with-eureka: false #表示是否向eureka注册中心注册自己
  11.     fetch-registry: false #如果为false表示自己是注册中心
  12.     service-url: #监控页面
  13.       #单机情况
  14. #      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  15.       #集群 多个服务地址用逗号隔开
  16.       defaultZone: http://${eureka.instance.hostname}:7002/eureka/,http://${eureka.instance.hostname}:7003/eureka/

3、启动类：

  1. @SpringBootApplication
  2. @EnableEurekaServer //服务端启动类，可以接受别人注册进来~ http://localhost:7001/(访问页面请求)
  3. public class EurekaServer_7001 {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(EurekaServer_7001.class,args);
  6.     }
  7. }

4、配置clinet服务提供者：

项目结构：
image.png
ps:多个服务对应多个端口号，可以连接不同的数据库，端口号不能一样（不然会冲突）

4.1 导入pom依赖：

  1.  <dependencies>
  2.         <!--我们需要拿到实体类（自己写的api项目）-->
  3.         <dependency>
  4.             <groupId>com.tang</groupId>
  5.             <artifactId>springcloud-api</artifactId>
  6.             <version>1.0-SNAPSHOT</version>
  7.         </dependency>
  8.         <dependency>
  9.             <groupId>junit</groupId>
  10.             <artifactId>junit</artifactId>
  11.             <scope>test</scope>
  12.         </dependency>
  13.         <dependency>
  14.             <groupId>mysql</groupId>
  15.             <artifactId>mysql-connector-java</artifactId>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>com.alibaba</groupId>
  19.             <artifactId>druid</artifactId>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.mybatis.spring.boot</groupId>
  23.             <artifactId>mybatis-spring-boot-starter</artifactId>
  24.         </dependency>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-test</artifactId>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-web</artifactId>
  32.         </dependency>
  33.         <!--Eureka依赖-->
  34.         <dependency>
  35.             <groupId>org.springframework.cloud</groupId>
  36.             <artifactId>spring-cloud-starter-eureka</artifactId>
  37.             <version>1.4.7.RELEASE</version>
  38.         </dependency>
  39.         <!--监控依赖-->
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             <artifactId>spring-boot-starter-actuator</artifactId>
  43.         </dependency>

4.2 配置application.yml：

  1. server:
  2.   port: 8001 
  4. #mybatis配置
  5. mybatis:
  6.   type-aliases-package: com.tang.springcloud.pojo
  7.   mapper-locations: classpath:mybatis/mapper/*.xml
  8.   config-location: classpath:mybatis/mybatis-config.xml
  9. #spring配置
  10. spring:
  11.   application:
  12.     name: springcloud-provider-dept
  13.   datasource:
  14.     type: com.alibaba.druid.pool.DruidDataSource
  15.     driver-class-name: com.mysql.jdbc.Driver
  16.     url: jdbc:mysql://localhost:3306/db01cloud?useUnicode=true&characterEncoding=utf-8&useSSL=true
  17.     username: root
  18.     password: root
  20. #eureka的配置  服务注册到哪里、
  21. eureka:
  22.   client:
  23.     service-url:
  24.     #配置集群的地址，多个地址之间用逗号隔开
  25.       defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  26.   instance:
  27.     instence-id: springcloud-provider-dept8001 #修改eureka视图上的默认描述信息
  29. info:
  30.   app.name: tangtang
  31.   company.name: www.tang.com

4.3 编写三层架构：

4.4 启动类：

  1. @SpringBootApplication
  2. @EnableEurekaClient //在服务启动自动注册到服务
  3. @EnableDiscoveryClient //服务发现
  4. public class DeptProvider_8001 {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(DeptProvider_8001.class,args);
  7.     }
  8. }

四、Eureka和Zookeeper的区别：

五、Ribbon及负载均衡：

负载均衡流程图：
image.png
image.png
image.png

1、什么是ribbon？

1》Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。春天云带是基于Netflix丝带实现的一套客户端负载均衡的工具。
2》·简单的说，Ribbon是Netflx发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将NetFlix的中间层服务连接在一起。Ribbon的客户端组件提供一系列完整的配置项如:连接超时、重试等等。简单的说，就是在配置文件中列出LoadBalancer(简称LB:负载均衡）后面所有的机器，Ribbon会自动的帮助你基于某种规则(如简单轮询，随机连接等等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法!

2、ribbon核心原理：

image.png

Ribbon其实就是在请求的时候使用了个interceptor拦截器，然后将拦截到请求信息，然后根据请求信息做一系列判断，最终请求到了server端。
image.png
其实就是请求过程中经过一层层的过滤器，然后进行不同的操作，最终到达目的地。
Ribbon负载均衡器分为五个部分组成，分别是
负载均衡管理器LoadBalancer，主要是协调下面四个部分的运行，围绕它周围的多有IRule、IPing等
IRule:是在选择实例的时候的负载均衡策略对象
IPing:是用来向服务发起心跳检测的，通过心跳检测来判断该服务是否可用
ServerListFilter:根据一些规则过滤传入的服务实例列表
ServerListUpdater:定义了一系列的对服务列表的更新操作

3.Ribbon负载均衡策略：

image.png

2、ribbon能干嘛？

1》·LB，即负载均衡(Load Balance)，在微服务或分布式集群中经常用的一种应用。
2》·负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA (高可用)。
3》·常见的负载均衡软件有Nginx,Lvs等等·
4》. dubbo、SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义·负载均衡简单分类:。

2.1 负载均衡简单分类：

2.1.1 集中式LB：

即在服务的消费方和提供方之间使用独立的LB设施，如Nginx（反向代理服务器），由该设施负责把访问请求通过某种策略转发至服务的提供方!

2.1.2 进程方LB：

将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。
Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址~

3、ribbon的使用：

Ribbon饥饿加载：
image.png
image.png

3.1 导入相关依赖：

  1.  <dependency>
  2.             <groupId>com.tang</groupId>
  3.             <artifactId>springcloud-api</artifactId>
  4.             <version>1.0-SNAPSHOT</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.boot</groupId>
  8.             <artifactId>spring-boot-starter-web</artifactId>
  9.         </dependency>
  12.         <!--ribbon依赖-->
  13.         <dependency>
  14.             <groupId>org.springframework.cloud</groupId>
  15.             <artifactId>spring-cloud-starter-ribbon</artifactId>
  16.             <version>1.4.7.RELEASE</version>
  17.         </dependency>
  18.         <!--eureka依赖-->
  19.         <dependency>
  20.             <groupId>org.springframework.cloud</groupId>
  21.             <artifactId>spring-cloud-starter-eureka</artifactId>
  22.             <version>1.4.7.RELEASE</version>
  23.         </dependency>

3.2 配置application.yml配置文件：

  1. server:
  2.   port: 80
  4. #Eureka配置
  5. eureka:
  6.   client:
  7.     register-with-eureka: false #不向Eureka注册自己
  8.     service-url:
  9.       defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/

3.3 编写自己的controller:

  2. @RestController
  3. public class DeptConsumerController {
  4.     /**
  5.      * 理解：消费者，不应该有service层
  6.      * restTemplate...供我们使用就行了，注测到spring容器中
  7.      * （url.实体：Map，Class<T>responseType）
  8.      */
  9.     //请求地址 只能针对一个服务进行
  10.    // private static final String REST_URL_PERFIX="http://localhost:8001";
  15.     /**
  16.      * 负载均衡的使用  Ribbon。请求地址应该是一个变量
  17.      * 用过服务器名来访问
  18.      */
  19.     private static final String REST_URL_PERFIX="http://SPRINGCLOUD-PROVIDER-DEPT";
  20.     /**
  21.      * RestTemplate 是提供多种便捷访问远程http服务的方法，简单的Restful服务模板~
  22.      */
  23.     @Autowired
  24.     private RestTemplate restTemplate;
  27.     @RequestMapping("/consumer/dept/queryDept/{id}")
  28.     public Dept getdept(@PathVariable("id")Long deptId){
  29.         return restTemplate.getForObject(REST_URL_PERFIX + "/dept/queryDept/"+deptId,Dept.class);
  30.     }
  31.     @RequestMapping("/consumer/dept/queryAllDept")
  32.     public List<Dept> getdeptAll(){
  33.         return restTemplate.getForObject(REST_URL_PERFIX + "/dept/queryAllDept",List.class);
  34.     }
  35.     @RequestMapping("/consumer/dept/addDept")
  36.     public int addept(Dept dept){
  37.         return restTemplate.getForObject(REST_URL_PERFIX + "/dept/addDept",int.class,dept);
  38.     }
  40. }

ps: private static final String REST_URL_PERFIX=”http://SPRINGCLOUD-PROVIDER-DEPT“;
SPRINGCLOUD-PROVIDER-DEPT:指页面的这个名~

image.png

3.4 配置RestTemplate工具：

  1. @Configuration
  2. public class ConfigBean {
  3.     /**
  4.      * 配置负载均衡实现RestTemlate
  5.      * @return
  6.      */
  7.     @Bean
  8.     @LoadBalanced //Ribbon的注解
  9.     public RestTemplate getRestTemplate() {
  10.         return new RestTemplate();
  11.     }
  12. }

ps:必须实现注解@LoadBalanced才能实现负载均衡。

3.5 启动类：

  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. public class DeptConsumer_80{
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(DeptConsumer_80.class,args);
  6.     }
  7. }

六、Feign负载均衡：

1、Feign简介：

feign是声明式的web service客户端，它让微服务之间的调用变得更简单了，类似controller调用service。SpringCloud集成了Ribbon和Eureka，可在使用Feign时提供负载均衡的http客户端。

只需要创建一个接口，然后添加注解即可!
feign，主要是社区，大家都习惯面向接口编程。这个是很多开发人员的规范。调用微服务访问两种方法：
1.微服务名字【ribbon】
2.接口和注解【feign】

2、Feign能干什么？

1》. Feign旨在使编写Java Http客户端变得更容易。
2》·前面在使用Ribbon + RestTemplate时，利用RestTemplate对Http请求的封装处理，形成了一套模板化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步封装，由他来帮助我们定义和实现依赖服务接口的定义，在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它(类似于以前Dao接口上标注Mapper注解，现在是一个微服务接口上面标注一个Feign注解即可。)即可完成对服务提供方的接口绑定，简化了使用Spring Cloud Ribbon时，自动封装服务调用客户端的开发量。

3、Feign集成了Ribbon：

·利用Ribbon维护了MicroServiceCloud-Dept的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过Feign只需要定义服务绑定接口且以声明式的方法，优雅而且简单的实现了服务调用。

4、Feign的远程调用的使用：

4.1 导入依赖：

  1.     <!--  feign-->
  2. <dependency>
  3.   <groupId>org.springframework.cloud</groupId>
  4.   <artifactId>spring-cloud-starter-feign</artifactId>
  5.   <version>1.4.7.RELEASE</version>
  6. </dependency>

4.2 在启动类上面加入注解@EnableFeignClients(basePackages = {“com.tang.springcloud”})：

  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. @EnableFeignClients(basePackages = {"com.tang.springcloud"})
  4. public class FeignDeptConsumer_80 {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(FeignDeptConsumer_80.class,args);
  7.     }
  8. }

4.3 编写对应的业务在类上添加注解@FeignClient(“服务名称”)：

  1. @FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
  2. //SPRINGCLOUD-PROVIDER-DEPT ： 服务的名称
  3. @Component
  4. public interface DeptClinetService {
  5.     @PostMapping("/dept/addDept")
  6.     int addDept(Dept dept);
  7.     @GetMapping("/dept/quaryDept/{id}")
  8.     Dept queryDept(@PathVariable("id") Long deptId);
  9.     @GetMapping("/dept/queryAllDept")
  10.     List<Dept> queryAllDept();
  12. }

4.4 直接调用第三步里面实现的方法：

  1. @RestController
  2. public class DeptConsumerController {
  3.     @Autowired
  4.     private DeptClinetService deptClinetService;
  7.     @RequestMapping("/consumer/dept/queryDept/{id}")
  8.     public Dept getdept(@PathVariable("id")Long deptId){
  9.         //调用feign方法
  10.         return deptClinetService.queryDept(deptId);
  11.     }
  12. }

5、Feign的自定义配置：

5.1 Feign运行自定义配置来覆盖默认配置，可以修改的配置如下：

image.png

5.2 配置Feign日志的两种方式：

方式一：配置文件的方式：
1》、全局生效：

  1. feign:
  2.     client:
  3.       config:
  4.           default:#这里用default就是全局配置，如果是写服务名称，这是针对某个微服务的配置
  5.           loggerLevel: FULL #日志级别

2》、局部生效：

  1. feign:
  2.     client:
  3.       config:
  4.           peoviderDept: #这里用peoviderDept（服务名）就是局部配置
  5.           loggerLevel: FULL #日志级别

**
image.png

6、Feign的性能优化：

image.png

6.1 feign连接池的配置：

image.png

七、Hystrix ：服务熔断

1.什么是服务雪崩？

1》多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C，微服务B和微服务C又调用其他的微服务，这就是所谓的“扇出”、如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的“雪崩效应”。
2》对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几秒中内饱和。比失败更糟糕的是，这些应用程序还可能导致服务之间的延迟增加，备份队列，线程和其他系统资源紧张，导致整个系统发生更多的级联故障，这些都表示需要对故障和延迟进行隔离和管理，以便单个依赖关系的失败，不能取消整个应用程序或系统
我们需要·弃车保帅·

2、什么是Hystrix？

1》Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时，异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性。
2》“断路器”本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝)，向调用方返回一个服务预期的，可处理的备选响应（FallBack)，而不是长时间的等待或者抛出调用方法无法处理的异常，这样就可以保证了服务调用方的线程不会被长时间，不必要的占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩

3、它能干嘛？

1》服务降级
2》服务熔断
3》服务限流
4》接近实时监控
……

4、官网资料（https://github.com/Netflix/Hystrix/wiki）

5、什么是服务熔断？

1》熔断机制是对应雪崩效应的一种微服务链路保护机制。
2》当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回错误的响应信息。当检测到该节点微服务调用响应正常后恢复调用链路。在SpringCloud框架里熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况，当失败的调用到一定阈值，缺省是5秒内20次调用失败就会启动熔断机制。熔断机制的注解是@HystrixCommand。

6、Hystrix的使用：

工程结构：
image.png

6.1 导入相关依赖：

  1.   <!--我们需要拿到实体类（自己写的api项目）-->
  2.     <dependency>
  3.         <groupId>com.tang</groupId>
  4.         <artifactId>springcloud-api</artifactId>
  5.         <version>1.0-SNAPSHOT</version>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>junit</groupId>
  9.         <artifactId>junit</artifactId>
  10.         <scope>test</scope>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>mysql</groupId>
  14.         <artifactId>mysql-connector-java</artifactId>
  15.     </dependency>
  16.     <dependency>
  17.         <groupId>com.alibaba</groupId>
  18.         <artifactId>druid</artifactId>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.mybatis.spring.boot</groupId>
  22.         <artifactId>mybatis-spring-boot-starter</artifactId>
  23.     </dependency>
  24.     <dependency>
  25.         <groupId>org.springframework.boot</groupId>
  26.         <artifactId>spring-boot-test</artifactId>
  27.     </dependency>
  28.     <dependency>
  29.         <groupId>org.springframework.boot</groupId>
  30.         <artifactId>spring-boot-starter-web</artifactId>
  31.     </dependency>
  32.     <!--Eureka依赖-->
  33.     <dependency>
  34.         <groupId>org.springframework.cloud</groupId>
  35.         <artifactId>spring-cloud-starter-eureka</artifactId>
  36.         <version>1.4.7.RELEASE</version>
  37.     </dependency>
  38.     <!--监控依赖-->
  39.     <dependency>
  40.         <groupId>org.springframework.boot</groupId>
  41.         <artifactId>spring-boot-starter-actuator</artifactId>
  42.     </dependency>
  46.         <!--Hystrix依赖-->
  47.         <dependency>
  48.             <groupId>org.springframework.cloud</groupId>
  49.             <artifactId>spring-cloud-starter-hystrix</artifactId>
  50.             <version>1.4.7.RELEASE</version>
  51.         </dependency>

6.2 配置application.yml配置文件：

  1. server:
  2.   port: 8001
  4. #mybatis配置
  5. mybatis:
  6.   type-aliases-package: com.tang.springcloud.pojo
  7.   mapper-locations: classpath:mybatis/mapper/*.xml
  8.   config-location: classpath:mybatis/mybatis-config.xml
  9. #spring配置
  10. spring:
  11.   application:
  12.     name: springcloud-provider-dept
  13.   datasource:
  14.     type: com.alibaba.druid.pool.DruidDataSource
  15.     driver-class-name: com.mysql.jdbc.Driver
  16.     url: jdbc:mysql://localhost:3306/db01cloud?useUnicode=true&characterEncoding=utf-8&useSSL=true
  17.     username: root
  18.     password: root
  20. #eureka的配置  服务注册到哪里、
  21. eureka:
  22.   client:
  23.     service-url:
  24.       defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  25.   instance:
  26.     instence-id: springcloud-provider-dept-Hystrix-8001 #修改eureka视图上的默认描述信息
  28. info:
  29.   app.name: tangtang
  30.   company.name: www.tang.com

6.3 配置controller:

  1. @RestController
  2. public class DeptController {
  3.     @Autowired
  4.     private DeptService deptService;
  6.     @GetMapping("/dept/quaryDept/{id}")
  7.     //服务熔断代码 fallbackMethod：表示当服务崩溃时调用备选方法
  8.     @HystrixCommand(fallbackMethod = "hystrixQueryDept")
  9.     public Dept queryDept(@PathVariable("id") Long deptId){
  10.         Dept dept = deptService.queryDept(deptId);
  11.         if(dept == null){
  12.             new RuntimeException("id=>"+deptId+"无法查询到信息");
  13.         }
  14.         return dept;
  15.     }
  17.     //备选方案
  19.     public Dept hystrixQueryDept(@PathVariable("id") Long deptId){
  20.        return new Dept().setDeptId(deptId).setDeptName("id=>"+deptId+"无法查询到信息").setDbSource("没有数据库信息");
  21.     }
  23. }

6.4 启动类：

  1. @SpringBootApplication
  2. @EnableEurekaClient //在服务启动自动注册到服务
  3. @EnableDiscoveryClient //服务发现
  4. @EnableCircuitBreaker//添加对熔断的支持
  5. public class DeptProviderHyterix_8001 {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(DeptProviderHyterix_8001.class,args);
  8.     }
  9. }

八、Hystrix：服务降级

九、Hystrix：Dashboard流监控

Dashboard的使用：

image.png

1、建立dashboard项目工程（springcloud-consumer-hystrix-dashboard）：

如上图所示

2、导入相关依赖：

  1.  <dependency>
  2.             <groupId>com.tang</groupId>
  3.             <artifactId>springcloud-api</artifactId>
  4.             <version>1.0-SNAPSHOT</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.boot</groupId>
  8.             <artifactId>spring-boot-starter-web</artifactId>
  9.         </dependency>
  12.         <!--ribbon依赖-->
  13.         <dependency>
  14.             <groupId>org.springframework.cloud</groupId>
  15.             <artifactId>spring-cloud-starter-ribbon</artifactId>
  16.             <version>1.4.7.RELEASE</version>
  17.         </dependency>
  18.         <!--eureka依赖-->
  19.         <dependency>
  20.             <groupId>org.springframework.cloud</groupId>
  21.             <artifactId>spring-cloud-starter-eureka</artifactId>
  22.             <version>1.4.7.RELEASE</version>
  23.         </dependency>
  24.         <!--Hystrix依赖-->
  25.         <dependency>
  26.             <groupId>org.springframework.cloud</groupId>
  27.             <artifactId>spring-cloud-starter-hystrix</artifactId>
  28.             <version>1.4.7.RELEASE</version>
  29.         </dependency>
  30.         <!--dashboard监控依赖-->
  31.         <dependency>
  32.             <groupId>org.springframework.cloud</groupId>
  33.             <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
  34.             <version>1.4.7.RELEASE</version>
  35.         </dependency>

3、配置applicatiion.tyml配置文件：

  1. server:
  2.   port: 9001

4、编写启动类：

浏览器请求地址：http://localhost:9001/hystrix

  1. @SpringBootApplication
  2. @EnableHystrixDashboard //开启监控  
  3. public class SpringcloudHystrixDashborad_9001 {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(SpringcloudHystrixDashborad_9001.class,args);
  6.     }
  7. }

如下图所示：

5、在业务提供工程（springvloud-provider-dept-8001）中的启动类编写方法：

5.1 导入Hystrix的依赖：

  1.  <!--Hystrix依赖-->
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-hystrix</artifactId>
  5.             <version>1.4.7.RELEASE</version>
  6.         </dependency>

5.1 在启动类编写servlet注册ServletRegistrationBean 方法：

注意：要想支持监控必须实现服务熔断

  1. @SpringBootApplication
  2. @EnableEurekaClient //在服务启动自动注册到服务
  3. @EnableDiscoveryClient //服务发现
  4. @EnableCircuitBreaker//添加对熔断的支持
  5. public class DeptProvider_8001 {
  6.     public static void main(String[] args) {
  8.         SpringApplication.run(DeptProvider_8001.class,args);
  9.     }
  13.       //增加一个servlet
  14.     @Bean
  15.     public ServletRegistrationBean hystrixMetricsStreamServlet() {
  16.         ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
  17.         //监控页面提供的路径（Single Hystrix App: http://hystrix-app:port/actuator/hystrix.stream）
  18.         servletRegistrationBean.addUrlMappings("/actuator/hystrix.stream");
  19.         servletRegistrationBean.setLoadOnStartup(1);
  20.         servletRegistrationBean.setName("hystrixMetricsStreamServlet");
  21.         return servletRegistrationBean;
  22.     }
  23. }

6、执行步骤：

6.1 启动集群 eureka-7001
6.2 启动服务t提供者 provider-8001
6.3 启动监控项目hystrix-dashboard-9001
http://localhost:8001/actuator/hystrix.stream查看服务流信息（必须执行@HystrixCommand注解所定义的请求方法 不然ping不到信息）
http://localhost:9001/hystrix 查看监控页面
image.png
监控后的页面：
image.png

十、Zuul 路由网关

1、什么是Zuul？

1》Zuul包含了对请求的路由和过滤两个最主要的功能。
2》其中路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础，而过滤器功能则负责对请求的处理过程进行干预，是实现请求校验，服务聚合等功能的基础。Zuul和Eureka进行整合，将Zuul自身注册为Eureka服务治理下的应用，同时从Eureka中获得其他微服务的消息，也即以后的访问微服务都是通过Zuul跳转后获得。

注意:Zuul服务最终还是会注册进Eureka
提供:代理＋路由＋过滤三大功能!

2、Zuul能干嘛？

1》路由
2》过滤

3、官方文档（https://github.com/Netflix/zuul）：

4、Zuul的相关配置和使用：

十一、Springcloud config分布式配置

1、分布式系统面临的—配置文件的问题：

微服务意味着要将单体应用中的业务拆分成一个个子服务，每个服务的粒度相对较小，因此系统中会出现大量的服务，由于每个服务都需要必要的配置信息才能运行，所以一套集中式的，动态的配置管理设施是必不可少的。SpringCloud提供了ConfigServer来解决这个问题，我们每一个微服务自己带着一个application.yml，那上百的的配置文件要修改起来，岂不是要发疯!

2、什么是Springcloud config分布式配置中心：

image.png
1》Spring Cloud Config 为微服务架构中的微服务提供集中化的外部配置支持，配置服务器为各个不同微服务应用的所有环节提供了一个中心化的外部配置。
2》Spring Cloud Config 分为服务端和客户端两部分;
3》服务端也称为分布式配置中心，它是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密，解密信息等访问接口。
4》客户端则是通过指定的配置中心来管理应用资源，以及与业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息。配置服务器默认采用git来存储配置信息，这样就有助于对环境配置进行版本管理。并且可以通过git客户端工具来方便的管理和访问配置内容。

3、Springcloud config分布式配置中心能干嘛？

1》集中管理配置文件
2》不同环境，不同配置，动态化的配置更新，分环境部署，比如/dev /test/ /prod /beta /release
3》运行期间动态调整配置，不再需要在每个服务部署的机器上编写配置文件，服务会向配置中心统一拉取配置自己的信息。
4》当配置发生变动时，服务不需要重启，即可感知到配置的变化，并应用新的配置
5》将配置信息以REST接口的形式暴露。

4、Springcloud config分布式配置中心与github整合：

由于Spring Cloud Config默认使用Git来存储配置文件（也有其他方式，比如支持SVN和本地文件)，但是最推荐的还是Git,而且使用的是 http / https 访问的形式;

十二、Nacos注册中心

Nacos是阿里巴巴的产品，现在是Springcloud中的一个组件。相比Eureka功能更加丰富。
image.png

12.1 Nacos的windows安装：

12.1.1 下载安装包：

在Nacos的GitHub页面，提供有下载链接，可以下载编译好的Nacos服务端或者源代码:
GitHub主页: https:/lgithub.com/alibaba/nacos
GitHub的Release下载页: https:llgithub.com/alibaba/nacos/releases
如图：
image.png
image.png
image.png

12.1.2 解压：

image.png

12.1.3 启动：

image.png

  1. startup.cmd -m standalone

12.2 Nacos依赖：

ps:如果用nacos就不用eureka注册中心了！！
父工程：

  1. <!-- Nacos父工程依赖-->
  2. <dependency>
  3.   <groupId>com.alibaba.cloud</groupId>
  4.   <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  5.   <version>2.2.5.RELEASE</version>
  6.   <type>pom</type>
  7.   <scope>import</scope>
  8. </dependency>

nacos客户端依赖（服务提供工程）：

  1.  <!--nacos客户端依赖-->
  2. <dependency>
  3.   <groupId>com.alibaba.cloud</groupId>
  4.   <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  5. </dependency>

application.yml配置nacos：
image.png
nacos客户端页面：
image.png

12.3 Nacos服务分级存储模型：

image.png

12.4 Nacos服务集群属性：

12.4.1 修改application.yml配置：

  1. spring:
  2.   cloud:
  3.     nacos:
  4.       server-addr: localhost:8848 #nacos 服务端地址
  5.       discovery:
  6.         cluster-name: CD #配置集群名称

12.4.2 在Nacos客户端看集群变化：

image.png

12.5 Nacos根据集群负载均衡：

12.5.1 设置集群（服务提供者）application.yml：

  1. spring:
  2.   cloud:
  3.     nacos:
  4.       server-addr: localhost:8848 #nacos 服务端地址
  5.       discovery:
  6.         cluster-name: CD #配置集群名称

12.5.2 在application.yml配置负债均衡信息：

image.png

  1. userservice:  #服务的名称（id）
  2.       ribbon:
  3.       NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule #负载均衡规则

image.png

12.5.3 NacosRile负载均衡策略：

1》、优先选择同集群服务实例列表。
2》、本机集群找不到提供者，采取其他集群寻找，并且会报警告。
3》、确定了可用实例列表后，在采用随机负载均衡挑选实例。

12.6 Nacos根据权重负载均衡：

1、在Nacos控制台设置权重：

image.png

2、进行更改：

image.png

12.7 Nacos环境隔离-namespace：

Nacos中的服务存储和数据存储的最外层都是一个名为namespace的东西，用来做外层隔离。
image.png

12.7.1 Nacos客户端新建命名空间：

image.png

image.png

image.png

12.7.2 修改服务到指定命名空间application.yml，添加namespace：

image.png

  1. spring:
  2.   cloud:
  3.     nacos:
  4.       server-addr: localhost:8848 #nacos 服务端地址
  5.       discovery:
  6.         cluster-name: CD #配置集群名称
  7.         namespace: 492a... #命名空间Id，填Id

12.7.3 Nacos环境隔离总结：

1》namespace用来做环境隔离
2》每个namespace都有唯一Id
2》不同namespace下的服务不可见

12.8 Nacos临时实例和非临时实例：

image.png

12.9 Nacos和Eureka的区别：

12.9.1 Nacos和Eureka的共同点：

1》、都支持服务注册和服务拉取。
2》、都支持服务提供者心跳的方式做健康检查。

12.9.2 Nacos和Eureka区别：

1》、Nacos支持服务端主动检测提供者状态:临时实例采用心跳模式，非临时实例采用主动检测模式。
2》、临时实例心跳不正常会被剔除，非临时实例则不会被剔除。
3》、Nacos支持服务列表变更的消息推送模式，服务列表更新更及时。
4》、Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式;Eureka采用AP方式。

13 Nacos配置管理：

13.1 Nacos实现统一配置管理：

13.1.1 配置更改热更新：

1》、在Nacos客户端配置：
image.png
2》、在弹出表单中填写配置信息：
image.png

13.1.2 微服务配置拉取：

获取配置的步骤如下：
image.png

13.1.2.1 步骤：

1》、引入Nacos的配置管理客户端依赖：

  1. <dependency>
  2.   <groupId>com.alibaba.cloud</groupId>
  3.   <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  4. </dependency>

2》、在服务提供项目中的resource目录添加一个bootstrap.yml文件，这个文件是引导文件，优先级高于application.yml：
image.png
image.png

总结：、

image.png

13.1.3 配置自动刷新：

Nacos中的配置文件变更后，微服务无需重启就可以感知。

方式一：在@Value注入变量所在的类上添加注解@RefreshScope：

image.png

方式二：使用@ConfigurationProperties注解：

image.png

总结：

image.png

13.1.4 Nacos多环境配置共享：

微服务启动时会从nacos读取多个配置文件：
. [spring.application.name]-[spring.profiles.active].yml,例如：userservice-dev.yml
. [spring.application.name].yml,例如：userservice.yaml

无论profile如何变化，[spring.application.name].yaml这个文件一定会加载，因此多环境共享配置可以写入这个配置文件
image.png

多环境配置优先级：

服务名-profile.yaml > 服务名称.yaml > 本地配置
image.png

总结：

image.png