SpringCloud详细教程(上)

朱雀 2022-04-22 09:22 352阅读 0赞

**【订阅[专栏合集][Link 1],关注公众号，作者所有付费文章都能看(持续更新)】**

推荐【**Kafka教程**】[https://bigbird.blog.csdn.net/article/details/108770504][https_bigbird.blog.csdn.net_article_details_108770504]  
推荐【**rabbitmq教程**】[https://bigbird.blog.csdn.net/article/details/81436980][https_bigbird.blog.csdn.net_article_details_81436980]  
推荐【**Flink教程**】[https://blog.csdn.net/hellozpc/article/details/109413465][https_blog.csdn.net_hellozpc_article_details_109413465]  
推荐【**JVM面试与调优教程**】[https://bigbird.blog.csdn.net/article/details/113888604][https_bigbird.blog.csdn.net_article_details_113888604]  
推荐【**SpringBoot全套教程**】[https://blog.csdn.net/hellozpc/article/details/107095951][https_blog.csdn.net_hellozpc_article_details_107095951]  
推荐【**SpringCloud教程**】[https://blog.csdn.net/hellozpc/article/details/83692496][https_blog.csdn.net_hellozpc_article_details_83692496]  
推荐【**Mybatis教程**】[https://blog.csdn.net/hellozpc/article/details/80878563][https_blog.csdn.net_hellozpc_article_details_80878563]  
推荐【**SnowFlake教程**】[https://blog.csdn.net/hellozpc/article/details/108248227][https_blog.csdn.net_hellozpc_article_details_108248227]  
推荐【**并发限流教程**】[https://blog.csdn.net/hellozpc/article/details/107582771][https_blog.csdn.net_hellozpc_article_details_107582771]  
推荐【**Redis教程**】[https://bigbird.blog.csdn.net/article/details/81267030][https_bigbird.blog.csdn.net_article_details_81267030]  
推荐【**Netty教程**】[https://blog.csdn.net/hellozpc/category\_10945233.html][https_blog.csdn.net_hellozpc_category_10945233.html]

[SpringCloud][]详细教程代码下载地址:[https://download.csdn.net/download/zpcandzhj/10762209][https_download.csdn.net_download_zpcandzhj_10762209]

## SpringCloud详细教程(上) ##

springcloud 官网 [https://spring.io/projects/spring-cloud/][SpringCloud]

### 文章目录 ###

*   *  SpringCloud详细教程(上)
     *   *  1.SpringCloud详细教程目录
         *  2. 开发环境说明
         *  3.细说微服务架构
         *   *  3.1.单体架构
             *  3.2.单体架构存在的问题
             *  3.3.什么是微服务？
             *  3.4.微服务架构的特征
             *  3.5.微服务架构示例
         *  4.SpringCloud概论
         *   *  4.1.简介
             *  4.2.SpringCloud子项目
             *  4.3.Springcloud版本说明
             *  4.4.SpringCloud框架特点
         *  5.使用 SpringBoot 实现微服务
         *   *  5.1.实现商品微服务
             *   *  5.1.1.创建maven工程
                 *  5.1.2.导入依赖
                 *  5.1.3.创建实体Item
                 *  5.1.4.编写ItemService
                 *  5.1.5.编写ItemController
                 *  5.1.6.编写程序入口
                 *  5.1.7.创建application.yml配置文件
                 *  5.1.8.启动程序测试
             *  5.2.实现订单微服务
             *   *  5.2.1.创建工程
                 *  5.2.2.导入依赖
                 *  5.2.3.创建订单Order实体
                 *  5.2.4.创建订单详情OrderDetail实体
                 *  5.2.5.将商品微服务项目中的Item类拷贝到当前工程
                 *  5.2.6.编写OrderService
                 *  5.2.7.实现ItemService
                 *  5.2.8.编写OrderController
                 *  5.2.9.编写程序入口
                 *  5.2.10.编写application.yml配置文件
                 *  5.2.11.启动测试
             *  5.3.添加okHttp的支持
             *  5.4.解决订单系统中的url硬编码问题
             *  5.5.继续优化解决硬编码的问题
         *  6.SpringCloud快速入门
         *   *  6.1.分析硬编码的问题
             *  6.2.微服务注册与发现
             *  6.3.注册中心：Eureka
             *   *  6.3.1.原理
                 *  6.3.2.编写Eureka Server
             *  6.4.将商品微服务注册到Eureka
             *  6.5.订单系统从Eureka中发现商品服务
         *  7.深入理解Eureka
         *   *  7.1.为Eureka添加用户认证
             *   *  7.1.1.服务注册时(client端)设置账户信息
             *  7.2.Eureka的自我保护模式
             *  7.3.Eureka的高可用(Eureka集群)
             *  7.4.将client端服务注册到Eureka高可用集群
             *  7.5.指定服务的IP地址
             *  7.6.指定实例id
         *  8.负载均衡：Ribbon
         *   *  8.1.Ribbon简介
             *  8.2.架构
             *  8.3.开始使用SpringCloud Ribbon
             *   *  8.3.1.为microservice order增加ribbon依赖
                 *  8.3.2.为RestTemplate设置@LoadBalanced注解
                 *  8.3.3.改造ItemService的实现
                 *  8.3.4.重启订单服务进行测试
                 *  8.3.5.测试负载均衡
             *  8.4.设置负载均衡策略
             *  8.5.其它策略
         *  9.容错保护：Hystrix
         *   *  9.1.分析
             *  9.2.雪崩效应
             *  9.3.SpringCloud Hystrix简介
             *  9.4.原理说明
             *  9.5.快速入门
             *   *  9.5.1.导入依赖
                 *  9.5.2.修改ItemService的queryItemById方法
                 *  9.5.3.在启动类OrderApplication添加@EnableHystrix注解
                 *  9.5.4.在Controller增加一个入口
                 *  9.5.5.重新启动进行测试
             *  9.6.定义统一的fallback接口

### 1.SpringCloud详细教程目录 ###

*  开发环境说明
 *  细说微服务架构
 *  SpringCloud 概论
 *  SpringCloud 快速入门
 *  Eureka 服务注册中心
 *  使用**Spring Cloud** Ribbon 实现负载均衡
 *  使用**Spring Cloud** Hystrix 实现容错

### 2. 开发环境说明 ###

*  JDK：  1.8
 *  IDE：    IntelliJ IDEA
 *  Maven：3.3.9
 *  OS:        Windows 10 10.0
 *  Springboot版本：2.0+

### 3.细说微服务架构 ###

目前微服务是非常火的架构或者说概念，也是在构建大型互联网项目时采用的架构方式。

#### 3.1.单体架构 ####

单体架构，是指将开发好的项目打成war包，然后发布到tomcat等容器中的应用。

假设你正准备开发一款与Uber和滴滴竞争的出租车调度软件，经过初步会议和需求分析，你可能会手动或者使用基于**SpringBoot**、Play或者Maven的生成器开始这个新项目，它的六边形架构是模块化的 ，架构图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70]

*  应用核心是业务逻辑，由定义服务、领域对象和事件的模块完成。围绕着核心的是与外界打交道的适配器。适配器包括数据库访问组件、生产和处理消息的消息组件，以及提供API或者UI访问支持的web模块等。
 *  尽管也是模块化逻辑，但是最终它还是会打包并部署为单体式应用。具体的格式依赖于应用语言和框架。例如，许多Java应用会被打包为WAR格式，部署在Tomcat或者Jetty上，而另外一些Java应用会被打包成自包含的JAR格式，类似的，Rails和Node.js会被打包成层级目录。
 *  这种应用开发风格很常见，因为IDE和其它工具都擅长开发一个简单应用，这类应用也很易于调试，只需要简单运行此应用，用Selenium链接UI就可以完成端到端测试。单体式应用也易于部署，只需要把打包应用拷贝到服务器端，通过在负载均衡器后端运行多个拷贝就可以轻松实现应用扩展。在早期这类应用运行的很好。

#### 3.2.单体架构存在的问题 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 2]  
如何解决以上问题呢？ – 使用**微服务**架构。使得应用由重变轻。

#### 3.3.什么是微服务？ ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 3]

作者：Martin Fowler  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 5]

#### 3.4.微服务架构的特征 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 6]

#### 3.5.微服务架构示例 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 7]

每一个应用功能区都使用微服务完成。

### 4.SpringCloud概论 ###

#### 4.1.简介 ####

SpringCloud项目的官方网址：  
http://projects.spring.io/spring-cloud/  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][20181103225238934.png]

#### 4.2.SpringCloud子项目 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 9]

#### 4.3.Springcloud版本说明 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 10]

官方版本：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 11]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 12]

可见，目前Finchley.SR2版本是最新的稳定版，所以我们学习的过程中，就是使用的这个版本。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 13]

#### 4.4.SpringCloud框架特点 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 14]

### 5.使用 SpringBoot 实现微服务 ###

在正式学习SpringCloud 之前我们先使用[SpringBoot][]实现一个微服务。

业务非常简单：  
1、商品微服务：通过商品id查询商品的服务；  
2、订单微服务：创建订单时通时，通过调用商品的微服务进行查询商品数据；

图示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 15]

说明：  
1、对于商品微服务而言，商品微服务是服务的提供者，订单微服务是服务的消费者；  
2、对于订单微服务而言，订单微服务是服务的提供者，人是服务的消费者。

#### 5.1.实现商品微服务 ####

##### 5.1.1.创建maven工程 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 17]

##### 5.1.2.导入依赖 #####

重点是导入**SpringBoot**的依赖：

##### 5.1.3.创建实体Item #####

package com.zpc.item.entity;
    
    public class Item {
    
        private Long id;
    
        private String title;
    
        private String pic;
    
        private String desc;
    
        private Long price;
    
        public Item(){}
    
        public Item(long id, String title, String pic, String desc, Long price) {
            this.id=id;
            this.title=title;
            this.pic=pic;
            this.desc=desc;
            this.price=price;
        }
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    
        public String getPic() {
            return pic;
        }
    
        public void setPic(String pic) {
            this.pic = pic;
        }
    
        public String getDesc() {
            return desc;
        }
    
        public void setDesc(String desc) {
            this.desc = desc;
        }
    
        public Long getPrice() {
            return price;
        }
    
        public void setPrice(Long price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Item [id=" + id + ", title=" + title + ", pic=" + pic + ", desc=" + desc + ", price=" + price + "]";
        }
    
    }

##### 5.1.4.编写ItemService #####

编写ItemService用于实现具体的商品查询逻辑，为了演示方便，我们并不真正的连接数据库，而是做模拟实现。

package com.zpc.item.service;
    import com.zpc.item.entity.Item;
    import org.springframework.stereotype.Service;
    import java.util.HashMap;
    import java.util.Map;
    
    @Service
    public class ItemService {
    
        private static final Map<Long, Item> ITEM_MAP = new HashMap<Long, Item>();
    
        static {// 准备一些静态数据,模拟数据库
            ITEM_MAP.put(1L, new Item(1L, "商品1", "http://图片1", "商品描述1", 1000L));
            ITEM_MAP.put(2L, new Item(2L, "商品2", "http://图片2", "商品描述2", 2000L));
            ITEM_MAP.put(3L, new Item(3L, "商品3", "http://图片3", "商品描述3", 3000L));
            ITEM_MAP.put(4L, new Item(4L, "商品4", "http://图片4", "商品描述4", 4000L));
            ITEM_MAP.put(5L, new Item(5L, "商品5", "http://图片5", "商品描述5", 5000L));
            ITEM_MAP.put(6L, new Item(6L, "商品6", "http://图片6", "商品描述6", 6000L));
            ITEM_MAP.put(7L, new Item(7L, "商品7", "http://图片7", "商品描述7", 7000L));
            ITEM_MAP.put(8L, new Item(8L, "商品8", "http://图片8", "商品描述8", 8000L));
            ITEM_MAP.put(8L, new Item(9L, "商品9", "http://图片9", "商品描述9", 9000L));
            ITEM_MAP.put(8L, new Item(10L, "商品10", "http://图片10", "商品描述10", 10000L));
        }
    
        /**
         * 模拟实现商品查询
         *
         * @param id
         * @return
         */
        public Item queryItemById(Long id) {
            return ITEM_MAP.get(id);
        }
    
    }

##### 5.1.5.编写ItemController #####

package com.zpc.item.controller;
    
    import com.zpc.item.entity.Item;
    import com.zpc.item.service.ItemService;
    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.RestController;
    
    @RestController
    public class ItemController {
    
        @Autowired
        private ItemService itemService;
    
        /**
         * 对外提供接口服务，查询商品信息
         *
         * @param id
         * @return
         */
        @GetMapping(value = "item/{id}")
        public Item queryItemById(@PathVariable("id") Long id) {
            return this.itemService.queryItemById(id);
        }
    
    }

@RestController注解的说明：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Controller
    @ResponseBody
    public @interface RestController {
    
       /**
        * The value may indicate a suggestion for a logical component name,
        * to be turned into a Spring bean in case of an autodetected component.
        * @return the suggested component name, if any (or empty String otherwise)
        * @since 4.0.1
        */
       @AliasFor(annotation = Controller.class)
       String value() default "";
    
    }

从源码可以看出，这是一个组合注解，组合了`@Controller`和`@Response`注解。相当于我们同时写了这2个注解。

@GetMapping注解的说明：

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @RequestMapping(method = RequestMethod.GET)
    public @interface GetMapping {...}

`@GetMapping`注解是`@RequestMapping(method = RequestMethod.GET)`简写方式。其功能都是一样的。

同理还有其它注解：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 18]

##### 5.1.6.编写程序入口 #####

package com.zpc.item.runner;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ComponentScan;
    
    /**
     * @author Evan
     */
    
    @SpringBootApplication//申明这是一个Spring Boot项目
    @ComponentScan(basePackages = {"com.zpc.item.controller","com.zpc.item.service"})//手动指定bean组件扫描范围
    public class ItemApp {
        public static void main(String[] args) {
            SpringApplication.run(ItemApp.class, args);
        }
    }

##### 5.1.7.创建application.yml配置文件 #####

**SpringBoot**以及SpringCloud项目支持yml和properties格式的配置文件。

yml格式是YAML（Yet Another Markup Language）编写的格式，YAML和properties格式的文件是可以相互转化的。如：

server:
      port: 8081 #服务端口

等价于properties文件的配置：  
`server.port=8081`

配置文件的示例：

server:
      port: 8081 #服务端口

##### 5.1.8.启动程序测试 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 19]

可以看到已经通过微服务查询到数据。

#### 5.2.实现订单微服务 ####

##### 5.2.1.创建工程 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 20]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 21]

##### 5.2.2.导入依赖 #####

##### 5.2.3.创建订单Order实体 #####

package com.zpc.order.entity;
    
    import java.util.Date;
    import java.util.List;
    
    public class Order {
    
        private String orderId;
    
        private Long userId;
    
        private Date createDate;
    
        private Date updateDate;
    
        private List<OrderDetail> orderDetails;
    
        public Order() {
    
        }
    
        public Order(String orderId, Long userId, Date createDate, Date updateDate) {
            this.orderId = orderId;
            this.userId = userId;
            this.createDate = createDate;
            this.updateDate = updateDate;
        }
    
        public String getOrderId() {
            return orderId;
        }
    
        public void setOrderId(String orderId) {
            this.orderId = orderId;
        }
    
        public Long getUserId() {
            return userId;
        }
    
        public void setUserId(Long userId) {
            this.userId = userId;
        }
    
        public Date getCreateDate() {
            return createDate;
        }
    
        public void setCreateDate(Date createDate) {
            this.createDate = createDate;
        }
    
        public Date getUpdateDate() {
            return updateDate;
        }
    
        public void setUpdateDate(Date updateDate) {
            this.updateDate = updateDate;
        }
    
    
        public List<OrderDetail> getOrderDetails() {
            return orderDetails;
        }
    
        public void setOrderDetails(List<OrderDetail> orderDetails) {
            this.orderDetails = orderDetails;
        }
    
        @Override
        public String toString() {
            return "Order [orderId=" + orderId + ", userId=" + userId
                    + ", createDate=" + createDate + ", updateDate=" + updateDate
                    + "]";
        }}

##### 5.2.4.创建订单详情OrderDetail实体 #####

订单与订单详情是一对多的关系。

package com.zpc.order.entity;
    
    public class OrderDetail {
    
        private String orderId;
    
        private Item item = new Item();
    
        public OrderDetail() {
    
        }
    
        public OrderDetail(String orderId, Item item) {
            this.orderId = orderId;
            this.item = item;
        }
    
        public String getOrderId() {
            return orderId;
        }
    
        public void setOrderId(String orderId) {
            this.orderId = orderId;
        }
    
        public Item getItem() {
            return item;
        }
    
        public void setItem(Item item) {
            this.item = item;
        }
    
        @Override
        public String toString() {
            return "OrderDetail [orderId=" + orderId + ", item=" + item + "]";
        }
    
    }

##### 5.2.5.将商品微服务项目中的Item类拷贝到当前工程 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 22]

##### 5.2.6.编写OrderService #####

该Service实现的根据订单Id查询订单的服务，为了方便测试，我们将构造数据实现，不采用查询数据库的方式。

package com.zpc.order.service;
    
    import com.zpc.order.entity.Item;
    import com.zpc.order.entity.Order;
    import com.zpc.order.entity.OrderDetail;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.*;
    
    @Service
    public class OrderService {
    
        private static final Map<String, Order> ORDER_DATA = new HashMap<String, Order>();
    
        static {
            // 模拟数据库，构造测试数据
            Order order = new Order();
            order.setOrderId("201810300001");
            order.setCreateDate(new Date());
            order.setUpdateDate(order.getCreateDate());
            order.setUserId(1L);
            List<OrderDetail> orderDetails = new ArrayList<OrderDetail>();
    
            Item item = new Item();// 此处并没有商品的数据，只是保存了商品ID，需要调用商品微服务获取
            item.setId(1L);
            orderDetails.add(new OrderDetail(order.getOrderId(), item));
    
            item = new Item(); // 构造第二个商品数据
            item.setId(2L);
            orderDetails.add(new OrderDetail(order.getOrderId(), item));
    
            order.setOrderDetails(orderDetails);
    
            ORDER_DATA.put(order.getOrderId(), order);
        }
    
        @Autowired
        private ItemService itemService;
    
        /**
         * 根据订单id查询订单数据
         *
         * @param orderId
         * @return
         */
        public Order queryOrderById(String orderId) {
            Order order = ORDER_DATA.get(orderId);
            if (null == order) {
                return null;
            }
            List<OrderDetail> orderDetails = order.getOrderDetails();
            for (OrderDetail orderDetail : orderDetails) {
                // 通过商品微服务查询商品详细数据
                Item item = this.itemService.queryItemById(orderDetail.getItem()
                        .getId());
                if (null == item) {
                    continue;
                }
                orderDetail.setItem(item);
            }
    
            return order;
        }
    
    }

##### 5.2.7.实现ItemService #####

package com.zpc.order.service;
    
    
    import com.zpc.order.entity.Item;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.client.RestTemplate;
    
    @Service
    public class ItemService {
    
        // Spring框架对RESTful方式的http请求做了封装，来简化操作
        @Autowired
        private RestTemplate restTemplate;
    
        public Item queryItemById(Long id) {
            return this.restTemplate.getForObject("http://127.0.0.1:8081/item/"
                    + id, Item.class);
        }
    
    }

##### 5.2.8.编写OrderController #####

package com.zpc.order.controller;
    
    import com.zpc.order.entity.Order;
    import com.zpc.order.service.OrderService;
    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.RestController;
    
    @RestController
    public class OrderController {
        @Autowired
        private OrderService orderService;
    
        @GetMapping(value = "order/{orderId}")
        public Order queryOrderById(@PathVariable("orderId") String orderId) {
            return this.orderService.queryOrderById(orderId);
        }
    }

##### 5.2.9.编写程序入口 #####

package com.zpc.order.runner;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.web.client.RestTemplate;
    
    /**
     * @author Evan
     */
    @SpringBootApplication//申明这是一个Spring Boot项目
    @ComponentScan(basePackages = {"com.zpc.order.controller", "com.zpc.order.service"})//手动指定bean扫描范围
    public class OrderApp {
        public static void main(String[] args) {
            SpringApplication.run(OrderApp.class, args);
        }
    
        /**
         * 向Spring容器中定义RestTemplate对象
         * @return
         */
        @Bean
        public RestTemplate restTemplate() {
            return new RestTemplate();
        }
    }

##### 5.2.10.编写application.yml配置文件 #####

server:
      port: 8082 #服务端口

##### 5.2.11.启动测试 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 23]

测试结果可见，查询订单时，同时也将商品数据查询到。

#### 5.3.添加okHttp的支持 ####

okhttp是一个封装URL,比HttpClient更友好易用的工具。目前似乎okhttp更流行一些。

官网：http://square.github.io/okhttp/

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 24]

RestTemplate底层默认使用的jdk的标准实现，如果我们想让RestTemplate的底层使用okhttp，非常简单：  
1、添加okhttp依赖

<dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>3.9.0</version>
    </dependency>

2、设置requestFactory  
return new RestTemplate(new OkHttp3ClientHttpRequestFactory());

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

测试：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 25]

结果（没有变化）：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 26]  
测试结果是一样的。

#### 5.4.解决订单系统中的url硬编码问题 ####

*  通过以上的测试我们发现，在订单系统中要调用商品微服务中的查询接口来获取数据，在订单微服务中将url硬编码到代码中，这样显然不好，因为，运行环境一旦发生变化这个url地址将不可用。
 *  如何解决呢？

解决方案：将url地址写入到`application.yml`配置文件中。

实现：  
修改`application.yml`文件：

server:
      port: 8082 #服务端口
    myspcloud:
      item:
        url: http://127.0.0.1:8081/item/

修改ItemService中的实现：

@Service
    public class ItemService {
    
        // Spring框架对RESTful方式的http请求做了封装，来简化操作
        @Autowired
        private RestTemplate restTemplate;
    
        @Value("${myspcloud.item.url}")
        private String itemUrl;
    
        public Item queryItemById(Long id) {
            return this.restTemplate.getForObject(itemUrl
                    + id, Item.class);
        }
    
    }

测试(debug可以看到效果)：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 27]

#### 5.5.继续优化解决硬编码的问题 ####

在SpringBoot中使用`@ConfigurationProperties`注解可以非常简单的将配置文件中的值映射成对象。  
第一步，创建ItemProperties类：

package com.zpc.order.properties;
    
    public class ItemProperties {
        private String url;
    
        public String getUrl() {
            return url;
        }
    
        public void setUrl(String url) {
            this.url = url;
        }
    
    }

第二步，创建OrderProperties类：

package com.zpc.order.properties;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    /**
     * 以myspcloud开头的配置被匹配到
     * @author Evan
     */
    @Component
    @ConfigurationProperties(prefix="myspcloud")
    public class OrderProperties {
    
        private ItemProperties item = new ItemProperties();
    
        public ItemProperties getItem() {
            return item;
        }
    
        public void setItem(ItemProperties item) {
            this.item = item;
        }
    }

第三步，在Itemservice中注入该对象：

@Service
    public class ItemService {
    
        // Spring框架对RESTful方式的http请求做了封装，来简化操作
        @Autowired
        private RestTemplate restTemplate;
    
        //@Value("${myspcloud.item.url}")
        //private String itemUrl;
    
        @Autowired
        OrderProperties orderProperties;
    
        public Item queryItemById(Long id) {
            return this.restTemplate.getForObject(orderProperties.getItem().getUrl()
                    + id, Item.class);
        }

第四步，启动类中增加bean扫描路径

@ComponentScan(basePackages = {"com.zpc.order.controller","com.zpc.order.service","com.zpc.order.properties"})//
    手动指定bean扫描范围

第五步，debug运行  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 28]  
可以看出，这种解决方案比第一种好很多，更加的方便的。

思考：

*  这样是否还存在问题？如果商品的微服务有多个怎么办？
 *  我们在订单微服务中使用了Item实体，直接采取从商品微服务拷贝代码的方式是否太生硬？

### 6.SpringCloud快速入门 ###

#### 6.1.分析硬编码的问题 ####

通过前面5.4、5.5的实现，我们视乎已经解决了url硬编码的问题，但是我们想想：  
1、如果商品微服务的ip地址发生了变更，订单微服务中的配置文件也需要跟着修改  
2、如果商品微服务有多个，那么在订单微服务中又该如何写地址？

那应该怎么解决呢？ – 通过服务注册、发现的机制来完成。

#### 6.2.微服务注册与发现 ####

原理示意图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 29]

由上图可以看出：  
1、服务提供者将服务注册到注册中心  
2、服务消费者通过注册中心查找服务  
3、查找到服务后进行调用（这里就是无需硬编码url的解决方案）  
4、服务的消费者与服务注册中心保持心跳连接，一旦服务提供者的地址发生变更时，注册中心会通知服务消费者

#### 6.3.注册中心：Eureka ####

SpringCloud提供了多种注册中心的支持，如：Eureka、consul、ZooKeeper等。Eureka已经闭源了。本教程第二篇也会介绍使用其它两种方式作为注册中心。  
![在这里插入图片描述][20181103224339436.png]

##### 6.3.1.原理 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 30]

Eureka包含两个组件：`Eureka Server`和`Eureka Client`。

*  Eureka Server提供服务注册服务，各个节点启动后，会在Eureka Server中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。
 *  Eureka Client是一个java客户端，用于简化与Eureka Server的交互，客户端同时也就别一个内置的、使用轮询(round-robin)负载算法的负载均衡器。
 *  在应用启动后，将会向Eureka Server发送心跳,默认周期为30秒，如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)。
 *  Eureka Server之间通过复制的方式完成数据的同步，Eureka还提供了客户端缓存机制，即使所有的Eureka Server都挂掉，客户端依然可以利用缓存中的信息消费其他服务的API。综上，Eureka通过心跳检查、客户端缓存等机制，确保了系统的高可用性、灵活性和可伸缩性。

##### 6.3.2.编写Eureka Server #####

第一步：创建Maven工程：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 31]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 32]  
第二步，导入依赖：  
这里需要导入SpringCloud的管理依赖。

第三步，编写程序启动类：

package com.zpc.springcloud.eureka;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
    
    /**
     * Eureka注册中心
     */
    @SpringBootApplication
    @EnableEurekaServer //申明这是一个Eureka服务
    public class AppEureka {
    
       public static void main(String[] args) {
          SpringApplication.run(AppEureka.class, args);
       }
    }

第四步，编写application.yml配置文件：

###服务端口号
    server:
      port: 8100
    
    ###服务名称
    spring:
      application:
        name: app-eureka-center
    
    eureka:
      instance:
        #注册中心地址
        hostname: 127.0.0.1
    ###客户端调用地址
      client:
        serviceUrl:
          defaultZone: http://${eureka.instance.hostname}:8100/eureka/
    ###是否将自己注册到Eureka服务中,因为该应用本身就是注册中心，不需要再注册自己（集群的时候为true）
        register-with-eureka: false
    ###是否从Eureka中获取注册信息,因为自己为注册中心,不会在该应用中的检索服务信息
        fetch-registry: false

第五步，启动程序做测试：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 33]

#### 6.4.将商品微服务注册到Eureka ####

接下来，我们需要将商品的微服务注册到Eureka服务中。

第一步：修改pom文件，引入SpringCloud的管理依赖以及eureka服务依赖。

<?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.zpc.microservice</groupId>
        <artifactId>microservice-item</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.6.RELEASE</version>
        </parent>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Finchley.SR1</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <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-client</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <finalName>${project.artifactId}</finalName>
            <plugins>
                
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <configuration>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
                
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

第二步，修改application.yml配置文件：

###服务端口号(本身是一个web项目)
    server:
      port: 8081
    ###起个名字作为服务名称(该服务注册到eureka注册中心的名称，比如商品服务)
    spring:
        application:
            name: app-item
    ###服务注册到eureka注册中心的地址
    eureka:
      client:
        service-url:
               defaultZone: http://127.0.0.1:8100/eureka
    ###因为该应用为服务提供者，是eureka的一个客户端，需要注册到注册中心
        register-with-eureka: true
    ###是否需要从eureka上检索服务
        fetch-registry: true

第三步，修改启动类，增加@EnableEurekaClient 注解：

package com.zpc.item.runner;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    import org.springframework.context.annotation.ComponentScan;
    
    /**
     * @author Evan
     */
    //申明这是一个Spring Boot项目
    @SpringBootApplication
    @EnableEurekaClient
    @ComponentScan(basePackages = {"com.zpc.item.controller","com.zpc.item.service"})
    public class ItemApp {
        public static void main(String[] args) {
            SpringApplication.run(ItemApp.class, args);
        }
    
    }

第四步，启动测试：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 34]

至此，我们已经将自己的微服务注册到Eureka server中了。

#### 6.5.订单系统从Eureka中发现商品服务 ####

之前我们在订单系统中是将商品微服务的地址进行了硬编码，现在，由于已经将商品服务注册到Eureka中，所以，只需要从Eureka中发现服务即可。

第一步，在订单系统中添加依赖：

<?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.zpc.microservice</groupId>
        <artifactId>microservice-order</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.6.RELEASE</version>
        </parent>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Finchley.SR1</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <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-client</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.squareup.okhttp3</groupId>
                <artifactId>okhttp</artifactId>
                <version>3.9.0</version>
            </dependency>
    
        </dependencies>
    
        <build>
            <finalName>${project.artifactId}</finalName>
            <plugins>
                
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-resources-plugin</artifactId>
                    <configuration>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
                
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

第二步，修改application.yml配置文件：

server:
      port: 8082 #服务端口
    myspcloud:
      item:
        url: http://127.0.0.1:8081/item/
    ###起个名字作为服务名称(该服务注册到eureka注册中心的名称，比如订单服务)
    spring:
        application:
            name: app-order
    ###服务注册到eureka注册中心的地址
    eureka:
      client:
        service-url:
               defaultZone: http://127.0.0.1:8100/eureka
    ###因为该应用为服务提供者，是eureka的一个客户端，需要注册到注册中心
        register-with-eureka: true
    ###是否需要从eureka上检索服务
        fetch-registry: true

第三步，修改ItemService的实现逻辑：

package com.zpc.order.service;
    import com.zpc.order.entity.Item;
    import com.zpc.order.properties.OrderProperties;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.client.RestTemplate;
    
    @Service
    public class ItemService {
    
        // Spring框架对RESTful方式的http请求做了封装，来简化操作
        @Autowired
        private RestTemplate restTemplate;
    
        @Autowired
        OrderProperties orderProperties;
    
        public Item queryItemById(Long id) {
    
            // 该方法走eureka注册中心调用(去注册中心根据app-item查找服务，这种方式必须先开启负载均衡@LoadBalanced)
            String itemUrl = "http://app-item/item/{id}";
            Item result = restTemplate.getForObject(itemUrl, Item.class, id);
            System.out.println("订单系统调用商品服务,result:" + result);
            return result;
        }
    }

第四步，在启动类中添加`@EnableEurekaClient`注解 ，获取RestTemplate的方法上加 `@LoadBalanced`注解

package com.zpc.order.runner;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
    import org.springframework.web.client.RestTemplate;
    
    /**
     * @author Evan
     */
    
    @SpringBootApplication//申明这是一个Spring Boot项目
    @EnableEurekaClient
    @ComponentScan(basePackages = {"com.zpc.order.controller", "com.zpc.order.service","com.zpc.order.properties"})//手动指定bean扫描范围
    public class OrderApp {
        public static void main(String[] args) {
            SpringApplication.run(OrderApp.class, args);
        }
    
        /**
         * 向Spring容器中定义RestTemplate对象
         * @return
         */
        @Bean
        @LoadBalanced
        public RestTemplate restTemplate() {
            return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
        }
    
    }

第五步，启动测试（此时有3个应用：Eureka注册中心、Item服务、order服务）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 35]

在注册中心`http://localhost:8100`看到有2个客户端：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 36]

### 7.深入理解Eureka ###

#### 7.1.为Eureka添加用户认证 ####

在前面的示例中，我们可以看到我们需要登录即可访问到Eureka服务，这样其实是不安全的。

接下来，我们为Eureka添加用户认证。

第一步，为Eureka服务端（eureka-server）添加安全认证依赖：

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

第二步，增加application.yml配置文件：

###服务端口号
    server:
      port: 8100
    
    ###服务名称
    spring:
      application:
        name: app-eureka-center
      security:
        basic:
          enable: true #开启基于HTTP basic的认证
        user: #配置用户的账号信息
          name: zpc
          password: 123456
    
    eureka:
      instance:
        #注册中心地址
        hostname: 127.0.0.1
    
    ###客户端调用地址
      client:
        serviceUrl:
          defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:8100/eureka/
    ###是否将自己注册到Eureka服务中,因为该应用本身就是注册中心，不需要再注册自己（集群的时候为true）
        register-with-eureka: false
    ###是否从Eureka中获取注册信息,因为自己为注册中心,不会在该应用中的检索服务信息
        fetch-registry: true

第三步，在eurka服务端添加一个安全认证类：

package com.zpc.springcloud.eureka;
    
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    import org.springframework.security.config.http.SessionCreationPolicy;
    
    @Configuration
    @EnableWebSecurity
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    
        /**
         * 高版本springcloud的丢弃了配置:
         *
         * security:
         *   basic:
         *    enabled: true
         *
         * 所以应该使用以下方式开启
         *
         * @param http
         * @throws Exception
         */
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            // Configure HttpSecurity as needed (e.g. enable http basic).
            http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.NEVER);
            http.csrf().disable();
            //注意：为了可以使用 http://${user}:${password}@${host}:${port}/eureka/ 这种方式登录,所以必须是httpBasic,
            // 如果是form方式,不能使用url格式登录
            http.authorizeRequests().anyRequest().authenticated().and().httpBasic();
        }
    }

第四步，重新启动Eureka服务进行测试：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 37]

输入正确的用户名密码即可登录。

这时，服务提供者注册到Eureka时会报错：

2018-10-31 23:01:13.419  WARN 143840 --- [nfoReplicator-0] c.n.d.s.t.d.RetryableEurekaHttpClient    : Request execution failure with status code 401; retrying on another server if available
    2018-10-31 23:01:13.420  WARN 143840 --- [nfoReplicator-0] com.netflix.discovery.DiscoveryClient    : DiscoveryClient_APP-ORDER/Evan-Zhou:app-order:8082 - registration failed Cannot execute request on any known server
    
    com.netflix.discovery.shared.transport.TransportException: Cannot execute request on any known server

所以，需要在服务注册时也需要设置用户名和密码。

##### 7.1.1.服务注册时(client端)设置账户信息 #####

服务注册到有认证需求的注册中心时，需要设置如下地址：

`http://USER:PASSWORD@127.0.0.1:端口号/eureka/`

配置如下（至此，Eureka注册中心、Item服务、order服务3个配置文件全部改成了带账号密码的请求地址）：

###服务注册到eureka注册中心的地址
    eureka:
      client:
        service-url:
               defaultZone: http://zpc:123456@127.0.0.1:8100/eureka

#### 7.2.Eureka的自我保护模式 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 38]

如图，当前Eureka进入了自我保护模式。(先开启Eureka server端和client端，然后再断开client端，此时刷新Eureka界面，就会看到红色字样)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 39]

在短时间内丢失了服务实例的心跳，不会剔除该服务，这是eurekaserver的自我保护机制的宗旨。主要是为了防止由于短暂的网络故障误删除可用的服务。

所以，一般进入自我保护模式，无需处理。如果，需要禁用自我保护模式，只需要在配置文件中添加配置即可：  
(测试环境、开发环境可以关闭自我保护机制，保证服务不可用时及时剔除)  
配置方式：在server端 配置文件中添加server: 配置

eureka:
      instance:
        #注册中心地址
        hostname: 127.0.0.1
    
    ###客户端调用地址
      client:
        serviceUrl:
          defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:8100/eureka/
        register-with-eureka: false
        fetch-registry: true
    
      server:
          enable-self-preservation: false #禁用自我保护模式

重新启动服务查看效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 40]  
提示，如果禁用自我保护模式，在网络通信故障下可能会出现问题，因为服务可能只是短暂的不可用。  
上述界面出现后，断开client端，此时刷新Eureka界面，就会看到红色字样，同时会把服务实例从注册中心剔除：`No instances available`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 41]

#### 7.3.Eureka的高可用(Eureka集群) ####

前面的测试，我们会发现，Eureka服务是一个单点服务，在生产环境就会出现单点故障，为了确保Eureka服务的高可用，我需要搭建Eureka服务的集群。

搭建Eureka集群非常简单，只要启动多个Eureka Server服务并且让这些Server端之间彼此进行注册即可实现。

第一步，修改eureka server端的application.yml文件：

*  端口为8100的机器注册到端口为9100的注册中心

###服务端口号
    server:
      port: 8100
    
    ###服务名称
    spring:
      application:
        name: app-eureka-center
      security:
        basic:
          enable: true #开启基于HTTP basic的认证
        user: #配置用户的账号信息
          name: zpc
          password: 123456
    
    eureka:
      instance:
        #注册中心地址
        hostname: 127.0.0.1
    
    ###客户端调用地址
      client:
        serviceUrl:
          defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:9100/eureka/
    ###是否将自己注册到Eureka服务中,集群的时候为true
        register-with-eureka: true
        fetch-registry: true
    
      server:
          enable-self-preservation: false

第二步，修改配置文件，再建一个Eureka server工程，启动两个工程（两个工程的name属性一样）测试：

*  端口为9100的机器注册到端口为8100的注册中心

###服务端口号
    server:
     port: 9100
    
    ###服务名称
    spring:
     application:
       name: app-eureka-center
     security:
       basic:
         enable: true #开启基于HTTP basic的认证
       user: #配置用户的账号信息
         name: zpc
         password: 123456
    
    eureka:
     instance:
       #注册中心地址
       hostname: 127.0.0.1
    ###客户端调用地址
     client:
       serviceUrl:
         defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:8100/eureka/
    ###是否将自己注册到Eureka服务中,集群的时候为true
       register-with-eureka: true
       fetch-registry: true
    ###测试环境、开发环境可以关闭自我保护机制，保证服务不可用时及时剔除
     server:
       enable-self-preservation: false
       eviction-interval-timer-in-ms: 2000

测试结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 42]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 43]

可以看到，2个Eureka服务进行了彼此注册。

#### 7.4.将client端服务注册到Eureka高可用集群 ####

服务注册到Eureka集群时，可以指定多个，也可以指定一个Eureka服务（因为Eureka服务集群间彼此互联）。

修改商品微服务项目microservice-item的application.yml配置文件，defaultZone 写上所有注册中心的地址：

###服务端口号(本身是一个web项目)
    server:
      port: 8081
    ###起个名字作为服务名称(该服务注册到eureka注册中心的名称，比如商品服务)
    spring:
        application:
            name: app-item
    ###服务注册到eureka注册中心的地址
    eureka:
      client:
        service-url:
               defaultZone: http://zpc:123456@127.0.0.1:8100/eureka/,http://zpc:123456@127.0.0.1:9100/eureka/
    ###因为该应用为服务提供者，是eureka的一个客户端，需要注册到注册中心
        register-with-eureka: true
    ###是否需要从eureka上检索服务
        fetch-registry: true

重启启动，测试：可以通过停止其中一个Eureka server服务进行测试，结果会发现集群是高可用。  
即：启动2个Eureka服务端(注册中心)，1个商品服务（item），1个订单服务（order）。停掉其中一个Eureka服务端后，访问另外一个Eureka服务端页面可以看到item服务立马切换到此注册中心，订单服务照样可以访问商品服务，浏览器输入`http://localhost:8082/order/201810300001`还能获取到商品数据（因为商品服务同时注册到了2个注册中心）。

为了防止是缓存的效果，OrderService 再加一条数据201810300002 ，用`http://localhost:8082/order/201810300002`测试高可用。

package com.zpc.order.service;
    
    import com.zpc.order.entity.Item;
    import com.zpc.order.entity.Order;
    import com.zpc.order.entity.OrderDetail;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.*;
    
    @Service
    public class OrderService {
    
        private static final Map<String, Order> ORDER_DATA = new HashMap<String, Order>();
    
        static {
            // 模拟数据库，构造测试数据
            Order order1 = new Order();
            order1.setOrderId("201810300001");
            order1.setCreateDate(new Date());
            order1.setUpdateDate(order1.getCreateDate());
            order1.setUserId(1L);
            List<OrderDetail> orderDetails1 = new ArrayList<OrderDetail>();
    
            Item item = new Item();// 此处并没有商品的数据，只是保存了商品ID，需要调用商品微服务获取
            item.setId(1L);
            orderDetails1.add(new OrderDetail(order1.getOrderId(), item));
    
            item = new Item(); // 构造第二个商品数据
            item.setId(6L);
            orderDetails1.add(new OrderDetail(order1.getOrderId(), item));
            order1.setOrderDetails(orderDetails1);
            ORDER_DATA.put(order1.getOrderId(), order1);
    
            Order order2 = new Order();
            order2.setOrderId("201810300002");
            order2.setCreateDate(new Date());
            order2.setUpdateDate(order2.getCreateDate());
            order2.setUserId(3L);
            List<OrderDetail> orderDetails2 = new ArrayList<OrderDetail>();
    
            Item item2 = new Item();// 此处并没有商品的数据，只是保存了商品ID，需要调用商品微服务获取
            item2.setId(3L);
            orderDetails2.add(new OrderDetail(order2.getOrderId(), item2));
    
            item2 = new Item(); // 构造第二个商品数据
            item2.setId(5L);
            orderDetails2.add(new OrderDetail(order2.getOrderId(), item2));
            order2.setOrderDetails(orderDetails2);
            ORDER_DATA.put(order2.getOrderId(), order2);
        }
    
        @Autowired
        private ItemService itemService;
    
        /**
         * 根据订单id查询订单数据
         *
         * @param orderId
         * @return
         */
        public Order queryOrderById(String orderId) {
            Order order = ORDER_DATA.get(orderId);
            if (null == order) {
                return null;
            }
            List<OrderDetail> orderDetails = order.getOrderDetails();
            for (OrderDetail orderDetail : orderDetails) {
                // 通过商品微服务查询商品详细数据
                Item item = this.itemService.queryItemById(orderDetail.getItem()
                        .getId());
                if (null == item) {
                    continue;
                }
                orderDetail.setItem(item);
            }
    
            return order;
        }
    
    }

#### 7.5.指定服务的IP地址 ####

在服务的提供者配置文件中可以指定ip地址，如下：

###服务注册到eureka注册中心的地址
    eureka:
      client:
        service-url:
               defaultZone: http://zpc:123456@127.0.0.1:8100/eureka/,http://zpc:123456@127.0.0.1:9100/eureka/
    ###因为该应用为服务提供者，是eureka的一个客户端，需要注册到注册中心
        register-with-eureka: true
    ###是否需要从eureka上检索服务
        fetch-registry: true
      instance:
          prefer-ip-address: true #将自己的ip地址注册到Eureka服务中
          ip-address: 127.0.0.1

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 44]

#### 7.6.指定实例id ####

通过instance-id 参数指定服务注册到Eureka中的服务实例id：

eureka:
      client:
        service-url:
               defaultZone: http://zpc:123456@127.0.0.1:8100/eureka/,http://zpc:123456@127.0.0.1:9100/eureka/
    ###因为该应用为服务提供者，是eureka的一个客户端，需要注册到注册中心
        register-with-eureka: true
    ###是否需要从eureka上检索服务
        fetch-registry: true
      instance:
          prefer-ip-address: true #将自己的ip地址注册到Eureka服务中
          ip-address: 127.0.0.1
          instance-id: ${spring.application.name}###${server.port} #指定实例id

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 45]

### 8.负载均衡：Ribbon ###

首先，我们思考一个问题，如果为同一个的提供者在Eureka中注册了多个服务，那么客户端该如何选择服务呢？

这时，就需要在客户端实现服务的负载均衡。

在SpringCloud中推荐使用Ribbon来实现负载均衡。

#### 8.1.Ribbon简介 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 46]

#### 8.2.架构 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 47]

#### 8.3.开始使用SpringCloud Ribbon ####

##### 8.3.1.为microservice order增加ribbon依赖 #####

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

其实，该依赖是可以省略的，因为spring-cloud-starter-netflix-eureka-client中已经包含了spring-cloud-starter-netflix-ribbon：  
![在这里插入图片描述][20181103224730632.png]

##### 8.3.2.为RestTemplate设置@LoadBalanced注解 #####

package com.zpc.order.runner;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
    import org.springframework.web.client.RestTemplate;
    
    /**
     * @author Evan
     */
    @SpringBootApplication//申明这是一个Spring Boot项目
    @EnableEurekaClient
    @ComponentScan(basePackages = {"com.zpc.order.controller", "com.zpc.order.service","com.zpc.order.properties"})//手动指定bean扫描范围
    public class OrderApp {
        public static void main(String[] args) {
            SpringApplication.run(OrderApp.class, args);
        }
    
        /**
         * 向Spring容器中定义RestTemplate对象
         * @return
         */
        @Bean
        @LoadBalanced
        public RestTemplate restTemplate() {
            return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
        }
    
    }

这样，RestTemplate就具备了负载均衡的功能。

##### 8.3.3.改造ItemService的实现 #####

之前的实现（其实本教程前面没有用这种方式）：

public Item queryItemById(Long id) {
        String serviceId = "app-item";
        List<ServiceInstance> instances = this.discoveryClient.getInstances(serviceId);
        if(instances.isEmpty()){
            return null;
        }
        // 为了演示，在这里只获取第一个实例
        ServiceInstance serviceInstance = instances.get(0);
        String url = serviceInstance.getHost() + ":" + serviceInstance.getPort();
        return this.restTemplate.getForObject("http://" + url + "/item/" + id, Item.class);
    }

改造后的实现（其实本教程一直采用的是这种方式）：

public Item queryItemById(Long id) {
        // 该方法走eureka注册中心调用(这种方式必须先开启负载均衡@LoadBalanced)
        String itemUrl = "http://app-item/item/{id}";
        Item result = restTemplate.getForObject(itemUrl, Item.class, id);
        System.out.println("订单系统调用商品服务,result:" + result);
        return result;
    }

可以发现，实现更加简化了。  
这种方式关键在于获取RestTemplat对象时要加上@LoadBalanced注解 ，否则restTemplate.getForObject方法会报java.net.UnknownHostException: app-item，而前面一种方式是手动指定了获取的服务实例，不需要加此注解。

##### 8.3.4.重启订单服务进行测试 #####

测试结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 48]

结果显示，可以正常获取到商品数据。

内部原理（可以启动多个item实例看效果，比如端口分别设为8081,8091，在下面2个类里打断点）：  
`org.springframework.cloud.client.loadbalancer.LoadBalancerInterceptor`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 49]  
`org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 50]

在执行请求前会经过`org.springframework.cloud.client.loadbalancer.LoadBalancerInterceptor`这个拦截器，并且在`org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient`中，通过serverId查找服务地址，通过一定的负载均衡策略去做真正的请求。

##### 8.3.5.测试负载均衡 #####

测试方法：  
第一步，启动2个microservice-item服务（多个也可以）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 51]  
第二步，导入测试依赖，编写单元测试用例：

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

第三步，编写测试用例：

package com.zpc.test;
    
    import com.zpc.order.runner.OrderApp;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
    import org.springframework.context.annotation.Import;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    @RunWith(SpringJUnit4ClassRunner.class)
    @SpringBootTest(classes = ItemServiceTest.class)
    @Import(OrderApp.class)
    public class ItemServiceTest {
    
        @Autowired
        private LoadBalancerClient loadBalancerClient;//自动注入
    
        @Test
        public void test() {
            String serviceId = "app-item";
            for (int i = 0; i < 100; i++) {
                ServiceInstance serviceInstance = this.loadBalancerClient.choose(serviceId);
                System.out.println("第" + (i + 1) + "次：" + serviceInstance.getHost() + ": " + serviceInstance.getPort());
            }
        }
    
    }

测试结果：  
第1次：127.0.0.1: 8091  
第2次：127.0.0.1: 8081  
第3次：127.0.0.1: 8091  
第4次：127.0.0.1: 8081  
第5次：127.0.0.1: 8091  
第6次：127.0.0.1: 8081  
第7次：127.0.0.1: 8091  
第8次：127.0.0.1: 8081  
第9次：127.0.0.1: 8091  
第10次：127.0.0.1: 8081  
第11次：127.0.0.1: 8091  
第12次：127.0.0.1: 8081  
第13次：127.0.0.1: 8091  
第14次：127.0.0.1: 8081  
第15次：127.0.0.1: 8091  
第16次：127.0.0.1: 8081  
第17次：127.0.0.1: 8091  
第18次：127.0.0.1: 8081  
第19次：127.0.0.1: 8091  
第20次：127.0.0.1: 8081  
第21次：127.0.0.1: 8091  
第22次：127.0.0.1: 8081  
第23次：127.0.0.1: 8091  
第24次：127.0.0.1: 8081  
第25次：127.0.0.1: 8091  
第26次：127.0.0.1: 8081  
第27次：127.0.0.1: 8091  
第28次：127.0.0.1: 8081  
第29次：127.0.0.1: 8091  
第30次：127.0.0.1: 8081  
第31次：127.0.0.1: 8091  
第32次：127.0.0.1: 8081  
第33次：127.0.0.1: 8091  
第34次：127.0.0.1: 8081  
第35次：127.0.0.1: 8091  
第36次：127.0.0.1: 8081  
第37次：127.0.0.1: 8091  
第38次：127.0.0.1: 8081  
第39次：127.0.0.1: 8091  
第40次：127.0.0.1: 8081  
…

或者在应用程序里测试，比如在item微服务里打印端口信息，这样多启动几个item服务，多次请求可以看到效果：

package com.zpc.item.controller;
    
    import com.zpc.item.entity.Item;
    import com.zpc.item.service.ItemService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author Evan
     */
    @RestController
    public class ItemController {
    
        @Value("${server.port}")
        private String port;
    
        @Autowired
        private ItemService itemService;
    
        /**
         * 对外提供接口服务，查询商品信息
         *
         * @param id
         * @return
         */
        @GetMapping(value = "item/{id}")
        public Item queryItemById(@PathVariable("id") Long id) {
            System.out.println("service port："+port);
            return this.itemService.queryItemById(id);
        }
    
    }

#### 8.4.设置负载均衡策略 ####

只需要在配置文件中添加配置  
`serviceId.ribbon.NFLoadBalancerRuleClassName=自定义的负载均衡策略类`

例如在order微服务的yml配置文件中添加：

app-item:
      ribbon:
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

其中`app-item`是要访问的服务id

测试：  
第1次：127.0.0.1: 8081  
第2次：127.0.0.1: 9081  
第3次：127.0.0.1: 9081  
第4次：127.0.0.1: 8081  
第5次：127.0.0.1: 9081  
第6次：127.0.0.1: 8081  
第7次：127.0.0.1: 9081  
第8次：127.0.0.1: 9081  
第9次：127.0.0.1: 8081  
第10次：127.0.0.1: 8081  
第11次：127.0.0.1: 8081  
第12次：127.0.0.1: 8081  
第13次：127.0.0.1: 8081  
第14次：127.0.0.1: 9081  
第15次：127.0.0.1: 9081  
第16次：127.0.0.1: 9081  
第17次：127.0.0.1: 8081  
第18次：127.0.0.1: 9081  
第19次：127.0.0.1: 8081  
第20次：127.0.0.1: 8081

#### 8.5.其它策略 ####

接口：`com.netflix.loadbalancer.IRule`，其实现类：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 52]  
策略描述：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 53]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 54]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 55]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 56]

### 9.容错保护：Hystrix ###

#### 9.1.分析 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 57]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 58]

#### 9.2.雪崩效应 ####

*  在微服务架构中通常会有多个服务层调用，基础服务的故障可能会导致级联故障，进而造成整个系统不可用的情况，这种现象被称为服务雪崩效应。服务雪崩效应是一种因“服务提供者”的不可用导致“服务消费者”的不可用,并将不可用逐渐放大的过程。
 *  如果下图所示：A作为服务提供者，B为A的服务消费者，C和D是B的服务消费者。A不可用引起了B的不可用，并将不可用像滚雪球一样放大到C和D时，雪崩效应就形成了。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 59]

#### 9.3.SpringCloud Hystrix简介 ####

主页：https://github.com/Netflix/Hystrix/

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 60]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 61]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 62]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 63]

#### 9.4.原理说明 ####

正常情况：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 64]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 65]  
当对特定服务的呼叫达到一定阈值时（Hystrix中的默认值为5秒内的20次故障），电路打开，不进行通讯。并且是一个隔离的线程中进行的。

#### 9.5.快速入门 ####

在 microservice-order系统中增加Hystrix容错(本教程中order微服务工程主要扮演消费者的角色)。

##### 9.5.1.导入依赖 #####

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

##### 9.5.2.修改ItemService的queryItemById方法 #####

在要做容错处理的方法上加`@HystrixCommand`注解，并指定一个容错方法，即fallbackMethod 。

/**
     * 进行容错处理
     * fallbackMethod的方法参数个数类型要和原方法一致
     *
     * @param id
     * @return
     */
    @HystrixCommand(fallbackMethod = "queryItemByIdFallbackMethod")
    public Item queryItemById3(Long id) {
        String itemUrl = "http://app-item/item/{id}";
        Item result = restTemplate.getForObject(itemUrl, Item.class, id);
        System.out.println("===========HystrixCommand queryItemById-线程池名称：" + Thread.currentThread().getName() + "订单系统调用商品服务,result:" + result);
        return result;
    }
    
    /**
     * 请求失败执行的方法
     * fallbackMethod的方法参数个数类型要和原方法一致
     *
     * @param id
     * @return
     */
    public Item queryItemByIdFallbackMethod(Long id) {
        return new Item(id, "查询商品信息出错!", null, null, null);
    }

##### 9.5.3.在启动类OrderApplication添加@EnableHystrix注解 #####

/**
     * @author Evan
     */
    @SpringBootApplication
    @EnableEurekaClient
    @EnableHystrix
    @ComponentScan(basePackages = {"com.zpc.order.controller", "com.zpc.order.service","com.zpc.order.properties"})//手动指定bean扫描范围
    public class OrderApp {
        public static void main(String[] args) {
            SpringApplication.run(OrderApp.class, args);
        }
    
        /**
         * 向Spring容器中定义RestTemplate对象
         * @return
         */
        @Bean
        @LoadBalanced
        public RestTemplate restTemplate() {
            return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
        }
    
    }

##### 9.5.4.在Controller增加一个入口 #####

OrderService中增加：

public Order queryOrderByIdx(String orderId) {
        Order order = ORDER_DATA.get(orderId);
        if (null == order) {
            return null;
        }
        List<OrderDetail> orderDetails = order.getOrderDetails();
        for (OrderDetail orderDetail : orderDetails) {
            // 通过商品微服务查询商品详细数据
            Item item = this.itemService.queryItemById3(orderDetail.getItem()
                    .getId());
            if (null == item) {
                continue;
            }
            orderDetail.setItem(item);
        }
    
        return order;
    }

##### 9.5.5.重新启动进行测试 #####

`http://localhost:8082/order/201810300001`  
`http://localhost:8082/order2/201810300001`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 66]

测试一切正常。可以发现加了@HystrixCommand注解的方法和普通方法不是共用的线程池，是隔离的：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 67]

接下来，我们把商品服务停止进行测试：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 68]

*  可以看到，使用了hystrix容错机制时订单服务(app-order)正常，尽管查询商品服务(app-item)已停止服务，查询到的是错误信息。
 *  由此可见，商品服务的宕机并没有影响订单服务的正常工作，起到的容错效果。

如果调用没有做Hytrix容错的方法，则直接返回异常信息：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 69]

#### 9.6.定义统一的fallback接口 ####

如果在每个方法里都定义对应的fallback方法，显得太臃肿，实际项目中可以单独使用一个类定义各种fallback，在使用feign客户端时使用统一fallback接口。  
详情请见本教程的姊妹篇 [Spring cloud详细教程2 ][Spring cloud_2]:介绍了其它SpringCloud组件。

欢迎关注公众号「程猿薇茑」

![20191130143507670.jpg][]

微信扫一扫

[Link 1]: https://blog.csdn.net/hellozpc/category_11127579.html
[https_bigbird.blog.csdn.net_article_details_108770504]: https://bigbird.blog.csdn.net/article/details/108770504
[https_bigbird.blog.csdn.net_article_details_81436980]: https://bigbird.blog.csdn.net/article/details/81436980
[https_blog.csdn.net_hellozpc_article_details_109413465]: https://blog.csdn.net/hellozpc/article/details/109413465
[https_bigbird.blog.csdn.net_article_details_113888604]: https://bigbird.blog.csdn.net/article/details/113888604
[https_blog.csdn.net_hellozpc_article_details_107095951]: https://blog.csdn.net/hellozpc/article/details/107095951
[https_blog.csdn.net_hellozpc_article_details_83692496]: https://blog.csdn.net/hellozpc/article/details/83692496
[https_blog.csdn.net_hellozpc_article_details_80878563]: https://blog.csdn.net/hellozpc/article/details/80878563
[https_blog.csdn.net_hellozpc_article_details_108248227]: https://blog.csdn.net/hellozpc/article/details/108248227
[https_blog.csdn.net_hellozpc_article_details_107582771]: https://blog.csdn.net/hellozpc/article/details/107582771
[https_bigbird.blog.csdn.net_article_details_81267030]: https://bigbird.blog.csdn.net/article/details/81267030
[https_blog.csdn.net_hellozpc_category_10945233.html]: https://blog.csdn.net/hellozpc/category_10945233.html
[SpringCloud]: https://spring.io/projects/spring-cloud/
[https_download.csdn.net_download_zpcandzhj_10762209]: https://download.csdn.net/download/zpcandzhj/10762209
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70]: /images/20220422/ac80bdd9e22247bcb6b024cf7b9096e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 1]: /images/20220422/c3a999ba0e93469ea77796651fb28028.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 2]: /images/20220422/d6f37dd02ffa4778bc1292efb563c685.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 3]: /images/20220422/1c10119a82a14551805e68e8c4766e63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 4]: /images/20220422/087d986a1373487bad47d624b8eb72f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 5]: /images/20220422/d398733b8c5648b8a6254f28eba49d82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 6]: /images/20220422/e1d13318aaba4690a39c1bc6bbf30d01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 7]: /images/20220422/7912a93b87704eb7ad3e52333909b22b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 8]: /images/20220422/4d176f5252dd4e78b439c6f17933f107.png
[20181103225238934.png]: /images/20220422/0b413b03643a4de29f078d3c64e08834.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 9]: /images/20220422/c5e7bc673e494074bd6600592759e4bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 10]: /images/20220422/c05e6a6996cf4ef6b56e43d5c4d7d60b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 11]: /images/20220422/e5666ba3dddb4b4493af9f45a22ea732.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 12]: /images/20220422/1f99451e7fca42c08fedf81e65a9dd47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 13]: /images/20220422/8873a94cad5e4bb39f4be5d56c39c48c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 14]: /images/20220422/53e1fffe635348fb84f1f6a20f138ada.png
[SpringBoot]: https://blog.csdn.net/hellozpc/article/details/82531834
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 15]: /images/20220422/ac054d76e43340918c9acc23ef1ae460.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 16]: /images/20220422/0fd815e6dfd14f048162ee37eb001ccb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 17]: /images/20220422/502678ffa4ff4b059616c09592a306a1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 18]: /images/20220422/8948ec25a3be4f3096a941cc2a5ef029.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 19]: /images/20220422/c2a43c45141448a59e05a37bff821155.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 20]: /images/20220422/c0251732b6314d08a8277f724b40010f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 21]: /images/20220422/f9e926eedb2f4979b1ee63a6232e5a7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 22]: /images/20220422/2fdbab76d2a34fae8fca5382ccf7e911.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 23]: /images/20220422/4c405d44b72b4a1ea02bf9fc72ab5e5a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 24]: /images/20220422/f6e8968e1acc4936a576764e0f403af3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 25]: /images/20220422/f094651e913c42e3a1fc580abb655e5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 26]: /images/20220422/9aa62de22fdb43ce9b012a26e5da8502.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 27]: /images/20220422/2dc2393e6a87479d95f664c1fe2f1af0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 28]: /images/20220422/20a5a2a76cd84ede86ce544c6dfd1285.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 29]: /images/20220422/5d61c6347bf4455e817e6daf41107e7d.png
[20181103224339436.png]: /images/20220422/82a9d7b1f1904ce3842d52b53c915228.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 30]: /images/20220422/e6c6699c210a493da0de267191614f1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 31]: /images/20220422/9f73c129a08b4cbcb4e760dd14397cd2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 32]: /images/20220422/786656fdd9954958bd164ed539f5a420.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 33]: /images/20220422/b5e6850cf98f460f91a27e2489ac91ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 34]: /images/20220422/b3004c9e857848eaba4ff765a16f3cfd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 35]: /images/20220422/f8cf0aaa20de4e409e358b30a04a404e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 36]: /images/20220422/c689bb56c341466288aee24831fac955.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 37]: /images/20220422/25f164fc0b8f4812aba86fe799d9334f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 38]: /images/20220422/1bd95af2b261489ca4c1ae417fdbcd4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 39]: /images/20220422/bec6dc862ec14246a24de51cc1446064.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 40]: /images/20220422/805ee688a38a4d8482b29fbd4e8ea54f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 41]: /images/20220422/b566c14999e44ebc99c2a48241573656.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 42]: /images/20220422/c46b0096aa18442b8700869e8e5d0e64.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 43]: /images/20220422/890e2e2127f740ada56fdda5d628d5f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 44]: /images/20220422/2e22bee05e2543849b2f865cf8c88608.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 45]: /images/20220422/4b5bffdeeaf043a2b2f96803c2de4df8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 46]: /images/20220422/84522b254c95406e8baf055ed6e1a93b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 47]: /images/20220422/a923830d51d446fdbd241d28d0d6a850.png
[20181103224730632.png]: /images/20220422/41bd8b41381344f3bfbb5807e19b2c10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 48]: /images/20220422/793927d76b8040f3b63634a22b946b01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 49]: /images/20220422/d58739c7d7e74a2eb031db0a2561c8b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 50]: /images/20220422/21242194b4aa44d3a732e2ca82bfa9d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 51]: /images/20220422/fe96d077b0a94ee8bb3adc423b810a7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 52]: /images/20220422/94f0be5543724b698c95e47c2fc2bc77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 53]: /images/20220422/b17a6c8b451f40ffbec4350fe100f6c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 54]: /images/20220422/0861022003a141febefe57de4a8615fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 55]: /images/20220422/7c6f66a966e14a978c3426450e78a480.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 56]: /images/20220422/ab7a7f9a762446ea807d92c519736982.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 57]: /images/20220422/1534e223607c4529809f804d18dd92bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 58]: /images/20220422/3ab6254491ad49ac8221c856bd247313.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 59]: /images/20220422/322534dceaf246d198b63760a192b8c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 60]: /images/20220422/9af10e8e7a12449d94f18f5baeb94aec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 61]: /images/20220422/9b3d88aa876e4aa2b6795503eb68c53c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 62]: /images/20220422/4723efdd9b434081989e0b9a9da57637.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 63]: /images/20220422/60ff745b8677445a9ea052943fa66b77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 64]: /images/20220422/3788fc7450d74c8289a29b8f158ec647.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 65]: /images/20220422/029ebde754ce4af6ab454adab69f8b55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 66]: /images/20220422/4157efea72254432b8ccdb48f0b18fc4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 67]: /images/20220422/2e0f7b25516c40b9a73280272294fd19.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 68]: /images/20220422/478d278d083b4d9d8438f615e984cc12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pwY2FuZHpoag_size_16_color_FFFFFF_t_70 69]: /images/20220422/1c5144bfc2534f97a0524d69e5d76f89.png
[Spring cloud_2]: https://blog.csdn.net/hellozpc/article/details/84144453
[20191130143507670.jpg]: /images/20220422/9752aa4c0c70404cb0c8e881a9d42aa2.png