微服务架构 SpringCloud

单体应用架构

将项目所有模块(功能)打成jar或者war，然后部署一个进程--医院挂号系统；

> 优点:
> 1:部署简单:由于是完整的结构体，可以直接部署在一个服务器上即可。
> 2:技术单一:项目不需要复杂的技术栈，往往一套熟悉的技术栈ssm就可以完成开发。
>
> 缺点:
> 1:系统启动慢，一个进程包含了所有的业务逻辑，涉及到的启动模块过多，导致系统的启动、重启时间周期过长;
>
> 2:系统错误隔离性差、可用性差，任何一个模块的错误均可能造成整个系统的宕机;
>
> 3:可伸缩性差:系统的扩容只能只对这个应用进行扩容，无法结合业务模块的特点进行伸缩。
>
> 4: 线上问题修复周期长:任何一个线上问题修复需要对整个应用系统进行全面升级。
>
> 5: 跨语言程度差 [必须统一用一门编程一些]
>
> 6: 不利于安全管理，所有开发人员都拥有全量代码。

> 单体架构===管理类项目 比如: 仓库管理系统  OA办公系统  银行系统{内部使用的系统}
>
> 不适合电商系统---->

微服务应用70%

微服务架构论文: Microservices

译文: 微服务译文理解_微服务架构翻译-CSDN博客

In short, the microservice architectural style [1] is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies

简单来说，微服务架构风格[1]是一种将一个单一应用程序开发为一组小型服务的方法，每个服务运行在自己的进程中，服务间通信采用轻量级通信机制(通常用HTTP资源API)。这些服务围绕业务能力构建并且可通过全自动部署机制独立部署。这些服务共用一个最小型的集中式的管理，服务可用不同的语言开发，使用不同的数据存储技术。

--把一个完整的项目--拆分为若干个小型的项目

解读微服务

1:微服务是一种==项目架构思想==(风格)

2:微服务架构是一系列小服务的组合（组件化与多服务)

3:任何一个微服务，都是一个独立的进程(独立开发、独立维护、独立部署)

4:轻量级通信http协议(跨语言,跨平台) 服务与服务之间可以通过http协议进行相互调用

5:服务粒度(围绕业务功能拆分---模块拆分【系统管理服务】【日志服务】【焦虑测试】【抑郁测试系统】)

6:去中心化管理(去中心化"地治理技术、去中心化地管理数据)；

微服务架构的优势

1.易于开发和维护

一个微服务只关注一个特定的业务功能，所以它的业务清晰、代码量较少。开发和维护单个微服务相对比较简单，整个应用是由若干个微服务构建而成，所以整个应用也会维持在可控状态；

⒉.单个微服务启动较快

单个微服务代码量较少，所以启动会比较快；

3.局部修改容易部署

单体应用只要有修改，就要重新部署整个应用，微服务解决了这样的问题。一般来说，对某个微服务进行修改，只需要重新部署这个服务即可；

4.技术栈不受限

在微服务中，我们可以结合项目业务及团队的特点，合理地选择技术栈；

5.按需伸缩

患者系统访问量大，只需要对患者系统进行扩展；

微服务架构的缺点--(挑战)

l 这么多小服务，如何管理他们？

l 这么多小服务，他们之间如何通讯？

l 这么多小服务，客户端怎么访问他们？

l 这么多小服务，一旦出现问题了，应该如何自处理？

l 这么多小服务，一旦出现问题了，应该如何排错?

SpringCloud与微服务的关系

Springcloud为微服务思想提供了完美的解决方案；
Springcloud是一些列框架的集合体（服务的注册与发现【注册中心】、服务间远程调用、服务降级、服务熔断、服务限流、分布式事务等)；
微服务：它是一种架构思想；
springcloud:就是解决微服务架构思想面临的挑战；

SpringBoot与SpringCloud的关系

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

电商案例：（搭建的是微服务架构项目服务）

第一步：准备/创建数据库；（商品数据库，订单数据库）

商品数据库；数据库名：springcloud

创建表结构

DROP TABLE IF EXISTS `shop_product`;
CREATE TABLE `shop_product`  (
  `pid` bigint(0) NOT NULL AUTO_INCREMENT COMMENT '商品id',
  `pname` varchar(255) CHARACTER SET utf8mb4 NULL DEFAULT NULL COMMENT '商品名',
  `pprice` decimal(10, 2) NULL DEFAULT NULL COMMENT '商品价格',
  `stock` varchar(255) CHARACTER SET utf8mb4  NULL DEFAULT NULL COMMENT '商品库存',
  PRIMARY KEY (`pid`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4  ROW_FORMAT = Dynamic;

插入数据

INSERT INTO `shop_product` VALUES (1, '华为手机', 1999.00, '100');
INSERT INTO `shop_product` VALUES (2, 'vivo手机', 2999.00, '100');
INSERT INTO `shop_product` VALUES (3, '小米', 2222.00, '1000');

SET FOREIGN_KEY_CHECKS = 1;

订单数据库；数据库名：springcloud-order

#订单数据库#
DROP TABLE IF EXISTS `shop_order`;
CREATE TABLE `shop_order`  (
  `oid` bigint(0) NOT NULL AUTO_INCREMENT COMMENT '订单id',
  `uid` int(0) NULL DEFAULT NULL COMMENT '用户id',
  `username` varchar(255) CHARACTER SET utf8mb4 NULL DEFAULT NULL COMMENT '用户名',
  `pid` bigint(0) NULL DEFAULT NULL COMMENT '商品id',
  `pname` varchar(255) CHARACTER SET utf8mb4 NULL DEFAULT NULL COMMENT '商品名称',
  `pprice` decimal(10, 2) NULL DEFAULT NULL COMMENT '商品价格',
  `number` int(0) NULL DEFAULT NULL COMMENT '购买数量',
  PRIMARY KEY (`oid`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 61741 CHARACTER SET = utf8mb4 ROW_FORMAT = Dynamic;

第二步:创建一个父工程；

创建一个工程

注意: 把src目录删除，并在pom.xml中添加打包方式为pom打包。

引入相关依赖

<!--引入父依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
    </parent>
    <!--定义版本号-->
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <!--springcloud的版本-->
        <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
        <!--springcloudalibaba的版本号-->
        <spring-cloud-alibaba.version>2.2.3.RELEASE</spring-cloud-alibaba.version>
    </properties>
    <!--dependencyManagement:只用于jar的管理 不负责jar的下载。 后期子工程使用jar时无需指定版本号-->
    <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>
            <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>
        </dependencies>
    </dependencyManagement>

注意: springboot和springcloud以及springcloud alibaba他们版本必须匹配https://github.com/alibaba/spring-cloud-alibaba/wiki/%E7%89%88%E6%9C%AC%E8%AF%B4%E6%98%8E

第三步:创建一个公共模块

模块名字：spring-common

所有微服务都需要用到的内容，可以放入到公共模块中。未来:放置实体类工具类等；

引入依赖

<dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
    </dependencies>

创建实体类entity

product类

package com.aaa.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.math.BigDecimal;

/**/
@Data
@TableName(value = "shop_product")
public class Product {
    @TableId(type = IdType.AUTO)
    private Integer pid;
    private String pname;
    //double  存在精度丢失  金额不要使用double  使用类型bigdecimal

    private BigDecimal pprice;
    private Integer stock;

}

Order类

package com.aaa.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.math.BigDecimal;

@Data
@TableName(value = "shop_order")
public class Order {
    @TableId(type = IdType.AUTO)
    private Integer oid;
    private Integer uid;
    private String username;

    //并没有只写商品id

    private Integer pid;
    private String pname;
    private BigDecimal pprice;
    private Integer number;

}

第四步:创建商品微服务；

模块名字：spring-product

引入依赖

<!--引入公共模块-->
        <dependency>
            <groupId>com.aaa</groupId>
            <artifactId>spring-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--springbootweb依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>




 <!--引入nacos的依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

创建配置文件

application.properties

# 商品微服务的端口号[8001~8009]
server.port=8001
# 数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springcloud?serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root

# mybatis sql日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl


#指定nacos服务器地址
spring.cloud.nacos.discovery.server-addr=localhost:8848
#指定服务名
spring.application.name=qy172-product

创建dao层接口

ProductDao

package com.aaa.dao;

import com.aaa.entity.Product;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface ProductDao  extends BaseMapper<Product> {
}

创建service层

ProductService接口

package com.aaa.service;

import com.aaa.entity.Product;

public interface ProductService {
    /**
     * 根据商品id查询商品信息
     * @param id
     * @return
     */
    public Product getBiId(Integer id);
}

创建service实现层

ProductServiceImpl

package com.aaa.service.impl;

import com.aaa.dao.ProductDao;
import com.aaa.entity.Product;
import com.aaa.service.ProductService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class ProductServiceImpl implements ProductService {
    @Resource
    private ProductDao productDao;
    @Override
    public Product getBiId(Integer id) {
        return productDao.selectById(id);
    }
}

创建controller

ProductController

package com.aaa.controller;

import com.aaa.entity.Product;
import com.aaa.service.ProductService;
import com.baomidou.mybatisplus.annotation.TableId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

    @Autowired
    private ProductService productService;

    @GetMapping("/selectById/{id}")
    public Product selecId(@PathVariable Integer id){
        Product product = productService.getBiId(id);
        return  product;
    }


}

创建主启动类

package com.aaa;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan(basePackages = "com.aaa.dao")   //dao接口扫描
public class ProductApp {
    public static void main(String[] args) {
        SpringApplication.run(ProductApp.class,args);
    }
}

访问

第五步：创建订单微服务

模块名字 spring-order

引入依赖

<!--引入公共模块-->
        <dependency>
            <groupId>com.aaa</groupId>
            <artifactId>spring-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--springbootweb依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>



 <!--引入nacos的依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

创建配置文件

application.properties

注：订单微服务和商品微服务配置文件唯一不同的就是数据库名字不同

# 订单微服务的端口号[8001~8009]
server.port=8001
# 数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springcloud-order?serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root

# mybatis sql日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl


#指定nacos服务器地址
spring.cloud.nacos.discovery.server-addr=localhost:8848
#指定服务名
spring.application.name=qy172-order

创建dao层接口

OrderDao

package com.aaa.dao;

import com.aaa.entity.Order;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface Orderdao extends BaseMapper<Order> {
}

创建service层

OrderService

package com.aaa.service;

import com.aaa.entity.Order;

public interface OrderService {

    public int inserorder(Order order);
}

创建service实现层

OrderServiceimpl

package com.aaa.service.impl;

import com.aaa.dao.Orderdao;
import com.aaa.entity.Order;
import com.aaa.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class OrderServiceimpl implements OrderService {
    
    @Resource
    private Orderdao orderdao;
    
    @Override
    public int inserorder(Order order) {
        int insert = orderdao.insert(order);
        return insert;
    }
}

创建controller

OrderController

package com.aaa.controller;


import com.aaa.entity.Order;
import com.aaa.entity.Product;
import com.aaa.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.net.URI;
import java.util.List;
import java.util.Random;

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

    @Resource
    private OrderService orderService;

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("save")

    //传参  商品编号+数量

    public String save(Integer pid,Integer num){
            Order order = new Order();
        //订单购买数量
            order.setNumber(num);
        //获取商品ID+用户信息
        order.setUid(1);
        order.setUsername("小明");

        //获取注册中心实例表
        List<ServiceInstance> instances = discoveryClient.getInstances("qy172-product");
        //获取列表的第一个实列
//        ServiceInstance serviceInstance = instances.get(0);
//        String scheme = serviceInstance.getScheme();
//        System.out.println("协议类型" + scheme);
//        String host = serviceInstance.getHost();
//        System.out.println("主机地址" + host);
//        int port = serviceInstance.getPort();
//        System.out.println("实列的端口号" + port);
//        URI uri = serviceInstance.getUri();
//        System.out.println("uri:"+uri);


        //随机生成一个实例下标
        int index = new Random().nextInt(instances.size());

        ServiceInstance serviceInstance = instances.get(index);
       URI uri = serviceInstance.getUri();


      Product product = restTemplate.getForObject(uri+"/product/selectById/"+pid,Product.class);
    // Product product = restTemplate.getForObject("http://qy172-product/product/selectById/"+pid,Product.class);
       // Product product = restTemplate.getForObject("http://localhost:8001/product/selectById/"+pid,Product.class);
        if(product == null){
            return "下单失败,商品不存在";
        }

        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());

        int i = orderService.inserorder(order);
        return "下单成功";
    }
}

注：上面RestTemplate在spring容器中默认不存在的，需要创建该对象并交于spring容器管理。

创建启动类

OrderApp

package com.aaa;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@MapperScan(basePackages = "com.aaa.dao")   //dao接口扫描
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class,args);
    }

//告诉RestTemplate远程调用时需要使用负载均衡ribbon
    
    @LoadBalanced
    @Bean
     public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

访问

服务治理

什么是服务治理？

服务治理是微服务架构中最核心最基本的模块。用于实现各个微服务的自动化注册与发现。

服务注册：在服务治理框架中，都会构建一个注册中心，每个服务单元向注册中心登记自己提供服

务的详细信息。并在注册中心形成一张服务的清单，服务注册中心需要以心跳30s 90s的方式去监测清单中的服务是否可用，如果不可用，需要在服务清单中剔除不可用的服务。

服务发现：服务调用方向服务注册中心咨询服务，并获取所有服务的实例清单，实现对具体服务实；

通过上面的调用图会发现，除了微服务，还有一个组件是服务注册中心，它是微服务架构非常重要

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

1. 服务发现：

服务注册：保存服务提供者和服务调用者的信息；

服务订阅：服务调用者订阅服务提供者的信息，注册中心向订阅者推送提供者的信息；

2. 服务配置：

配置订阅：服务提供者和服务调用者订阅微服务相关的配置；

配置下发：主动将配置推送给服务提供者和服务调用者；

3. 服务健康检测

检测服务提供者的健康情况，如果发现异常，执行服务剔除；

常见的注册中心

Zookeeper

zookeeper是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式

应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用

配置项的管理等。

Eureka

springcloud很多组件都是使用的是netflix公司。--停更了---springcloud alibaba

Eureka是Springcloud Netflix中的重要组件，主要作用就是做服务注册和发现。但是现在已经闭

源，停更不停用。

Consul

Consul是基于GO语言开发的开源工具，主要面向分布式，服务化的系统提供服务注册、服务发现

和配置管理的功能。Consul的功能都很实用，其中包括：服务注册/发现、健康检查、Key/Value

存储、多数据中心和分布式一致性保证等特性。Consul本身只是一个二进制的可执行文件，所以

安装和部署都非常简单，只需要从官网下载后，在执行对应的启动脚本即可。

Nacos (服务治理配置中心)

Nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它是 Spring

Cloud Alibaba 组件之一，负责服务注册发现和服务配置，可以这样认为nacos=eureka+config。

nacos简介

Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。

从上面的介绍就可以看出，nacos的作用就是一个注册中心，用来管理注册上来的各个微服务。

nacos实战入门

接下来，我们就在现有的环境中加入nacos，并将我们的两个微服务注册上去。

Releases · alibaba/nacos · GitHub nacos安装网站

安装nacos服务治理组件

解压即可

默认nacos启动模式为集群模式。修改模式为单机模式。

修改文件目录：nacos/bin/startup.cmd文件

修改完成以后双击启动nacos组件（startup.cmd）

访问nacos服务

注:无法启动nacosl常见的两种情况:

1.nacos放在中文目录;

2.jdk环境设置有问题；

把微服务注册到注册中心nacos

引入依赖

分别把该依赖分别添加在商品微服务架构和订单微服务架构中

 <!--引入nacos的依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

修改配置文件

分别修改商品微服务和订单微服务的application.properties配置文件

商品微服务

订单微服务

启动微服务

修改订单服务和商品服务的耦合问题

通过以上修改订单服务和商品服务的耦合问题解决了 一旦服务提供者地址变化，就需要手工修改代码；我们修改完地址以后，只需要重新运行一下修改地址的微服务即可；

实现服务调用的负载均衡

什么是负载均衡？

通俗的讲，负载均衡就是将负载（工作任务，访问请求）进行分摊到多个操作单元（服务器,组件）上进行执行。

根据负载均衡发生位置的不同,一般分为服务端负载均衡和客户端负载均衡。

服务端负载均衡指的是发生在服务提供者一方,比如常见的nginx负载均衡

而客户端负载均衡指的是发生在服务请求的一方，也就是在发送请求之前已经选好了由哪个实例处理请求；

我们在微服务调用关系中一般会选择*客户端负载均衡*，也就是在服务调用的一方来决定服务由哪个提供者执行.

搭建商品微服务的集群

自定义负载均衡

上面是自己手写了一个随机负载均衡策略代码，如果后期我想使用其他的负载均衡策略，手动改上面的代码。--使用第三方提供的负载均衡组件来实现。---ribbon

什么是ribbon？

专门实现微服务客户端负载均衡的。目前阿里巴巴没有提供负载均衡器。

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

注：使用ribbon无需引入任何依赖。因为nacos依赖中自带了ribbon；

修改controller类

测试结果为：ribbon的负载均衡策略为轮询。

ribbon内部提供了哪些负载均衡策略

你可以自己定义策略【很少】---你可以仿造上面的策略写自己的策略类。

如何改变相应的策略

#指定ribbon的负载均衡策略
qy172-product.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
#服务提供者的名称.ribbon.NFLoadBalancerRuleClassName=负载均衡策略类全路径