SpringCloud学习Day1

1.基本的杂乱概念

CAP

分布式中的CAP原理
现如今，对于多数大型互联网应用，分布式系统（distributed system）正变得越来越重要。分布式系
统的最大难点，就是各个节点的状态如何同步。CAP 定理是这方面的基本定理，也是理解分布式系统的
起点。
CAP理论由 Eric Brewer 在ACM研讨会上提出，而后CAP被奉为分布式领域的重要理论。分布式系统的
CAP理论，首先把分布式系统中的三个特性进行了如下归纳：
Consistency（一致性）：数据一致更新，所有数据的变化都是同步的
Availability（可用性）：在集群中一部分节点故障后，集群整体是否还能响应客户端的读写请求
Partition tolerance（分区容忍性）：某个节点的故障，并不影响整个系统的运行

2.SpringCloud概述

2.1 微服务中的相关概念

2.1.1 服务注册与发现

**服务注册：**服务实例将自身服务信息注册到注册中心。这部分服务信息包括服务所在主机IP和提供服务
的Port，以及暴露服务自身状态以及访问协议等信息。
**服务发现：**服务实例请求注册中心获取所依赖服务信息。服务实例通过注册中心，获取到注册到其中的
服务实例的信息，通过这些信息去请求它们提供的服务。

2.1.2 负载均衡

负载均衡是高可用网络基础架构的关键组件，通常用于将工作负载分布到多个服务器来提高网站、应
用、数据库或其他服务的性能和可靠性。

2.1.3 熔断

熔断这一概念来源于电子工程中的断路器（Circuit Breaker）。在互联网系统中，当下游服务因访问压
力过大而响应变慢或失败，上游服务为了保护系统整体的可用性，可以暂时切断对下游服务的调用。这
种牺牲局部，保全整体的措施就叫做熔断。

2.1.4 链路追踪

随着微服务架构的流行，服务按照不同的维度进行拆分，一次请求往往需要涉及到多个服务。互联网应
用构建在不同的软件模块集上，这些软件模块，有可能是由不同的团队开发、可能使用不同的编程语言
来实现、有可能布在了几千台服务器，横跨多个不同的数据中心。因此，就需要对一次请求涉及的多个
服务链路进行日志记录，性能监控即链路追踪

2.1.5 API网关

随着微服务的不断增多，不同的微服务一般会有不同的网络地址，而外部客户端可能需要调用多个服务
的接口才能完成一个业务需求，如果让客户端直接与各个微服务通信可能出现：
客户端需要调用不同的url地址，增加难度
再一定的场景下，存在跨域请求的问题
每个微服务都需要进行单独的身份认证
针对这些问题，API网关顺势而生。
API网关直面意思是将所有API调用统一接入到API网关层，由网关层统一接入和输出。一个网关的基本
功能有：统一接入、安全防护、协议适配、流量管控、长短链接支持、容错能力。有了网关之后，各个
API服务提供团队可以专注于自己的的业务逻辑处理，而API网关更专注于安全、流量、路由等问题。

2.2 SpringCloud的介绍

它利用Spring Boot的开发便利性巧妙地简化了分布式系统基
础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用
Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将目前各家
公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉
了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具
包。

2.3 SpringCloud的架构

2.3.1 SpringCloud中的核心组件

Spring Cloud Netflix组件

Spring Cloud Alibaba组件

Spring Cloud原生及其他组件

2.3.2 SpringCloud的体系结构

从上图可以看出Spring Cloud各个组件相互配合，合作支持了一套完整的微服务架构。
注册中心负责服务的注册与发现，很好将各服务连接起来
断路器负责监控服务之间的调用情况，连续多次失败进行熔断保护。
API网关负责转发所有对外的请求和服务
配置中心提供了统一的配置信息管理服务,可以实时的通知各个服务获取最新的配置信息
链路追踪技术可以将所有的请求数据记录下来，方便我们进行后续分析
各个组件又提供了功能完善的dashboard监控平台,可以方便的监控各组件的运行状况

3 案例搭建

通过RestTemplate调用网络方法

需要有一个已经在运行的项目（服务提供者product）

Bean层代码

/**
 * 商品实体类
 */
@Data
@Entity
@Table(name="tb_product")
public class Product {

	@Id
	private Long id;
	private String productName;
	private Integer status;
//	private BigDecimal price;
	private String productDesc;
	private String caption;
	private Integer inventory;
}

Dao层代码

/**
 * 接口继承    
 * 
 * 继承这个Jpa和MybatisPlus一样		可以实现一些简单的		增删改查
 */
public interface ProductDao extends JpaRepository<Product,Long>, JpaSpecificationExecutor<Product> {

}

Service层代码：

@Service
public class ProductServiceImpl implements ProductService {

	@Autowired
	private ProductDao productDao;

	@Override
	public Product findById(Long id) {
		return productDao.findById(id).get();
	}

	@Override
	public void save(Product product) {
		productDao.save(product);
	}

	@Override
	public void update(Product product) {
		productDao.save(product);
	}

	@Override
	public void delete(Long id) {
		productDao.deleteById(id);
	}
}

Controller层代码

@RestController
@RequestMapping("/product")
public class ProductController {

	@Autowired
	private ProductService productService;

	@RequestMapping(value = "/{id}",method = RequestMethod.GET)
	public Product findById(@PathVariable Long id) {
		Product product = productService.findById(id);
		return product;
	}

	@RequestMapping(value = "",method = RequestMethod.POST)
	public String save(@RequestBody Product product) {
		productService.save(product);
		return "保存成功";
	}
}

3.5 服务调用

3.5.1 RestTemplate介绍

Spring框架提供的RestTemplate类可用于在应用中调用rest服务，它简化了与http服务的通信方式，统
一了RESTful的标准，封装了http链接， 我们只需要传入url及返回值类型即可。相较于之前常用的
HttpClient，RestTemplate是一种更优雅的调用RESTful服务的方式。

在Spring应用程序中访问第三方REST服务与使用Spring RestTemplate类有关。RestTemplate类的设计
原则与许多其他Spring 模板类(例如JdbcTemplate、JmsTemplate)相同，为执行复杂任务提供了一种具
有默认行为的简化方法。
RestTemplate默认依赖JDK提供http连接的能力（HttpURLConnection），如果有需要的话也可以通过
setRequestFactory方法替换为例如 Apache HttpComponents、Netty或OkHttp等其它HTTP library。
考虑到RestTemplate类是为调用REST服务而设计的，因此它的主要方法与REST的基础紧密相连就不足
为奇了，后者是HTTP协议的方法:HEAD、GET、POST、PUT、DELETE和OPTIONS。例如，
RestTemplate类具有headForHeaders()、getForObject()、postForObject()、put()和delete()等方法。

3.5.3 通过RestTemplate调用微服务

服务消费者：
首先在启动类里创建bean

@SpringBootApplication
@EntityScan("cn.itcast.order.entity")
//激活eurekaClient
//@EnableEurekaClient
//@EnableDiscoveryClient
public class OrderApplication {
    /**
     * 使用Spring提供的RestTemplate发送请求
     * 1.创建RestTemplate的bean
     * 2.调用其方法
     */
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

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

在controller层调用其方法 会出现没有实体类的错误 需要导入一个服务调用者层的实体类

@RestController
@RequestMapping("/order")
public class OrderController {
	//注入restTemplate对象
	@Autowired
	private RestTemplate restTemplate;
	/**
	 * 基于ribbon的形式调用远程微服务
	 *  1.使用@LoadBalanced声明RestTemplate
	 *  2.使用服务名称替换ip地址
	 */
	@RequestMapping(value = "/buy/{id}",method = RequestMethod.GET)
	public Product findById(@PathVariable Long id) {
		Product product = null;
		//第一个是服务的请求地址，第二个是转换成哪个类
		product = restTemplate.getForObject("http://localhost:9001/product/"+id,Product.class);
		return product;
	}
}

SpringCloud注册中心

主要作用

服务注册中心（下称注册中心）是微服务架构非常重要的一个组件，在微服务架构里主要起到了协调者
的一个作用。注册中心一般包含如下几个功能：

1. 服务发现：
   服务注册/反注册：保存服务提供者和服务调用者的信息
   服务订阅/取消订阅：服务调用者订阅服务提供者的信息，最好有实时推送的功能
   服务路由（可选）：具有筛选整合服务提供者的能力。
2. 服务配置：
   配置订阅：服务提供者和服务调用者订阅微服务相关的配置
   配置下发：主动将配置推送给服务提供者和服务调用者
3. 服务健康检测
   检测服务提供者的健康情况

Eureka的概述

Eureka的基础知识

Eureka是Netflix开发的服务发现框架，SpringCloud将它集成在自己的子项目spring-cloud-netflix中，
实现SpringCloud的服务发现功能。

上图简要描述了Eureka的基本架构，由3个角色组成：
1、Eureka Server
提供服务注册和发现
2、Service Provider
服务提供方
将自身服务注册到Eureka，从而使服务消费方能够找到
3、Service Consumer
服务消费方
从Eureka获取注册服务列表，从而能够消费服务

3.2.2 Eureka的交互流程与原理

图是来自Eureka官方的架构图，大致描述了Eureka集群的工作过程。图中包含的组件非常多，可能比较难以理解，我们用通俗易懂的语言解释一下：’
Application Service 相当于本书中的服务提供者，Application Client相当于服务消费者；
Make Remote Call，可以简单理解为调用RESTful API；
us-east-1c、us-east-1d等都是zone，它们都属于us-east-1这个region；
由图可知，Eureka包含两个组件：Eureka Server 和 Eureka Client，它们的作用如下：

Eureka Client是一个Java客户端，用于简化与Eureka Server的交互
Eureka Server提供服务发现的能力，各个微服务启动时，会通过Eureka Client向Eureka Server
进行注册自己的信息（例如网络信息），Eureka Server会存储该服务的信息；
微服务启动后，会周期性地向Eureka Server发送心跳（默认周期为30秒）以续约自己的信息。如
果Eureka Server在一定时间内没有接收到某个微服务节点的心跳，Eureka Server将会注销该微服务节点（默认90秒）；
每个Eureka Server同时也是Eureka Client，多个Eureka Server之间通过复制的方式完成服务注册表的同步
Eureka Client会缓存Eureka Server中的信息。即使所有的Eureka Server节点都宕掉，服务消费
者依然可以使用缓存中的信息找到服务提供者。

综上，Eureka通过心跳检测、健康检查和客户端缓存等机制，提高了系统的灵活性、可伸缩性和可用
性。

3.3 搭建Eureka注册中心

(1) 在 shop_parent 下创建子模块 shop_eureka_server

(2) 引入maven坐标
（这里有个坑 有时候包抱红把本地仓库的包删了 再重新上弄就可以了）

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

(3) 配置application.yml

server:
  port: 9000
eureka:
  instance:
    hostname: locast
  client:
    register-with-eureka: false #是否将自己注册到注册中心
    fetch-registry: false #是否从eureka中获取注册信息
    service-url: #设置服务的请求地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

(4) 配置启动类

@SpringBootApplication
//激活eurekaService
@EnableEurekaServer
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }

}

@ EnableEurekaServer 注解作用: 激活Eureka Server端配置

3.4 服务注册到Eureka注册中心

3.4.1 商品服务注册

(1) 商品模块中引入坐标
在 shop_service_product 的pom文件中添加eureka client的相关坐标

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-commons</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

(2) 配置application.yml文件
在工程的 application.yml 中添加Eureka Server的主机地址

eureka:
 client:
   serviceUrl: # eureka server的路径
     defaultZone: http://localhost:9000/eureka/
 instance:
   prefer-ip-address: true #使用ip注册

(3) 修改启动类添加服务注册注解

@SpringBootApplication
@EntityScan("cn.itcast.product.entity")
//激活eurekaClient
@EnableEurekaClient
//@EnableDiscoveryClient
public class ProductApplication {
	public static void main(String[] args) {
		SpringApplication.run(ProductApplication.class,args);
	}
}

3.4.2 订单服务注册

和商品微服务一样,只需要引入坐标依赖,在工程的 application.yml 中添加Eureka Server的主机地址
即可

3.4.3 用户服务注册

和商品微服务一样,只需要引入坐标依赖,在工程的 application.yml 中添加Eureka Server的主机地址
即可

3.4.4消费者调用服务

首先在controller层注入

/**
	 * z注入DiscoveryClient
	 * springcloud获取元数据的工具类
	 */
	@Autowired
	private DiscoveryClient discoveryClient;

具体类：

@RestController
@RequestMapping("/order")
public class OrderController {
    //注入restTemplate对象
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 注入DiscoveryClient
     * springcloud获取元数据的工具类
     */
    @Autowired
    private DiscoveryClient discoveryClient;

    /**
     * 基于ribbon的形式调用远程微服务
     * 1.使用@LoadBalanced声明RestTemplate
     * 2.使用服务名称替换ip地址
     */
    @RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id) {
        //调用DiscoveryClient方法   这个里面封装了 "SERVICE-PRODUCT" 的ip地址等等信息
        List< ServiceInstance > instances = discoveryClient.getInstances("SERVICE-PRODUCT");
        ServiceInstance serviceInstance = instances.get(0);

        //定义一个Product类
        Product product = null;
        //第一个是请求地址，第二个是转换成哪个类
        product = restTemplate.getForObject("http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/product/" + id, Product.class);

        return product;
    }
}

4 服务注册Eureka高级

4.1 Eureka Server 高可用集群

之前实现了单节点的Eureka Server的服务注册与服务发现功能。Eureka Client会定时连接
Eureka Server，获取注册表中的信息并缓存到本地。微服务在消费远程API时总是使用本地缓存中的数
据。因此一般来说，即使Eureka Server发生宕机，也不会影响到服务之间的调用。但如果Eureka
Server宕机时，某些微服务也出现了不可用的情况，Eureka Server中的缓存若不被刷新，就可能会影
响到微服务的调用，甚至影响到整个应用系统的高可用。因此，在生成环境中，通常会部署一个高可用
的Eureka Server集群。
Eureka Server可以通过运行多个实例并相互注册的方式实现高可用部署，Eureka Server实例会彼此增
量地同步信息，从而确保所有节点数据一致。事实上，节点之间相互注册是Eureka Server的默认行
为。

4.1.1 搭建 Eureka Server高可用集群

直接创建多个eureka 在eureka中填写其他的eureka服务器的地址
eureka（服务器）配置文件如下

server:
  port: 9000

#设置服务应用名字
spring:
  application:
    name: eureak-server1

#配置eureka服务
eureka:
  client:
    serviceUrl: # eureka server的路径  写另外一个eureka的路径
      defaultZone: http://localhost:8000/eureka/
  instance:
    prefer-ip-address: true #使用ip注册

在其他应用服务（客户端）注册到eureka中的时候 注册到多个eureka可以在defaultZone中用 ， 分割多个地址
如下：

eureka:
  client:
    serviceUrl: # eureka server的路径
      defaultZone: http://localhost:9000/eureka/,http://localhost:8000/eureka/
  instance:
    prefer-ip-address: true #使用ip注册

如何在控制台显示服务的ip 添加（客户端）如下属性

eureka:
  instance:
    instance-id: ${spring.cloud.client.ip-address}:${server.port} #向注册中心注册服务的ip  从配置中的获取

在测试阶段如何避免 等待服务剔除的时间长 在需要的服务上（客户端）添加如下属性

eureka:
  instance:
    lease-expiration-duration-in-seconds: 10 #没有发送心跳的剔除时间
    lease-renewal-interval-in-seconds: 5 #心跳间隔

（服务器）关闭自我保护机制和服务剔除时间

#配置eureka服务
eureka:
  server:
    enable-self-preservation: false #关闭自我保护机制
    eviction-interval-timer-in-ms: 5000 #设置服务剔除时间
    

5 Consul

5.1 Consul安装

https://www.consul.io/downloads 官网下载consul
然后解压到本地
在安装目录打开cmd 执行 consul agent -dev -client=0.0.0.0
等待一会就可以启动成功了
访问地址 127.0.0.1:8500

5.3 consul的基本使用

需要有两个基础的微服务模块 参考前面

服务提供者修改
首先在服务提供者导入依赖

  <!--SpringCloud提供的基于Consul的服务发现-->
 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</artifactId>
        </dependency>
 <!--actuator用于心跳检查-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

修改服务提供者的yam配置文件

spring:
	cloud:
	  consul:
	    host: 127.0.0.1 #主机地址
	    port: 8500 # 端口
	    discovery:
	      #是否注册
	      register: true
	      #实例ID
	      instance-id: ${spring.application.name}-1
	      #服务实例名称
	      service-name: ${spring.application.name}
	      #服务实例端口
	      port: ${server.port}
	      #健康检查路径
	      healthCheckPath: /actuator/health
	      #健康检查时间间隔
	      healthCheckInterval: 15s
	      #开启ip地址注册
	      prefer-ip-address: true
	      #实例的请求ip
	      ip-address: ${spring.cloud.client.ip-address}

服务消费者修改
和提供者一样 导入依赖 修改yml
在启动类的bean上加上一个注解看代码 和之前实现eruark一样

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

修改contorller层代码

//        product = restTemplate.getForObject("http://ip:post/product/" + id, Product.class);
        product = restTemplate.getForObject("http://service-product/product/" + id, Product.class);

执行测试

5.6 consul高可用集群

5.6.1 准备环境

准备几台虚拟机
并配置：

##从官网下载最新版本的Consul服务
wget https://releases.hashicorp.com/consul/1.5.3/consul_1.5.3_linux_amd64.zip
##使用unzip命令解压
unzip consul_1.5.3_linux_amd64.zip
##将解压好的consul可执行命令拷贝到/usr/local/bin目录下
cp consul /usr/local/bin
##测试一下
consul

启动每个consul server节点

##登录s1虚拟机，以server形式运行
consul agent -server -bootstrap-expect 3 -data-dir /etc/consul.d -node=server-1
-bind=192.168.74.101 -ui -client 0.0.0.0 &
##登录s2 虚拟机，以server形式运行
consul agent -server -bootstrap-expect 2 -data-dir /etc/consul.d -node=server-2
-bind=192.168.74.102 -ui -client 0.0.0.0 &
##登录s3 虚拟机，以server形式运行
consul agent -server -bootstrap-expect 2 -data-dir /etc/consul.d -node=server-3
-bind=192.168.74.103 -ui -client 0.0.0.0 &

此三个Consul Server模式服务全部启动成功

##在本地电脑中使用client形式启动consul
consul agent -client=0.0.0.0  -data-dir /etc/consul.d -node=client-1

测试
在任意一台服务器中输入 consul members查看集群中的所有节点信息

##查看consul集群节点信息
consul members

调用方式参考erueak

6 服务调用Ribbon入门

经过以上的学习，已经实现了服务的注册和服务发现。当启动某个服务的时候，可以通过HTTP的形式
将信息注册到注册中心，并且可以通过SpringCloud提供的工具获取注册中心的服务列表。但是服务之
间的调用还存在很多的问题，如何更加方便的调用微服务，多个微服务的提供者如何选择，如何负载均
衡等。

6.1什么是Ribbon

是 Netflixfa 发布的一个负载均衡器，有助于控制 HTTP 和 TCP客户端行为。在 SpringCloud 中，
Eureka一般配合Ribbon进行使用，Ribbon提供了客户端负载均衡的功能，Ribbon利用从Eureka中读
取到的服务信息，在调用服务节点提供的服务时，会合理的进行负载。
在SpringCloud中可以将注册中心和Ribbon配合使用，Ribbon自动的从注册中心中获取服务提供者的
列表信息，并基于内置的负载均衡算法，请求服务

6.2 Ribbon的主要作用

（1）服务调用
基于Ribbon实现服务调用， 是通过拉取到的所有服务列表组成（服务名-请求路径的）映射关系。借助
RestTemplate 最终进行调用
（2）负载均衡
当有多个服务提供者时，Ribbon可以根据负载均衡的算法自动的选择需要调用的服务地址

6.3 基于Ribbon实现订单调用商品服务

不论是基于Eureka的注册中心还是基于Consul的注册中心，SpringCloudRibbon统一进行了封装，所
以对于服务调用，两者的方式是一样的。

6.3.1 坐标依赖

在springcloud提供的服务发现的jar中以及包含了Ribbon的依赖。所以这里不需要导入任何额外的坐标

6.3.2 工程改造

修改服务消费者
修改服务消费者 shop_service_order模块中的启动类OrderApplication ，在创建RestTemplate方法
上添加 @LoadBalanced 注解

@SpringBootApplication
@EntityScan("cn.itcast.order.entity")
//激活eurekaClient
@EnableEurekaClient
//@EnableDiscoveryClient
public class OrderApplication {
    /**
     * 使用Spring提供的RestTemplate发送请求
     * 1.创建RestTemplate的bean
     * 2.调用其方法
     */
    @LoadBalanced//只添加了这个注解
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

在 shop_service_order的OrderController 中改变getForObject的地址，并使用RestTemplate完成服务调用

@RestController
@RequestMapping("/order")
public class OrderController {
    //注入restTemplate对象
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 注入DiscoveryClient
     * springcloud获取元数据的工具类
     */
    @Autowired
    private DiscoveryClient discoveryClient;


    /**
     * 基于ribbon的形式调用远程微服务
     * 1.使用@LoadBalanced声明RestTemplate
     * 2.使用服务名称替换ip地址
     */
    @RequestMapping(value = "/buy/{id}", method = RequestMethod.GET)
    public Product findById(@PathVariable Long id) {
        //定义一个Product类
        Product product = null;
        //第一个是请求地址，第二个是转换成哪个类
        product = restTemplate.getForObject("http://service-product/product/" + id, Product.class);
        return product;
    }
    }

主要的是替换了这两句：

product = restTemplate.getForObject("http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/product/" + id, Product.class);

替换为：

product = restTemplate.getForObject("http://service-product/product/" + id, Product.class);

需要说明的是
中间的请求地址和端口 替换为为了服务提供者（Product）的spring.application.name 属性，他的属性为：service-product

6.3.3 代码测试

浏览器中请求http://localhost:9001/order/buy/1查看展示效果如下，已经可以在订单微服务中已服务
名称的形式调用商品微服务获取数据

7 服务调用Ribbon高级

7.1 负载均衡概述

7.1.1 什么是负载均衡

在搭建网站时，如果单节点的 web服务性能和可靠性都无法达到要求；或者是在使用外网服务时，经常
担心被人攻破，一不小心就会有打开外网端口的情况，通常这个时候加入负载均衡就能有效解决服务问
题。
负载均衡是一种基础的网络服务，其原理是通过运行在前面的负载均衡服务，按照指定的负载均衡算
法，将流量分配到后端服务集群上，从而为系统提供并行扩展的能力。
负载均衡的应用场景包括流量包、转发规则以及后端服务，由于该服务有内外网个例、健康检查等功
能，能够有效提供系统的安全性和可用性

7.1.2 客户端负载均衡与服务端负载均衡

服务端负载均衡
先发送请求到负载均衡服务器或者软件，然后通过负载均衡算法，在多个服务器之间选择一个进行访
问；即在服务器端再进行负载均衡算法分配
客户端负载均衡
客户端会有一个服务器地址列表，在发送请求前通过负载均衡算法选择一个服务器，然后进行访问，这
是客户端负载均衡；即在客户端就进行负载均衡算法分配

7.2 基于Ribbon实现负载均衡

7.2.1 修改轮询策略

在启动类上加了@LoadBalanced注解后就已经默认启动了负载均衡的模式，默认为轮询模式
在访问的时候就会每一个服务访问一次
如何修改他的模式
只需要在 服务调用者的application.yml文件里修改即可
设置属性

service-product:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #设置负载均衡的策略

策略有

7.3 重试机制

7.3.1首先引入依赖

<dependency>
            <groupId>org.springframework.retry</groupId>
            <artifactId>spring-retry</artifactId>
            <version>1.2.4.RELEASE</version>
</dependency>

7.3.2 修改配置

注意看下对应项的配置