SpringCloud

干嘛的

单体架构：将业务的所有功能集中在一个项目中开发，部署为一个服务

• 优点：架构简单 开发方便 部署成本低
• 问题：耦合度太高,不利于扩容 分布式架构：根据业务功能对系统进行模块拆分，每个业务模块部署为一个服务
• 优点：降低服务耦合 有利于服务升级拓展
• 问题：服务之间如何调用？服务关系如何管理？

微服务：微服务是一种经过良好架构设计的分布式架构方案。Java领域可以使用SpringCloud提供的方案.

结论：分布式架构是理论 微服务是实现这套理论的手段，而手段的底层技术是微服务框架springCloud技术

SpringCloud的组件

• 服务注册发现:Eureka,Nacos,Consul
• 服务远程调用:OpenFeign,Dubbo
• 服务链路监控:Zipkin,Sleuth
• 统一配置管理:SpringCloudConfig,Nacos
• 统一网关路由:SpringCloudGateway,Zuul
• 流控(流量控制),降级,保护:Hystix,Sentinel ps:流控可以控制数据传输的进程，防止数据的丢失。数据在两个串口之间传输时，当通讯双方速率不匹配时，常常会出现丢失数据的现象。

搭建环境

父工程依赖

<modules>
    <module>user-service</module>
    <module>order-service</module>
</modules>

<properties>
    <!--指定使用那个jdk版本进行编译-->
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
    <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
    <mysql.version>5.1.47</mysql.version>
    <mybatis.version>2.1.1</mybatis.version>
</properties>


<dependencyManagement>
    <dependencies>
        <!-- springCloud -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

RestTemplate

Spring提供了一个RestTemplate模板工具类，对基于Http的客户端进行了封装

并且自动实现了对象与json的序列化和反序列化

启动类中注册RestTemplate

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {

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

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

调用服务

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

   @Autowired
   private OrderService orderService;
   @Autowired
   private RestTemplate restTemplate;

    @GetMapping("{orderId}")
    public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
        // 根据id查询订单并返回
        Order order = orderService.queryOrderById(orderId);
        //获取订单用户id
        Long userId = order.getUserId();
        //查询用户,并将json封装成user对象
        String url="http://localhost:9999/user/"+userId;
        User user = restTemplate.getForObject(url, User.class);
        //封装进订单
        order.setUser(user);
        return order;
    }
}

消费者与提供者

• 服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）
• 服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口） 两者关系是相对的,一个服务既可以是提供者,也可以是消费者

存在的问题

1. 服务消费者该如何获取服务提供者的最新地址信息？
2. 如果有多个服务提供者，消费者该如何选择？
3. 消费者如何得知服务提供者的健康状态？

注册中心-Eureka

Eureka基础架构

• 消费者该如何获取服务提供者具体信息？

  • 服务提供者启动时向eureka注册自己的信息
  • eureka保存这些信息
  • 消费者根据服务名称向eureka拉取提供者信息

• 如果有多个服务提供者，消费者该如何选择？

  • 服务消费者利用负载均衡算法，从服务列表中挑选一个

• 消费者如何感知服务提供者健康状态？

  • 服务提供者会每隔30秒向EurekaServer发送心跳请求，报告健康状态
  • eureka会更新记录服务列表信息，心跳不正常会被剔除
  • 消费者就可以拉取到最新的信息

搭建EurekaServer

（1）创建项目，引入spring-cloud-starter-netflix-eureka-server的依赖

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

（2）编写启动类，添加@EnableEurekaServer注解

@SpringBootApplication
@EnableEurekaServer
public class EurkaServerApplication {

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

（3）添加application.yml文件

server:
  port: 10086
spring:
  application:
    name: eureka-server
eureka:
  client:
    service-url:
      defaultZone: http://localhost:10086/eureka

服务注册

将user-service服务注册到EurekaServer步骤如下

（1）在user-service项目引入spring-cloud-starter-netflix-eureka-client的依赖

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

（2）在application.yml文件，编写下面的配置

spring:
  application:
    name: user-service
eureka:
  client:
    service-url:
      defaultZone: http://localhost:9812/eureka 

服务发现

（1）在order-service项目引入spring-cloud-starter-netflix-eureka-client的依赖

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

（2）在application.yml文件，编写下面的配置

 spring:
   application:
     name: order-service
 eureka:
   client:
     service-url:
       defaultZone: http://localhost:9812/eureka 

服务自动拉取是基于服务名称获取服务列表

服务名称=ip+端口

（1）修改OrderService的代码，修改访问的url路径，用服务名代替ip、端口：

 String url = "http://user-service/user/" + userId;

（2）在order-service项目的启动类OrderApplication中的RestTemplate添加负载均衡注解

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

对服务做负载均衡

• @LoadBalanced：负载均衡注解(默认是轮询)

Ribbon

负载均衡是一种基础的网络服务，其原理是通过运行在前面的负载均衡服务，按照指定的负载均衡算法，将流量分配到后端服务集群上，从而为系统提供并行扩展的能力。

Eureka中内置了Ribbon

负载均衡策略

Ribbon内置了多种负载均衡策略，内部负责复杂均衡的顶级接口为com.netflix.loadbalancer.IRule

内置负载均衡规则类	规则描述
RoundRobinRule	简单轮巡服务列表来选择服务器。它是Ribbon默认的负载均衡规则。
AvailabilityFilteringRule	对以下两种服务器进行忽略： （1）在默认情况下，这台服务器如果3次连接失败，这台服务器就会被设置为“短路”状态。短路状态将持续30秒，如果再次连接失败，短路的持续时间就会几何级地增加。 （2）并发数过高的服务器。如果一个服务器的并发连接数过高，配置了AvailabilityFilteringRule规则的客户端也会将其忽略。并发连接数的上限，可以由客户端的ActiveConnectionsLimit属性进行配置。
WeightedResponseTimeRule	为每一个服务器赋予一个权重值。服务器响应时间越长，这个服务器的权重就越小。这个规则会随机选择服务器，这个权重值会影响服务器的选择。
ZoneAvoidanceRule	以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。
BestAvailableRule	忽略哪些短路的服务器，并选择并发数较低的服务器。
RandomRule	随机选择一个可用的服务器。
RetryRule	重试机制的选择逻辑

指定负载均衡策略

（1）代码方式：在order-service中的OrderApplication类中，定义一个新的IRule：

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

这种方法是全局的,不建议使用

（2）配置文件方式：在order-service的application.yml文件中，添加新的配置也可以修改规则

#配置负载均衡的策略（可以实现局部）
user-service: #针对user应用的
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #随机

饥饿加载

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。

而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载：

ribbon:
  eager-load:
    enabled: true #开启饥饿加载
    clients: user-service #指定对userservice这个服务饥饿加载

Nacos注册中心

Nacos = Spring Cloud注册中心 + Spring Cloud配置中心。

服务注册

（1）在父工程中添加spring-cloud-alilbaba的管理依赖：

 <dependency>
     <groupId>com.alibaba.cloud</groupId>
     <artifactId>spring-cloud-alibaba-dependencies</artifactId>
     <version>2.2.5.RELEASE</version>
     <type>pom</type>
     <scope>import</scope>
 </dependency>

（2）子工程中添加nacos的客户端依赖

 <dependency>
     <groupId>com.alibaba.cloud</groupId>
     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
 </dependency>

（3）修改子工程中的application.yml文件，添加nacos地址：

 spring:
   cloud:
     nacos:
       discovery:
         server-addr: localhost:8848

分级（区域）存储

设置服务集群

修改user-service的application.yml，添加如下内容：

设置服务区域集群名称

 spring:
   cloud:
     nacos:
       discovery:
         server-addr: localhost:8848
         cluster-name: HZ   #配置集群名称，也就是机房位置，例如：HZ，杭州 BJ SH

区域集群调用

（1）修改order-service中的application.yml，设置集群为HZ

 spring:
   cloud:
     nacos:
       discovery:
         server-addr: localhost:8848
         cluster-name: HZ   

（2）指定负载均衡策略 在order-service中设置负载均衡的IRule为NacosRule，这个规则优先会寻找与自己同集群的服务

userservice:  
   ribbon:
     NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则 

服务权重调节

在Nacos控制台可以设置实例的权重值