一.系统架构演变

随着互联网的发展，网站应用的规模不断扩大。需求的激增，带来的是技术上的压
力。系统架构也因此也不断的演进、升级、迭代。从单一应用，到分布式服务，以及
现在火热的微服务架构。

1.1 单体应用架构

互联网早期的时候，网站的流量都比较少，只有一个简单的功能，将所有的功能都部
署到一台服务器就可以，这样还可以减少开发、部署和维护的成本。
比如说一个电商系统，里面会包含很多用户管理，商品管理，订单管理，物流管理等
等很多模块， 我们会把它们做成一个web项目，然后部署到一台tomcat服务器上。

优点：项目结构简单，非常适合小型项目，开发成本低
项目部署在一个节点上，维护方便

缺点：全部功能都集中在一个工程中，一旦某个地方出现问题，影响整个系统。
*耦合性高
*扩展性较差

1.2 垂直应用架构

随着访问量的增加，单一应用只能靠增加节点来应对，这时候发现有些模块的访问量
高，有些的访问量不高。用户访问量的增加可能影响的只是用户和订单模块， 但是
对消息模块的影响就比较小。 那么此时我们希望只多增加几个订单模块， 而不增加
消息模块. 此时单体应用就做不到了， 垂直应用就应运而生了。
所谓的垂直应用架构，就是将原来的一个应用拆成互不相干的几个应用，以提升效
率。比如我们可 以将上面电商的单体应用拆分成:
        *电商系统(用户管理 商品管理 订单管理)
        *后台系统(用户管理 订单管理 客户管理)
        *CMS系统(广告管理 营销管理)
这样拆分完毕之后，一旦用户访问量变大，只需要增加电商系统的节点就可以了，而
无需增加后台 和CMS的节点。

优点：
系统拆分实现了流量的分担，一定程度上解决了并发问题。
可以针对不同的模块进行优化和扩展
一个系统的问题不会影响到其他系统，单点容错率提高

缺点：
系统之间相互独立，不能进行通信

系统之间相互独立，会有重复的开发任务

1.3 分布式架构

随着网络的发展，用户量继续增加，功能继续完善，当垂直应用越来越多，重复的业
务代码就会越来越多。这时候，我们就思考可不可以将重复的代码 抽取出来，做成
统一的业务层作为独立的服务，然后由前端控制层调用不同的业务层服务呢？

这就产生了新的分布式系统架构。

它将把工程拆分成表现层和服务层两个部分：

        服务层中包含业务逻辑。

        表现层只需要处理和页面的交互

优点：
        抽取公共的功能为服务层，提高代码的复用性
缺点：
        调用关系复杂，难以维护

1.4 微服务架构

微服务是一种经过良好架构设计的分布式架构方案

*单一职责：微服务中每一个服务都对应唯一的业务能力，做到单一职责

*微：微服务的服务拆分粒度很小，例如一个用户管理就可以作为一个服务。每个
服务虽小，但“五脏俱全”。

*面向服务：面向服务是说每个服务都要对外暴露Rest风格服务接口API。并不关
心服务的技术实现，做到与平台和语言无关，也不限定用什么技术实现，只要提

供Rest的接口即可。
*自治：自治是说服务间互相独立，互不干扰
        *团队独立：每个服务都是一个独立的开发团队，人数不能过多。
        *技术独立：因为是面向服务，提供Rest接口，使用什么技术没有别人干涉
        *数据库分离：每个服务都使用自己的数据源
        *部署独立，服务间虽然有调用，但要做到服务重启不影响其它服务。有利于
        持续集成和持续交付。每个服务都是独立的组件，可复用，可替换，降低耦
        合，易维护

1.5 相关概念

集群概念:
        多台服务器做相同的事情

        解决的问题：提高并发量；解决单点故障(单点,单台指只有一台服务器,一旦
        宕机,整个项目将会瘫痪)；保证服务的高可用
分布式概念:
        不同的服务器做不同的事情,协作起来完成一个完整的业务
        解决的问题：降低耦合,让服务器专职做一件事情
负载均衡：
        将并发过来的请求,均匀的分发给不同的服务器

二.初识Spring Cloud

大家谈起的微服务，大多来讲说的只不过是种架构方式。其实现方式很多种：Spring
Cloud，Dubbo 那么这么多的微服务架构产品中，我们为什么要用Spring Cloud？因
为它后台硬、技术强、群众基础好，使用方便；

2.1 Spring Cloud简介

官方网址;Spring Cloud

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

Spring Cloud从技术架构上降低了对大型系统构建的要求和难度，使我们以非常低的
成本（技术或者硬件）搭建一套高效、分布式、容错的平台，但Spring Cloud也不是
没有缺点，小型独立的项目不适合使用。

2.2 SpringCloud与SpringBoot版本匹配关系

SpringCloud底层是依赖于SpringBoot的，并且有版本的兼容关系

版本依赖关系：

2.3 SpringCloud技术栈

三.模拟微服务业务场景

目标：模拟一个最简单的服务调用场景，场景中包含微服务提供者(Producer)和微服
务调用者(Consumer)，方便后面学习微服务架构
        创建父工程
        搭建服务提供者
        搭建服务消费者
        服务消费者使用RestTemplate调用服务提供者

创建父工程：

新建一个Maven父工程springcloud-parent

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.lzw</groupId>
    <artifactId>springcloud-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--自动引入的微服务，不用复制-->
    <modules>
        <module>emp_service</module>
        <module>dept_service</module>
    </modules>
    <!-- 打包方式为pom 表示是父工程 -->
    <packaging>pom</packaging>
    
    <!-- 继承SpringBoot父工程:微服务组件都是基于SpringBoot开发的-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.9.RELEASE</version>
        <relativePath/>
    </parent>
    <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <!-- SpringCloud版本号 -->
        <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
        <mybatis.version>2.1.1</mybatis.version>
    </properties>
    <!-- 版本锁定,并不是jar包导入 -->
    <dependencyManagement>
        <dependencies>
        <!-- 导入springCloud父工程 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
        <!-- 打包方式为pom:说明我们导入的是一个父工程 -->
            <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>
</project>

3.2 创建dept_service服务

每个微服务工程都是独立的工程，连数据库都是独立的，所以我们一会要单独为该服
务工程创建数据库。

准备表结构：

创建工程：

引入依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <artifactId>springcloud-parent</artifactId>
        <groupId>com.lzw</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
    <build>
        <finalName>dept_service</finalName>
        <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>

        </plugins>
    </build>
</project>

创建POJO

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dept {
private Integer id;
private String name;
}

创建mapper

public interface DeptMapper {
    @Select("select * from dept where id = #{id}")
    public Dept findById(Integer id);
}

创建service，和mapper

public interface DeptService {
public List<Dept> findById();
}

@Service
public class DeptServiceImpl implements DeptService{
    @Autowired
    private DeptMapper deptMapper;

    @Override
    public Dept findById(Integer id) {
        return deptMapper.findById(id);
}
}

创建Controller并调用Service

RestController
@RequestMapping("/dept")
public class DeptController {
    @Autowired
    private DeptService deptService;

    @GetMapping("{/id}")
    public Dept findById(@PathVariable("id") Integer id){
        Dept dept = deptService.findById(id);
        return dept;
}
}

创建application.xml文件

创建启动类：

@MapperScan("com.lzw.mapper")
@SpringBootApplication
public class DeptApplication {
    public static void main(String[] args) {
    SpringApplication.run(DeptApplication.class, args);
 }
}

测试用游览器搜索网址：http://localhost:8081/dept/1

3.3 创建emp_service服务

准备表结构：

创建工程：

引入依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <artifactId>springcloud-parent</artifactId>
        <groupId>com.lzw</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>

    </build>
</project>

创建pojo

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dept {
    private Integer id;
    private String name;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Emp {
    private Integer id;
    private String name;
    private String gender;
    private Double salary;
    private Date joinDate;
    private Integer deptId;
    private Dept dept;
}

创建mapper

public interface EmpMapper {
    @Select("select * from emp where id = #{id}")
    public Emp findById(Integer id);
}

创建Service,并调用Mapper

public interface EmpService {
    public Emp findById(Integer id);
}

@Service
public class EmpServiceImpl implements EmpService {
    @Autowired
    private EmpMapper empMapper;

    @Override
    public Emp findById(Integer id) {
        return empMapper.findById(id);
}
}

创建Controller并调用Service

@RestController
@RequestMapping("/emp")
public class EmpController {
    @Autowired
    private EmpService empService;

    @GetMapping("/{id}")
    public Emp findById(@PathVariable("id") Integer id){
        Emp emp = empService.findById(id);
        return emp;
}
}

创建application.yml文件

创建启动类：

@MapperScan("com.lzw.mapper")
@SpringBootApplication
public class EmpApplication {
    public static void main(String[] args) {
        SpringApplication.run(EmpApplication.class, args);
}
}

测试游览器访问地址：http://localhost:8082/emp/2

3.4 服务调用方式

3.4.1 RPC和HTTP

        RPC：(Remote Produce Call)远程过程调用
                基于Socket
                自定义数据格式
                速度快，效率高
                典型应用代表：Dubbo，WebService，ElasticSearch集群间互相调用
        HTTP：网络传输协议
                基于TCP/IP
                规定数据传输格式
                缺点是消息封装比较臃肿、传输速度比较慢
                优点是对服务提供和调用方式没有任何技术限定，自由灵活，更符合微服务
                理念
                常见Http客户端工具：HttpClient、OKHttp、URLConnection。
        RPC和HTTP的区别：RPC是根据语言API来定义，而不是根据基于网络的应用来
        定义。

3.4.2 RestTemplate

        RestTemplate是Spring提供的进行远程调用客户端
        实现对象与JSON的序列化与反序列化
        对基于Http的客户端进行封装
        不限定客户端类型，目前常用的3种客户端都支持：HttpClient、OKHttp、JDK原
        生URLConnection(默认方式)

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

3.4.3 实现远程调用

注册RestTemplate

我们在emp_service服务中的EmpApplication启动类中，注册RestTemplate实例：

@MapperScan("com.lzw.mapper")
@SpringBootApplication
public class EmpApplication {
    public static void main(String[] args) {
        SpringApplication.run(EmpApplication.class, args);
    }
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
}
}

        实现远程调用
修改emp_service服务中的EmpServiceImpl类中的findById方法：

Service
public class EmpServiceImpl implements EmpService {
    @Autowired
    private EmpMapper empMapper;
    @Autowired
    private RestTemplate restTemplate;

    @Override
    public Emp findById(Integer id) {
    //根据ID获取员工信息 其中包含了部门的ID
        Emp emp = empMapper.findById(id);
        //编写远程调用地址
        String url="http://localhost:8081/dept/"+emp.getDeptId();
        //发起调用
        Dept dept = restTemplate.getForObject(url, Dept.class);
        //存入emp中
        emp.setDept(dept);
            return emp;
}

测试访问地址：http://localhost:8082/emp/2

3.4.4 提供者与消费者
在服务调用关系中，会有两个不同的角色：
        服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）
        服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）
但是，服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言。
如果服务A调用了服务B，而服务B又调用了服务C，服务B的角色是什么？
        对于A调用B的业务而言：A是服务消费者，B是服务提供者
        对于B调用C的业务而言：B是服务消费者，C是服务提供者
因此，服务B既可以是服务提供者，也可以是服务消费者。

3.5 IDEA简单设置

四.Eureka注册中心

假如我们的服务提供者user-service部署了多个实例

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

4.1 Eureka的作用

Eureka是Netflix开源的一个基于REST的服务治理框架，主要用于实现服务注册、发
现和负载均衡。通过Eureka，我们可以将微服务的各个实例注册到服务中心，并根据
需要进行负载均衡和调用，从而实现整个微服务架构的高可用和弹性。

Eureka是一个C/S架构的组件,通过客户端操作服务端。

服务注册：客户端向eureka服务端注册自己的服务，服务端将信息存于多级缓存
中。
服务续约：服务注册后，客户端会定时发送心跳包来保持可用性，避免被剔除。
每30秒发送一次心跳来进行服务续约。
服务同步:eureka服务端之间互相进行注册，构建server集群，不同Server之间
会进行服务同步，用来保证服务信息的一致性。
服务列表获取：客户端请求eureka server获取注册的服务清单，并缓存到客户
端本地。默认间隔30秒。
远程调用：服务调用方在获取到服务清单后，就可以根据自身的一个负载均衡策
略找到一个服务url，并对他发起请求。
服务下线:客户端关闭或重启时，需告诉server端该服务已下线。服务端在收到请
求后，就会把该服务状态置为下线（DOWN），并把该下线事件传播出去
服务剔除：如果客户端没有正常下线，需要有剔除机制，将不可用的服务删除
掉。EurekaServer 在启动时会创建一个定时任务，每隔默认60秒，从当前服务
清单中把超时没有续约（默认90秒）的服务剔除
自我保护：当短时间内，统计续约失败的比例，如果达到一定阈值，就会触发自
我保护机制。在该机制下，Eureka Server不会剔除任何微服务。

4.2 搭建eureka-server

创建eureka-server服务

引入依赖：

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

编写启动类
给eureka-server服务编写启动类，要添加一个@EnableEurekaServer注解，开启
eureka的注册中心功能：

@SpringBootApplication
@EnableEurekaServer //开启Eureka服务端支持
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
}
}

编写配置文件：

启动服务;

启动微服务，然后在浏览器访问；http://127.0.0.1:10086/

4.3 服务注册

我们将dept-service注册到eureka-server中去。
        引入依赖
在dept-service的pom文件中，引入下面的eureka-client依赖：

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

        *配置文件
在dept-service中，修改application.yml文件，添加服务名称、eureka地址：

复制原来的dept-service启动配置：

在弹出的窗口中，填写信息：

SpringBoot窗口会出现两个dept-service启动配置

启动两个dept-service实例：

查看eureka-server管理页面：

4.4 服务发现

我们将emp-service的逻辑修改：向eureka-server拉取dept-service的信息，实现服
务发现。

        引入依赖
服务发现、服务注册统一都封装在eureka-client依赖，因此这一步与服务注册时一
致。在emp-service的pom文件中，引入下面的eureka-client依赖：

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

        配置文件
服务发现也需要知道eureka地址，因此第二步与服务注册一致，都是配置eureka信
息：在emp-service中，修改application.yml文件，添加服务名称、eureka地址：

        服务拉取和负载均衡
我们要去eureka-server中拉取dept-service服务的实例列表，并且实现负载均衡。不
过这些动作不用我们去做，只需要添加一些注解即可。

在emp-service的OrderApplication中，给RestTemplate这个Bean添加一个
@LoadBalanced注解：

@MapperScan("com.lzw.mapper")
@SpringBootApplication
public class EmpApplication {
    public static void main(String[] args) {
        SpringApplication.run(EmpApplication.class, args);
    }
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
}
}

修改emp-service服务中的EmpServiceImpl类中的findById方法。修改访问的url
路径，用服务名代替ip、端口：

@Service
public class EmpServiceImpl implements EmpService {
    @Autowired
    private EmpMapper empMapper;

    @Autowired
    private RestTemplate restTemplate;

    @Override
    public Emp findById(Integer id) {
    //根据ID获取员工信息 其中包含了部门的ID
        Emp emp = empMapper.findById(id);
    //编写远程调用地址
        String url="http://deptservice/dept/"+emp.getDeptId();
    //发起调用
        Dept dept = restTemplate.getForObject(url, Dept.class);
    //存入emp中
        emp.setDept(dept);
            return emp;
}
}

spring会自动帮助我们从eureka-server端，根据deptservice这个服务名称，获取实
例列表，而后完成负载均衡。

@Service
public class DeptServiceImpl implements DeptService{
    @Autowired
    private DeptMapper deptMapper;
    @Value("${server.port}")
    private Integer port;
    @Override
    public Dept findById(Integer id) {
        Dept dept = deptMapper.findById(id);
        dept.setName(dept.getName()+":"+port);
        return dept;
    }
}

@Service
public class EmpServiceImpl implements EmpService {
    @Autowired
    private EmpMapper empMapper;
    @Autowired
    private RestTemplate restTemplate;
    @Override
public Emp findById(Integer id) {
    //根据ID获取员工信息 其中包含了部门的ID
        Emp emp = empMapper.findById(id);
    //编写远程调用地址
        String url="http://deptservice/dept/"+emp.getDeptId();
    //发起调用
        Dept dept = restTemplate.getForObject(url, Dept.class);
    //存入emp中
        emp.setDept(dept);
            return emp;
}
}

spring会自动帮助我们从eureka-server端，根据deptservice这个服务名称，获取实
例列表，而后完成负载均衡。

五.Ribbon负载均衡

我们添加了@LoadBalanced注解，即可实现负载均衡功能，这是什么原理呢？

5.1 负载均衡原理

SpringCloud底层其实是利用了一个名为Ribbon的组件，来实现负载均衡功能的。

5.2 查看源码

显然有人帮我们根据service名称，获取到了服务实例的ip和端口。它就是
LoadBalancerInterceptor，这个类会在对RestTemplate的请求进行拦截，然后从
Eureka根据服务id获取服务列表，随后利用负载均衡算法得到真实的服务地址信息，
替换服务id。

LoadBalancerIntercepor

可以看到这里的intercept方法，拦截了用户的HttpRequest请求，然后做了几件事：

        request.getURI()：获取请求uri，本例中就是 :http://user-service/user/8
        originalUri.getHost()：获取uri路径的主机名，其实就是服务的id
        （deptservice）
        this.loadBalancer.execute()：处理服务id，和用户请求
这里的this.loadBalancer是LoadBalancerClient类型。

LoadBalancerClient

        *getLoadBalancer(serviceId)：根据服务id获取ILoadBalancer，而
        ILoadBalancer会拿着服务id去eureka中获取服务列表并保存起来。
        *getServer(loadBalancer，hint)：利用内置的负载均衡算法，从服务列表中选择
        一个。本例中，可以看到获取了8082端口的服务

        拦截我们的RestTemplate请求http:http://userservice/user/1
        RibbonLoadBalancerClient会从请求url中获取服务名称，也就是deptservice
        DynamicServerListLoadBalancer根据deptservice到eureka拉取服务列表
        eureka返回列表，localhost:8081、localhost:8082
        IRule利用内置负载均衡规则，从列表中选择一个，例如localhost:8081
        RibbonLoadBalancerClient修改请求地址，用localhost:8081替代
        deptservice，得到:http://localhost:8081/user/1，发起真实请求

负载均衡策略IRule
负载均衡的规则都定义在IRule接口中，而IRule有很多不同的实现类：

默认的实现就是ZoneAvoidanceRule，是一种轮询方案

5.3 自定义负载均衡策略

通过定义IRule实现可以修改负载均衡规则，有两种方式：
代码方式：在emp-service中的EmpApplication类中，定义一个新的IRule：

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

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

5.4 饥饿加载

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时
间会很长。
而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿
加载：