[大数据]学习日志day74（2021-11-16）（1、微服务架构 2、Eureka服务搭建 3、Ribbon负载均衡 4、Feign简化服务间的调用）

学习内容：学习SpringCloud（Day74）

1、微服务架构
2、Eureka服务搭建
3、Ribbon负载均衡
4、Feign简化服务间的调用

1、微服务架构

（1）微服务架构是?种架构模式，它提倡将单?应?程序划分成?组?的服务，服务之间互相协调、互相配合，为?户提供最终价值。每个服务运?在其独?的进程中，服务与服务间采?轻量级的通信机制互相协作（通常是基于HTTP协议的RESTful API）。每个服务都围绕着具体业务进?构建，并且能够被独?的部署到?产环境、类?产环境等。另外，应当尽量避免统?的、集中式的服务管理机制，对具体的?个服务??，应根据业务上下?，选择合适的语?、?具对其进?构建。

（2）微服务技术栈：多种技术的集合

2、SpringCloud入门

（1）SpringCloud，基于SpringBoot提供了一套微服务解决方案，包括服务注册与发现，配置中心，全链路监控，服务网关，负载均衡，熔断器等组件，除了基于NetFlix的开源组件做高度抽象封装之外，还有一些选型中立的开源组件。

SpringCloud利用SpringBoot的开发便利性巧妙地简化了分布式系统基础设施的开发，SpringCloud为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等,它们都可以用SpringBoot的开发风格做到一键启动和部署。

SpringBoot专注于快速方便的开发单个个体微服务。SpringBoot可以离开SpringCloud独立使用开发项目，但是SpringCloud离不开SpringBoot，属于依赖的关系。SpringBoot专注于快速、方便的开发单个微服务个体，SpringCloud关注全局的服务治理框架。

（2）创建工程
1.pom父工程

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.hisoft</groupId>
<artifactId>springcloud</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springcloud</name>
<packaging>pom</packaging><!--打包方式：pom-->
<description>Demo project for Spring Boot</description>

<!--添加最新版依赖：Hoxton.SR8,暂时不加入其他任何依赖和插件-->
<properties>
    <java.version>1.8</java.version>
    <spring.cloud-version>Hoxton.SR8</spring.cloud-version>
</properties>

<dependencyManagement>
    <dependencies>
        <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>

2.Eureka服务搭建，创建子模块：pom

<parent>
    <artifactId>springcloud</artifactId>
    <groupId>com.hisoft</groupId>
    <version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>eureka-8761</artifactId>

<properties>
    <maven.compiler.source>10</maven.compiler.source>
    <maven.compiler.target>10</maven.compiler.target>
</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-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

子模块新建启动类

@SpringBootApplication
@EnableEurekaServer //启动Eureka服务
public class Eureka8761Application {
    public static void main(String[] args) {
        SpringApplication.run(Eureka8761Application.class,args);
    }
}

子模块创建application.yml，添加配置：

server:
  port: 8761   #服务端口号

eureka:
  instance:
    hostname: localhost  #服务主机
  client:
    #当前的Eureka服务是单机版的
    registerWithEureka: false #自己就是一个服务，不注册到Eureka服务器上
    fetchRegistry: false #不从注册表获取信息
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #可以写成http://localhost:8761/eureka/

启动服务，看到服务注册中心可以用

3.创建Eureka client模块customer服务，导入依赖

<parent>
    <artifactId>springcloud</artifactId>
    <groupId>com.hisoft</groupId>
    <version>0.0.1-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>customer-8080</artifactId>

<properties>
    <maven.compiler.source>10</maven.compiler.source>
    <maven.compiler.target>10</maven.compiler.target>
</properties>

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

    <!--Eureka客户端-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

</dependencies>

启动类添加注解@EnableEurekaClient

@SpringBootApplication
@EnableEurekaClient
public class Eureka8080Application {
    public static void main(String[] args) {
        SpringApplication.run(Eureka8080Application.class,args);
    }
}

编写配置文件

#指定Eureka服务地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ #注册到Eureka注册中心

#指定服务的名称
spring:
  application:
    name: CUSTOMER

启动EurakaClient，刷新服务页面可以看到注册表增加了一条。

4.创建search服务，和customer服务相似，yml需要修改服务名和端口号

#指定Eureka服务地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ #注册到Eureka注册中心

#指定服务的名称
spring:
  application:
    name: SEARCH

server:
  port: 8081

启动服务，刷新页面，已注册到Eureka

5.通过restTemplate访问服务
search模块添加SearchController接口，通过customer模块调用该接口

@RestController
public class SearchController {
    @GetMapping("search")
    public String search(){
        return "search";
    }
}

customer模块添加CustomerController接口，使用restTemplate访问search接口
为了使代码更简单，直接在启动类中注入bean

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

使用eurekaClient拿到search服务信息，再使用restTemplate访问

@RestController
public class CustomerController {
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private EurekaClient eurekaClient;

    @GetMapping("customer")
    public String customer(){
        //1.通过EurekaClient获取Search服务信息
        InstanceInfo info = eurekaClient.getNextServerFromEureka("SEARCH",false);
        //2.获取到访问的地址
        String url = info.getHomePageUrl();
        //3.通过RestTemplate访问
        String result = restTemplate.getForObject(url + "/search", String.class);
        //4.返回
        return result;
    }
}

重启两个模块，访问localhost:8080/customer,访问成功

（3）Eureka安全性
Eureka服务模块导入依赖

<!--安全框架-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

编写配置类

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().ignoringAntMatchers("/eureka/**");//忽略eureka服务的同源控制
        super.configure(http);
    }

}

编写配置文件

#登录服务ui需要账号密码
spring:
  security:
    user:
      name: root
      password: root

重启Eureka服务，访问页面，需要输入用户名和密码才能访问。
但是登录进去之后，发现没有服务，控制台也有报错，此时必须在其他服务也要添加用户名和密码才能注册到Eureka

#指定Eureka服务地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://root:root@localhost:8761/eureka/ #注册到Eureka注册中心，加上用户名和密码

（4）自我保护模式
默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。一旦进入该模式，EurekaServer就会保护服务注册表中的信息，不再删除服务注册表中的数据（也就是不会注销任何微服务）。当网络故障恢复后，该Eureka Server节点会自动退出自我保护模式。
在自我保护模式中，Eureka Server会保护服务注册表中的信息，不再注销任何服务实例。当它收到的心跳数重新恢复到阈值以上时，该Eureka Server节点就会自动退出自我保护模式。它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。
在Spring Cloud中，可以使用eureka.server.enable-self-preservation = false 禁用自我保护模式。
在Eureka服务模块配置

eureka:
  server:
    enable-self-preservation: false

（5）Eureka的高可用
如果程序正在运行，突然宕机了
1.如果调用方访问过被调用方，Eureka的宕机不会影响功能
2.如果调用方没有访问过被调用方，Eureka的宕机就会造成当前功能的不可用

搭建高可用：使用Eureka集群，搭建多台Eureka服务，所有服务都注册到多台Eureka机器上，并且多台Eureka之间是数据互通的。
1.采用复制方式，删除iml和target文件，修改pom中的项目名称，修改所有8761为8762，给父工程添加一个module。
2.服务注册到多台Eureka：修改customer和search模块的yml，在defaultZone后再添加新的服务地址，逗号隔开

defaultZone: http://root:root@localhost:8761/eureka/,http://root:root@localhost:8762/eureka/

3.相互通讯：所有Eureka的yml中两个false修改为true，修改defaultZone端口，以便注册到另一个Eureka服务上

server:
  port: 8762   #服务端口号

eureka:
  instance:
    hostname: localhost  #服务主机
  client:
    registerWithEureka: true 
    fetchRegistry: true 
    serviceUrl:
      defaultZone: http://root:root@localhost:8761/eureka/ #注册到Eureka8761
  server:
    enable-self-preservation: true #自我保护

#登录服务ui需要账号密码
spring:
  security:
    user:
      name: root
      password: root
  application:
    name: EUREKA-8762

（6）Eureka启动细节
1.EurekaClient启动时，将自己的信息注册到EurekaServer上，EurekaServer就会存储有EurekaClient的注册信息
2.当EurekaClient调用服务时，本地没有注册信息的缓存时，去EurekaServer中去获取注册信息
3.EurekaClient会通过心跳的方式和EurekaServer链接。（默认30秒EurekaClient会发送一次心跳请求，如果超过90秒没有发送，EurekaServer就认为你宕机，从注册表移除注册信息）

eureka:
  instance:
    lease-renewal-interval-in-seconds: 30 #心跳的间隔
    lease-expiration-duration-in-seconds: 90 #多久没发送就认为宕机

4.EurekaClient每隔30秒从注册中心更新本地注册表

eureka:
  client:
    registry-fetch-interval-seconds: 30 #每隔30秒从注册中心更新本地注册表

5.Eureka自我保护机制，统计15分钟内，如果一个服务的心跳发送比例低于85%，EurekaServer就会开启自我保护机制。
不会从EurekaServer中移除长时间没有收到心跳的服务
EurekaServer正常提供服务
网络稳定时，会开始将自己的信息同步到其他节点

eureka:
  server:
    enable-self-preservation: true

（7）作为服务注册中心，Eureka比Zookeeper好在哪里
著名的CAP理论指出，一个分布式系统不可能同时满足C(一致性)、A(可用性)和P(分区容错性)。由于分区容错性P在是分布式系统中必须要保证的，因此我们只能在A和C之间进行权衡。

Zookeeper保证的是CP
当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的注册信息，但不能接受服务直接down掉不可用。也就是说，服务注册功能对可用性的要求要高于一致性。但是zk会出现这样一种情况，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新进行leader选举。问题在于，选举leader的时间太长，30 ~ 120s, 且选举期间整个zk集群都是不可用的，这就导致在选举期间注册服务瘫痪。在云部署的环境下，因网络问题使得zk集群失去master节点是较大概率会发生的事，虽然服务能够最终恢复，但是漫长的选举时间导致的注册长期不可用是不能容忍的。

Eureka则是AP
Eureka看明白了这一点，因此在设计时就优先保证可用性。Eureka各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个Eureka注册或时如果发现连接失败，则会自动切换至其它节点，只要有一台Eureka还在，就能保证注册服务可用(保证可用性)，只不过查到的信息可能不是最新的(不保证强一致性)。除此之外，Eureka还有一种自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳，那么Eureka就认为客户端与注册中心出现了网络故障，此时会出现以下几种情况：
1.Eureka不再从注册列表中移除因为长时间没收到心跳而应该过期的服务
2.Eureka仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上(即保证当前节点依然可用)
3.当网络稳定时，当前实例新的注册信息会被同步到其它节点中
因此， Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像zookeeper那样使整个注册服务瘫痪。

3、Ribbon负载均衡

（1）Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。
Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。

LB，即负载均衡(Load Balance)，在微服务或分布式集群中经常用的一种应用。
负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）。
常见的负载均衡有软件Nginx，LVS，硬件 F5等。相应的在中间件，例如：dubbo和SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义。

（2）Ribbon配置
启动两个search模块，复制一个启动配置，vmoption加入参数：-Dserver.port=8082

Customer模块导入ribbon依赖

<!--负载均衡-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

配置整合RestTemplate和ribbon
启动类RestTemplate的@Bean下添加注解：@LoadBalanced

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

CustomerController中访问search，调用不再需要EurekaClient,直接使用服务名获取服务信息

@GetMapping("customer")
public String customer(){
    String result = restTemplate.getForObject("http://SEARCH/search", String.class);
    return result;
}

为方便比较效果，修改SearchController

@RestController
public class SearchController {
    @Value("${server.port}")
    private String port;
    @GetMapping("search")
    public String search(){
        return "search" + port;
    }
}

Ribbon配置自定义负载均衡策略
1.RandomRule:随机策略
2.RoundRobbinRule:轮询策略
3.WeightedResourceTimeRule:默认采用轮询，后续会根据服务的响应时间，自动分配权重
4.BestAvailableRule:根据被调用方并发最小的分配

注解方式配置
1.在Customer的启动类中

@Bean
public IRule ribbonRule(){
    return new RandomRule();
}

2.配置文件制定方式，制定具体服务的负载均衡策略，在customer模块的配置文件

#指定具体服务的负载均衡策略
SEARCH: #编写服务名称
  ribbon:
    NFloadBalancerRuleClassName: com.netflix.loadblancer.WeightedResponseTimeRule

4、Feign简化服务间的调用

（1）Feign可以实现让我们面向接口编程，直接调用其他服务，简化开发。
Customer模块导入依赖

<!--服务间的调用-Feign-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

在customer的启动类上添加@EnableFeignClients注解

创建一个接口，和search模块映射

@FeignClient("SEARCH")//指定服务名称
public interface SearchClient{
    @RequestMapping(value = "search",method = RequestMethod.GET)
    String search();
}

CustomerController中调用search模块

@RestController
public class CustomerController {
    @Autowired
    private SearchClient searchClient;

    @GetMapping("customer")
    public String customer(){
        return searchClient.search();
    }
}

浏览器输入访问路径：http://localhost:8080/customer