Spring Cloud Ribbon

￡神魔★判官ぃ 2023-03-06 05:29 26阅读 0赞

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

> Spring Cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具，它基于Netflix Ribbon实现。通过Spring Cloud的封装，可以让我们轻松地将面向服务的REST模版请求自动转换成客户端负载均衡的服务调用。Spring Cloud Ribbon虽然只是一个工具类框架，它不像服务注册中心、配置中心、API网关那样需要独立部署，但是它几乎存在于每一个Spring Cloud构建的微服务和基础设施中。因为微服务间的调用，API网关的请求转发等内容，实际上都是通过Ribbon来实现的，包括后续我们将要介绍的Feign，它也是基于Ribbon实现的工具。所以，对Spring Cloud Ribbon的理解和使用，对于我们使用Spring Cloud来构建微服务非常重要。

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

### 文章目录 ###

*  一、ribbon 服务消费者
 *   *  1.1 RestTemplate
     *  1.2 新建项目
     *  1.3 RibbonController
     *  1.4 启动服务，并访问测试
 *  二、ribbon 负载均衡和重试
 *   *  2.1 Ribbon 负载均衡
     *   *  2.1.1 添加 ribbon 起步依赖（可选）
         *  2.1.2 RestTemplate 设置 \`@LoadBalanced\`
         *  2.1.3 访问路径设置为服务id
         *  2.1.4 访问测试
     *  2.2 ribbon重试
     *   *  2.2.1 pom.xml 添加 spring-retry 依赖
         *  2.2.2 application.yml 配置 ribbon重试
         *  2.2.3 主程序设置 RestTemplate 的请求工厂的超时属性
         *  2.2.4 修改item-service 的 ItemController 添加延迟代码，测试 ribbon 的重试机制
         *  2.2.5 访问，测试 ribbon 重试机制

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

# 一、ribbon 服务消费者 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]  
ribbon 提供了负载均衡和重试功能, 它底层是使用 RestTemplate 进行 Rest api 调用

## 1.1 RestTemplate ##

Ribbon 对RestTemplate进行了封装、增强，提供了**负载均衡**和**重试**的功能

Spring Cloud 使用的一个远程调用工具

RestTemplate 是Springboot提供的一个远程调用工具

*  `getForObject("url", 转换类型, 提交的参数)` — 执行get请求
 *  `postForObject("url", 协议体数据, 转换类型)` — 执行get请求

之前的系统结构是浏览器直接访问后台服务  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]  
接下来通过一个Demo项目演示 Spring Cloud 远程调用  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 2]  
下面我们先不使用ribbon, 单独使用RestTemplate来执行远程调用

1.  新建 ribbon 项目
2.  pom.xml
3.  application.yml
4.  主程序
5.  controller
6.  启动，并访问测试

## 1.2 新建项目 ##

（1）**新建sp06-ribbon 项目**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 3]  
（2）**添加依赖**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 4]  
（3）**pom.xml**

*  eureka-client 中已经包含 ribbon 依赖
 *  需要添加 sp01-commons 依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.2.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>cn.tedu</groupId>
        <artifactId>sp06-ribbon</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>sp06-ribbon</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
            <spring-cloud.version>Hoxton.SR6</spring-cloud.version>
        </properties>
    
        <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>cn.tedu</groupId>
                <artifactId>sp01-commons</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    
        <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>
            </dependencies>
        </dependencyManagement>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>

> 如果得到的是一个xml格式的返回值，那么需要改变一下itemservice,userservice,orderservice,ribbon 四个项目  
> 在项目中的 spring-cloud-starter-netflix-eureka-client 依赖中排除 jackson.dataformat-xml

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>jackson-dataformat-xml</artifactId>
                    <groupId>com.fasterxml.jackson.dataformat</groupId>
                </exclusion>
            </exclusions>
        </dependency>

（4）**application.xml**

spring:
      application:
        name: ribbon
        
    server:
      port: 3001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

（5）**主程序**

*  添加`@EnableDiscoveryClient`注解
 *  创建 RestTemplate 实例

`RestTemplate` 是用来调用其他微服务的工具类，封装了远程调用代码，提供了一组用于远程调用的模板方法，例如：`getForObject()`、`postForObject()` 等

## 1.3 RibbonController ##

package cn.tedu.sp06.controller;
    
    import java.util.List;
    
    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.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.pojo.Order;
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.web.util.JsonResult;
    
    @RestController
    public class RibbonController { 
    	@Autowired
    	private RestTemplate rt;
    	
    	@GetMapping("/item-service/{orderId}")
    	public JsonResult<List<Item>> getItems(@PathVariable String orderId) { 
    	    //向指定微服务地址发送 get 请求，并获得该服务的返回结果 
    	    //{1} 占位符，用 orderId 填充
    		return rt.getForObject("http://localhost:8001/{1}", JsonResult.class, orderId);
    	}
    
    	@PostMapping("/item-service/decreaseNumber")
    	public JsonResult decreaseNumber(@RequestBody List<Item> items) { 
    	    //发送 post 请求
    		return rt.postForObject("http://localhost:8001/decreaseNumber", items, JsonResult.class);
    	}
    
    	/
    	
    	@GetMapping("/user-service/{userId}")
    	public JsonResult<User> getUser(@PathVariable Integer userId) { 
    		return rt.getForObject("http://localhost:8101/{1}", JsonResult.class, userId);
    	}
    
    	@GetMapping("/user-service/{userId}/score") 
    	public JsonResult addScore(
    			@PathVariable Integer userId, Integer score) { 
    		return rt.getForObject("http://localhost:8101/{1}/score?score={2}", JsonResult.class, userId, score);
    	}
    	
    	/
    	
    	@GetMapping("/order-service/{orderId}")
    	public JsonResult<Order> getOrder(@PathVariable String orderId) { 
    		return rt.getForObject("http://localhost:8201/{1}", JsonResult.class, orderId);
    	}
    
    	@GetMapping("/order-service")
    	public JsonResult addOrder() { 
    		return rt.getForObject("http://localhost:8201/", JsonResult.class);
    	}
    }

## 1.4 启动服务，并访问测试 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 3]  
`http://eureka1:2001`

[http://localhost:3001/item-service/35][http_localhost_3001_item-service_35]  
`http://localhost:3001/item-service/decreaseNumber`  
使用postman，POST发送以下格式数据：  
`[{"id":1, "name":"abc", "number":23},{"id":2, "name":"def", "number":11}]`

[http://localhost:3001/user-service/7][http_localhost_3001_user-service_7]  
[http://localhost:3001/user-service/7/score?score=100][http_localhost_3001_user-service_7_score_score_100]

[http://localhost:3001/order-service/123abc][http_localhost_3001_order-service_123abc]  
[http://localhost:3001/order-service/][http_localhost_3001_order-service]

# 二、ribbon 负载均衡和重试 #

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

## 2.1 Ribbon 负载均衡 ##

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

*  **Ribbon 的作用，解决的问题：**

1.  **负载均衡（微服务系统必须功能）**  
    访问压力可以分散到多态服务器
2.  **重试（不是必须功能）**  
    当第一次请求失败或等待超时，可以自动发起重试请求

*  **修改 sp06-ribbon 项目**

1.  添加 ribbon 起步依赖（可选，在 eureka client 中已经包含）
2.  `RestTemplate` 设置 `@LoadBalanced`
3.  访问路径设置为服务id

### 2.1.1 添加 ribbon 起步依赖（可选） ###

*  **eureka 依赖中已经包含了 ribbon**

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

### 2.1.2 RestTemplate 设置 `@LoadBalanced` ###

`@LoadBalanced` 负载均衡注解，会对 `RestTemplate` 实例进行封装，创建动态代理对象，并切入（AOP）负载均衡代码，把请求分发到集群中的服务器

添加 `@LoadBalanced`注解，用Ribbon封装 `RestTemplate` 对象，对 `RestTemplate`功能进行增强

### 2.1.3 访问路径设置为服务id ###

*  在 RibbonController 中，请求的后台服务路径，改成 `service-id`，根据eureka地址表，可以获取这个服务的集群主机地址列表

restTemplate.getForObject("http://item-service/{1}", .......)

package cn.tedu.sp06.controller;
    
    import java.util.List;
    
    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.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.pojo.Order;
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.web.util.JsonResult;
    
    @RestController
    public class RibbonController { 
    	@Autowired
    	private RestTemplate rt;
    	
    	@GetMapping("/item-service/{orderId}")
    	public JsonResult<List<Item>> getItems(@PathVariable String orderId) { 
    	    //这里服务器路径用 service-id 代替，ribbon 会向服务的多台集群服务器分发请求
    		return rt.getForObject("http://item-service/{1}", JsonResult.class, orderId);
    	}
    
    	@PostMapping("/item-service/decreaseNumber")
    	public JsonResult decreaseNumber(@RequestBody List<Item> items) { 
    		return rt.postForObject("http://item-service/decreaseNumber", items, JsonResult.class);
    	}
    
    	/
    	
    	@GetMapping("/user-service/{userId}")
    	public JsonResult<User> getUser(@PathVariable Integer userId) { 
    		return rt.getForObject("http://user-service/{1}", JsonResult.class, userId);
    	}
    
    	@GetMapping("/user-service/{userId}/score") 
    	public JsonResult addScore(
    			@PathVariable Integer userId, Integer score) { 
    		return rt.getForObject("http://user-service/{1}/score?score={2}", JsonResult.class, userId, score);
    	}
    	
    	/
    	
    	@GetMapping("/order-service/{orderId}")
    	public JsonResult<Order> getOrder(@PathVariable String orderId) { 
    		return rt.getForObject("http://order-service/{1}", JsonResult.class, orderId);
    	}
    
    	@GetMapping("/order-service")
    	public JsonResult addOrder() { 
    		return rt.getForObject("http://order-service/", JsonResult.class);
    	}
    }

### 2.1.4 访问测试 ###

访问测试，ribbon 会把请求分发到 8001 和 8002 两个服务端口上  
[http://localhost:3001/item-service/34][http_localhost_3001_item-service_34]

![在这里插入图片描述][2020080622252334.png]  
![在这里插入图片描述][2020080622253057.png]

## 2.2 ribbon重试 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 8]  
容错机制

当调用后台服务失败，可以自动重试，如果重试成功，可以向客户端正常返回结果。

添加Ribbon重试：

1.  添加 pring-retry 依赖
2.  设置重试参数：
    
     *  `MaxAutoRetries` \- 单台 服务器的重试次数
     *  `MaxAutoRetriesNextServer` \- 更换服务器的次数
     *  `OkToRetryOnAllOperations` \- 是否对所有类型请求都重试，默认只对 get 重试，如果要对所有请求重试设置成 true

下面两个超时设置不能在 yml 中配置，需要在 java 代码中设置

*  `connectTimeout` \- 建立连接超时时间
 *  `readTimeout` \- 已建立连接并发送了请求，等待响应的超时时间

### 2.2.1 pom.xml 添加 spring-retry 依赖 ###

复制代码到 pom.xml，添加依赖的时候找不到！！！

*  直接复制！！！
 *  直接复制！！！
 *  直接复制！！！

（重要的话说三遍）

<dependency>
    	<groupId>org.springframework.retry</groupId>
    	<artifactId>spring-retry</artifactId>
    </dependency>

### 2.2.2 application.yml 配置 ribbon重试 ###

spring:
      application:
        name: ribbon
        
    server:
      port: 3001
      
    eureka:
      client:    
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    ribbon:
      # 没有提示，而且有黄色警告，需要自己手动写
      MaxAutoRetriesNextServer: 2		# 单台服务器重试次数
      MaxAutoRetries: 1					# 更换服务器的次数
      OkToRetryOnAllOperations: true

*  `ConnectionTimeout`
 *  `ReadTimeout`
 *  `OkToRetryOnAllOperations=true`  
    默认只对GET请求重试, 当设置为true时, 对POST等所有类型请求都重试
 *  `MaxAutoRetriesNextServer`  
    更换实例的次数
 *  `MaxAutoRetries`  
    当前实例重试次数，尝试失败会更换下一个实例

### 2.2.3 主程序设置 RestTemplate 的请求工厂的超时属性 ###

package cn.tedu.sp06;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.http.client.SimpleClientHttpRequestFactory;
    import org.springframework.web.client.RestTemplate;
    
    @EnableDiscoveryClient
    @SpringBootApplication
    public class Sp06RibbonApplication { 
    
    	@LoadBalanced
    	@Bean
    	public RestTemplate getRestTemplate() { 
    		SimpleClientHttpRequestFactory f = new SimpleClientHttpRequestFactory();
    		f.setConnectTimeout(1000);
    		f.setReadTimeout(1000);
    		return new RestTemplate(f);
    		
    		//RestTemplate 中默认的 Factory 实例中，两个超时属性默认是 -1，
    		//未启用超时，也不会触发重试
    		//return new RestTemplate();
    	}
    
    	public static void main(String[] args) { 
    		SpringApplication.run(Sp06RibbonApplication.class, args);
    	}
    
    }

### 2.2.4 修改item-service 的 ItemController 添加延迟代码，测试 ribbon 的重试机制 ###

package cn.tedu.sp02.item.controller;
    
    import java.util.List;
    import java.util.Random;
    
    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.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.service.ItemService;
    import cn.tedu.web.util.JsonResult;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @RestController
    public class ItemController { 
    	@Autowired
    	private ItemService itemService;
    	
    	@Value("${server.port}")
    	private int port;
    	
    	@GetMapping("/{orderId}")
    	public JsonResult<List<Item>> getItems(@PathVariable String orderId) throws Exception { 
    		log.info("server.port="+port+", orderId="+orderId);
    
            ///--设置随机延迟
    		if(Math.random()<0.6) {  
    			long t = new Random().nextInt(5000);
    			log.info("item-service-"+port+" - 暂停 "+t);
    			Thread.sleep(t);
    		}
    		///~~
    		
    		List<Item> items = itemService.getItems(orderId);
    		return JsonResult.ok(items).msg("port="+port);
    	}
    	
    	@PostMapping("/decreaseNumber")
    	public JsonResult decreaseNumber(@RequestBody List<Item> items) { 
    		itemService.decreaseNumbers(items);
    		return JsonResult.ok();
    	}
    }

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

### 2.2.5 访问，测试 ribbon 重试机制 ###

*  通过 ribbon 访问 item-service，当超时，ribbon 会重试请求集群中其他服务器  
    [http://localhost:3001/item-service/35][http_localhost_3001_item-service_35]  
    ![在这里插入图片描述][20200806223121507.png]  
    ![在这里插入图片描述][20200806223132148.png]
 *  ribbon的重试机制，在 feign 和 zuul 中进一步进行了封装，后续可以使用feign或zuul的重试机制  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 4]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230208/2d2ed41f4d9f47e4b05d0b4e9324937a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230208/d2ea64dad647471a8acb7b143ce959ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20230208/878596ea4e6b407fb1978249f3406d4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]: /images/20230208/b302896087b9433faa44d9c4d57b7363.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]: /images/20230208/c6ad561300ed4ed381883d434b352cd8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 2]: /images/20230208/8d68d3bcd4e84b1abcb458eb1361644e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 3]: /images/20230208/5c73a5560f234f39b82590a802d8874c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 4]: /images/20230208/8a21b5f727c7499bbb7420da6e8dc880.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20230208/9746c9a763af4cbd8ace2966d8494c83.png
[http_localhost_3001_item-service_35]: http://localhost:3001/item-service/35
[http_localhost_3001_user-service_7]: http://localhost:3001/user-service/7
[http_localhost_3001_user-service_7_score_score_100]: http://localhost:3001/user-service/7/score?score=100
[http_localhost_3001_order-service_123abc]: http://localhost:3001/order-service/123abc
[http_localhost_3001_order-service]: http://localhost:3001/order-service/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 5]: /images/20230208/4dd2f469cf7945d29e993f7bf5194f74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 6]: /images/20230208/482980a10ef2449bb86d83090c9a994b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 7]: /images/20230208/99f721432c2a454f93b605a35eea1865.png
[http_localhost_3001_item-service_34]: http://localhost:3001/item-service/34
[2020080622252334.png]: /images/20230208/6387660b40b946d08ad802923aba19c7.png
[2020080622253057.png]: /images/20230208/6cce22f4897442ab87d928f502479305.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 8]: /images/20230208/c840f7832fca4cf98a2bb2efe6f64fca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 9]: /images/20230208/53599fb232b544d2a674bd4ceb7bf656.png
[20200806223121507.png]: /images/20230208/0f8f9fd916a74352a7f0f889f0fd8a7a.png
[20200806223132148.png]: /images/20230208/af3010d1c54546f698c894dc9f3d3765.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20230208/b658849d0b3d472392c889e83b9ec1cb.png