微服务环境搭建（一）

我就是我 2022-08-31 13:25 228阅读 0赞

### 微服务 ###

*  Spring Cloud Alibaba 组件集合
 *  内容
 *   *  一、微服务概念
     *   *  1. 单体、分布式、集群
         *   *  1.1 单体
             *  1.2 分布式
             *  1.3 集群
         *  2. 系统架构演变
         *   *  2.1 单体应用架构
             *  2.2 垂直应用架构
             *  2.3 分布式架构
             *  2.4 微服务架构
         *  3. 微服务架构介绍
         *  4. SpringCloud介绍(了解)
         *   *  4.1 SpringBoot和SpringCloud有啥关系?
             *  4.2 SpringCloud版本名称?
             *  4.3 为什么选择SpringCloud Alibaba？
 *  二、微服务环境搭建
 *   *   *  1. 技术选型
         *  2. 模块设计
         *  3. 微服务调用
         *  4. 版本说明
         *  5. 创建父工程
         *  6. 创建商品微服务
         *  7. 创建订单微服务
         *  8. 服务间如何进行远程调用
 *  总结

# Spring Cloud Alibaba 组件集合 #

### [配置 Nacos 注册中心（二）][Nacos] ###

### [使用负载均衡器 Ribbon 实现负载均衡（三）][Ribbon] ###

### [配置远程调用 Feign（四）][Feign] ###

### [配置容错组件 Sentinel（五）][Sentinel] ###

# 内容 #

## 一、微服务概念 ##

### 1. 单体、分布式、集群 ###

我们学习微服务之前,需要先理解单体、集群、分布式这些概念，这样会帮助我们在学习后面课程会更加容易些.

#### 1.1 单体 ####

一个系统业务量很小的时候所有的代码都放在一个项目中就好了，然后这个项目部署在一台服务器上就好了。整个项目所有的服务都由这台服务器提供。这就是单机结构。  
![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XTsH1Kue-1627228546871)(图片/image-20201027172014044.png)\]][img-XTsH1Kue-1627228546871_image-20201027172014044.png]  
  单体应用开发简单,部署测试简单.但是存在一些问题,比如:单点问题,单机处理能力有限,当你的业务增长到一定程度的时候，单机的硬件资源将无法满足你的业务需求。

#### 1.2 分布式 ####

由于整个系统运行需要使用到Tomcat和MySQL，单台服务器处理的能力有限,2G的内存需要分配给Tomcat和MySQL使用，，随着业务越来越复杂，请求越来越多. 内存越来越不够用了，所以这时候我们就需要进行分布式的部署.  
![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o783Wnlj-1627228546879)(图片/image-20201027173909529.png)\]][img-o783Wnlj-1627228546879_image-20201027173909529.png]  
  我们进行一个评论的请求，这个请求是需要依赖**分布**在两台不同的服务器的组件\[Tomat和MySQL\],才能完成的. 所以叫做分布式的系统.

#### 1.3 集群 ####

在上面的图解中其实是存在问题的，比如Tomcat存在单点故障问题，一旦Tomcat所在的服务器宕机不可用了，我们就无法提供服务了,所以针对单点故障问题，我们会使用集群来解决.那什么是集群模式呢?

单机处理到达瓶颈的时候，你就把单机复制几份，这样就构成了一个“集群”。集群中每台服务器就叫做这个集群的一个“节点”，所有节点构成了一个集群。每个节点都提供相同的服务，那么这样系统的处理能力就相当于提升了好几倍（有几个节点就相当于提升了这么多倍）。

但问题是用户的请求究竟由哪个节点来处理呢？最好能够让此时此刻负载较小的节点来处理，这样使得每个节点的压力都比较平均。要实现这个功能，就需要在所有节点之前增加一个“调度者”的角色，用户的所有请求都先交给它，然后它根据当前所有节点的负载情况，决定将这个请求交给哪个节点处理。这个“调度者”有个牛逼了名字——负载均衡服务器。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70]  
  我们在上面的图中仅展示了Tomcat的集群，如果MySQL压力比较大的情况下，我们也是可以对MySQL进行集群的.

### 2. 系统架构演变 ###

随着互联网的发展，网站应用的规模也不断的扩大，进而导致系统架构也在不断的变化。  
  从互联网早期到现在，系统架构大体经历了下面几个过程: 单体应用架构—>垂直应用架构—>分布式架构—>微服务架构。  
  接下来我们就来了解一下每种系统架构是什么样子的， 以及各有什么优缺点。

#### 2.1 单体应用架构 ####

互联网早期，一般的网站应用流量较小，只需一个应用，将所有功能代码都部署在一起就可以，这样可以减少开发、部署和维护的成本。

比如说一个电商系统，里面会包含很多用户管理，商品管理，订单管理，物流管理等等很多模块，我们会把它们做成一个web项目，然后部署到一台tomcat服务器上。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 1]

**优点：**

*  项目架构简单，小型项目的话， 开发成本低
 *  项目部署在一个节点上， 维护方便

**缺点：**

*  全部功能集成在一个工程中，对于大型项目来讲不易开发和维护
 *  项目模块之间紧密耦合，单点容错率低
 *  无法针对不同模块进行针对性优化和水平扩展

#### 2.2 垂直应用架构 ####

随着访问量的逐渐增大，单一应用只能依靠增加节点来应对，但是这时候会发现并不是所有的模块都会有比较大的访问量；

还是以上面的电商为例子， 用户访问量的增加可能影响的只是用户和订单模块， 但是对消息模块的影响就比较小. 那么此时我们希望只多增加几个订单模块， 而不增加消息模块. 此时单体应用就做不到了， 垂直应用就应运而生了；

所谓的垂直应用架构，就是将原来的一个应用拆成互不相干的几个应用，以提升效率。比如我们可以将上面电商的单体应用拆分成:

*  电商系统(用户管理 商品管理 订单管理)
 *  后台系统(用户管理 订单管理 客户管理)
 *  CMS系统(广告管理 营销管理)

这样拆分完毕之后，一旦用户访问量变大，只需要增加电商系统的节点就可以了，而无需增加后台和CMS的节点。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 2]

**优点：**

*  系统拆分实现了流量分担，解决了并发问题，而且可以针对不同模块进行优化和水平扩展
 *  一个系统的问题不会影响到其他系统，提高容错率

**缺点：**

*  系统之间相互独立， 无法进行相互调用
 *  系统之间相互独立， 会有重复的开发任务

#### 2.3 分布式架构 ####

当垂直应用越来越多，重复的业务代码就会越来越多。这时候，我们就思考可不可以将重复的代码抽取出来，做成统一的业务层作为独立的服务，然后由前端控制层调用不同的业务层服务呢？

这就产生了新的分布式系统架构。它将把工程拆分成表现层和服务层两个部分，服务层中包含业务逻辑。表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 3]

**优点**：

*  抽取公共的功能为服务层，提高代码复用性

**缺点**：

*  系统间耦合度变高，调用关系错综复杂，难以维护

#### 2.4 微服务架构 ####

微服务架构在某种程度上是面向服务的架构，它更加强调服务的"彻底拆分"。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 4]  
**优点**：

*  服务原子化拆分，独立打包、部署和升级，保证每个微服务清晰的任务划分，利于扩展
 *  微服务之间采用RESTful等轻量级Http协议相互调用

**缺点**：

*  分布式系统开发的技术成本高（容错、分布式事务等）

### 3. 微服务架构介绍 ###

微服务架构， 简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目。

**微服务架构的常见问题**

一旦采用微服务系统架构，就势必会遇到这样几个问题：

*  这么多小服务，如何管理他们？
 *  这么多小服务，他们之间如何通讯？
 *  这么多小服务，客户端怎么访问他们？
 *  这么多小服务，一旦出现问题了，应该如何自处理？
 *  这么多小服务，一旦出现问题了，应该如何排错?

对于上面的问题，是任何一个微服务设计者都不能绕过去的，因此大部分的微服务产品都针对每一个问题提供了相应的组件来解决它们。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 5]

### 4. SpringCloud介绍(了解) ###

Spring Cloud是一系列框架的集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。

Spring Cloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

#### 4.1 SpringBoot和SpringCloud有啥关系? ####

*  SpringBoot专注于快速方便的开发单个个体微服务。
 *  SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务整合并管理起来，为各个微服务之间提供，配置管理、服务发现、断路器、路由、事件总线、分布式事务、等等集成服务。

**总结**: SpringBoot专注于快速、方便的开发单个微服务个体，SpringCloud关注全局的服务治理组件的集合。

#### 4.2 SpringCloud版本名称? ####

Spring Cloud不同其他独立项目，它是拥有很多子项目的大项目。所以它是的版本是 版本名+版本号 （如Greenwich.SR6）。  
  版本名：是伦敦的地铁名  
  版本号：SR（Service Releases）是固定的 ,大概意思是稳定版本。后面会有一个递增的数字。  
  所以 Greenwich.SR6就是Greenwich的第6个Release版本。

#### 4.3 为什么选择SpringCloud Alibaba？ ####

我们这里为什么选择SpringCloud Alibaba呢，主要因为SpringCloud Netflix的组件：服务注册与发现的 Eureka、服务限流降级的 Hystrix、网关 Zuul都已经停止更新了，当然继续使用是没问题的，只是出现问题，官方不维护，需要自行解决。

# 二、微服务环境搭建 #

我们在讲解SpringCloud的课程中，使用简单易懂的模块给同学讲解里面相关的组件.

**商品微服务**

*  查询商品列表

**订单微服务**

*  创建订单

### 1. 技术选型 ###

持久层: SpingData Jpa  
数据库: MySQL5.7  
其他: SpringCloud Alibaba 技术栈

### 2. 模块设计 ###

— shop-parent 父工程  
— shop-product-api 商品微服务api 【存放商品实体】  
— shop-product-server 商品微服务 【端口:808x】  
— shop-order-api 订单微服务api 【存放订单实体】  
— shop-order-server 订单微服务 【端口:809x】

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

### 3. 微服务调用 ###

在微服务架构中，最常见的场景就是微服务之间的相互调用。我们以电商系统中常见的**用户下单**为例来演示微服务的调用：客户向订单微服务发起一个下单的请求，在进行保存订单之前需要调用商品微服务查询商品的信息。  
  我们一般把服务的主动调用方称为**服务消费者**，把服务的被调用方称为**服务提供者**。  
![在这里插入图片描述][59120480fe564051888df307bf4c1633.png]  
  在这种场景下，订单微服务就是一个服务消费者， 商品微服务就是一个服务提供者。

### 4. 版本说明 ###

[https://github.com/alibaba/spring-cloud-alibaba/wiki/][https_github.com_alibaba_spring-cloud-alibaba_wiki]版本说明  
![\*\*\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GtcV4cz6-1627228546896)(图片/image-20201028150721156.png)\]\*\*][img-GtcV4cz6-1627228546896_image-20201028150721156.png]

### 5. 创建父工程 ###

创建一个maven工程，然后在pom.xml文件中添加下面内容

<?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>cn.wolfcode</groupId>
        <artifactId>shop-parent</artifactId>
        <version>1.0.0</version>
        <packaging>pom</packaging>
        
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.2.RELEASE</version>
        </parent>
        
        <properties>
            <java.version>1.8</java.version>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
            <spring-cloud-alibaba.version>2.2.3.RELEASE</spring-cloud-alibaba.version>
        </properties>
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <dependency>
                    <groupId>com.alibaba.cloud</groupId>
                    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                    <version>${spring-cloud-alibaba.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    </project>

### 6. 创建商品微服务 ###

1.创建shop-product-api项目，然后在pom.xml文件中添加下面内容

2.创建实体类

//商品
    @Entity(name = "t_shop_product")
    @Data
    public class Product { 
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long pid;//主键
        private String pname;//商品名称
        private Double pprice;//商品价格
        private Integer stock;//库存
    }

3.创建shop-product-server项目，然后在pom.xml文件中添加下面内容

4.编写启动类ProductServer.java

package cn.wolfcode;
    @SpringBootApplication
    public class ProductServer { 
        public static void main(String[] args) { 
            SpringApplication.run(ProductServer.class,args);
        }
    }

5.编写配置文件application.yml

server:
      port: 8081
    spring:
      application:
        name: product-service
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql:///shop-product?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
        username: root
        password: admin
      jpa:
        properties:
          hibernate:
            hbm2ddl:
              auto: update
            dialect: org.hibernate.dialect.MySQL5InnoDBDialect

6.在数据库中创建shop-product的数据库

7.创建ProductDao

package cn.wolfcode.dao;
    public interface ProductDao extends JpaRepository<Product, Long> { 
    }

8.创建ProductService接口和实现类

package cn.wolfcode.service.impl;
    @Service
    public class ProductServiceImpl implements ProductService { 
        @Autowired
        private ProductDao productDao;
        @Override
        public Product findByPid(Long pid) { 
            return productDao.findById(pid).get();
        }
    }

9.创建Controller

package cn.wolfcode.controller;
    @RestController
    @Slf4j
    public class ProductController { 
        @Autowired
        private ProductService productService;
        //商品信息查询
        @RequestMapping("/product")
        public Product findByPid(@RequestParam("pid") Long pid) { 
            log.info("接下来要进行{}号商品信息的查询", pid);
            Product product = productService.findByPid(pid);
            log.info("商品信息查询成功,内容为{}", JSON.toJSONString(product));
            return product;
        }
    }

10.启动工程，等到数据库表创建完毕之后，加入测试数据

INSERT INTO t_shop_product VALUE(NULL,'小米','1000','5000'); 
    INSERT INTO t_shop_product VALUE(NULL,'华为','2000','5000'); 
    INSERT INTO t_shop_product VALUE(NULL,'苹果','3000','5000'); 
    INSERT INTO t_shop_product VALUE(NULL,'OPPO','4000','5000');

11.通过浏览器访问服务  
![在这里插入图片描述][f8ee03617d414dbcb95ef8cf16788839.png]

### 7. 创建订单微服务 ###

1.创建shop-order-api项目，然后在pom.xml文件中添加下面内容

2 创建实体类

//订单
    @Entity(name = "t_shop_order")
    @Data
    public class Order { 
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long oid;//订单id
    
        //用户
        private Long uid;//用户id
        private String username;//用户名
        //商品
        private Long pid;//商品id
        private String pname;//商品名称
        private Double pprice;//商品单价
        //数量
        private Integer number;//购买数量
    }

3.创建shop-order-server项目，然后在pom.xml文件中添加下面内容

4.编写启动类OrderServer.java

package cn.wolfcode;
    @SpringBootApplication
    public class OrderServer { 
        public static void main(String[] args) { 
            SpringApplication.run(OrderServer.class,args);
        }
    }

5.编写配置文件application.yml

server:
      port: 8091
    spring:
      application:
        name: order-service
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql:///shop-order?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
        username: root
        password: admin
      jpa:
        properties:
          hibernate:
            hbm2ddl:
              auto: update
            dialect: org.hibernate.dialect.MySQL5InnoDBDialect

6.在数据库中创建shop-order的数据库

7.创建OrderDao

package cn.wolfcode.dao;
    
    public interface OrderDao extends JpaRepository<Order, Long> { 
    }

8.创建OrderService接口和实现类

package cn.wolfcode.service.impl;
    @Service
    @Slf4j
    public class OrderServiceImpl implements OrderService { 
        @Autowired
        private OrderDao orderDao;
        @Override
        public Order createOrder(Long productId,Long userId) { 
            log.info("接收到{}号商品的下单请求,接下来调用商品微服务查询此商品信息", productId);
            //远程调用商品微服务,查询商品信息
            Product product = null;
            log.info("查询到{}号商品的信息,内容是:{}", productId, JSON.toJSONString(product));
            //创建订单并保存
            Order order = new Order();
            order.setUid(userId);
            order.setUsername("叩丁狼教育");
            order.setPid(productId);
            order.setPname(product.getPname());
            order.setPprice(product.getPprice());
            order.setNumber(1);
            orderDao.save(order);
            log.info("创建订单成功,订单信息为{}", JSON.toJSONString(order));
            return order;
        }
    }

9.创建Controller

package cn.wolfcode.controller;
    @RestController
    @Slf4j
    public class OrderController { 
        @Autowired
        private OrderService orderService;
        @RequestMapping("/save")
        public Order order(Long pid,Long uid) { 
            return orderService.createOrder(pid,uid);
        }
    }

### 8. 服务间如何进行远程调用 ###

商品微服务已经提供了数据接口了，订单微服务应该如何去调用呢?  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 7]

其实就是如何通过Java代码去调用一个http的接口地址，我们可以使用RestTemplate来进行调用.

1.在启动类上添加RestTemplate的bean配置

@SpringBootApplication
    public class OrderServer { 
        public static void main(String[] args) { 
            SpringApplication.run(OrderServer.class,args);
        }
        @Bean
        public RestTemplate restTemplate(){ 
            return new RestTemplate();
        }
    }

2.在OrderServiceImpl中注入RestTemplate并实现远程调用

@Service
    @Slf4j
    public class OrderServiceImpl implements OrderService { 
        @Autowired
        private OrderDao orderDao;
        @Autowired
        private RestTemplate restTemplate;
        @Override
        public Order createOrder(Long productId,Long userId) { 
            log.info("接收到{}号商品的下单请求,接下来调用商品微服务查询此商品信息", productId);
            //远程调用商品微服务,查询商品信息
            Product product = restTemplate.getForObject(
                    "http://localhost:8081/product/"+productId,Product.class);
            log.info("查询到{}号商品的信息,内容是:{}", productId, JSON.toJSONString(product));
            //创建订单并保存
            Order order = new Order();
            order.setUid(userId);
            order.setUsername("叩丁狼教育");
            order.setPid(productId);
            order.setPname(product.getPname());
            order.setPprice(product.getPprice());
            order.setNumber(1);
            orderDao.save(order);
            log.info("创建订单成功,订单信息为{}", JSON.toJSONString(order));
            return order;
        }
    }

虽然我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：

*  一旦服务提供者地址变化，就需要手工修改代码
 *  一旦是多个服务提供者，无法实现负载均衡功能
 *  一旦服务变得越来越多，人工维护调用关系困难

那么应该怎么解决呢， 这时候就需要通过注册中心动态的实现**服务治理**。

# 总结 #

以上就是对微服务环境搭建的总结了，代码仅供参考，欢迎讨论交流。  
下篇博客：[使用 Nacos Discovery 注册中心动态的实现服务治理][Nacos]

[Nacos]: https://blog.csdn.net/zzvar/article/details/119091530
[Ribbon]: https://blog.csdn.net/zzvar/article/details/119092274
[Feign]: https://blog.csdn.net/zzvar/article/details/119092516
[Sentinel]: https://blog.csdn.net/zzvar/article/details/119092779
[img-XTsH1Kue-1627228546871_image-20201027172014044.png]: /images/20220829/9426842e8fd3477b86b8a17551d8c17d.png
[img-o783Wnlj-1627228546879_image-20201027173909529.png]: /images/20220829/19b905d677314a0cac67ad79cdc1f56d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70]: /images/20220829/61983f3e36394095b9de3a9ae38bd1ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 1]: /images/20220829/bb4a8f34d4984af083f8c78e257307f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 2]: /images/20220829/ba981c0298d5405dbaede875d686d298.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 3]: /images/20220829/6b61dbe9cd8e466f941063c9563673dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 4]: /images/20220829/ee791e6a33d040c3b55632640cc73408.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 5]: /images/20220829/a817b02fd55d454dbf4ef95da9183992.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 6]: /images/20220829/01c55708b0954960acd9e030745b07b1.png
[59120480fe564051888df307bf4c1633.png]: /images/20220829/781d1e4375f842c794871025da9fc5fe.png
[https_github.com_alibaba_spring-cloud-alibaba_wiki]: https://github.com/alibaba/spring-cloud-alibaba/wiki/
[img-GtcV4cz6-1627228546896_image-20201028150721156.png]: /images/20220829/4b2204c827ef451ea2a22967b6b3ca1c.png
[f8ee03617d414dbcb95ef8cf16788839.png]: /images/20220829/89451fe4911f4588874cef6c69cb0c6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70 7]: /images/20220829/f34808b37f974c53aafc63de7a10de36.png