SpringCloud H版系列1＜PaymentMain8001和OrderMain80＞

绝地灬酷狼 2022-09-09 01:57 32阅读 0赞

这里根据尚硅谷周阳老师的springcloud视频，整理的项目资料，持续更新中。

# 一、创建主maven项目springcloud2021 #

[代码下载][Link 1]

## 1 项目整体目录结构如下，持续更新中) ##

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

## 2 主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>com.atguigu.springcloud</groupId>
      <artifactId>springcloud2021</artifactId>
      <packaging>pom</packaging>
      <version>1.0-SNAPSHOT</version>
    
      <modules>
        <module>cloud-provider-payment8001</module>
        <module>cloud-consumer-order80</module>
        <module>cloud-api-commons</module>
        <module>cloud-eureka-server7001</module>
        <module>cloud-eureka-server7002</module>
        <module>cloud-provider-payment8002</module>
        <module>cloud-provider-payment8004</module>
        <module>cloud-consumerzk-order80</module>
        <module>cloud-providerconsul-payment8006</module>
        <module>cloud-providerconsul-payment8006</module>
        <module>cloud-providerconsul-payment8006</module>
        <module>cloud-consumerconsul-order80</module>
        <module>cloud-consumer-feign-order80</module>
        <module>cloud-provider-hystrix-payment8001</module>
        <module>cloud-consumer-feign-hystrix-order80</module>
        <module>cloud-consumer-hystrix-dashboard9001</module>
        <module>cloud-gateway-gateway9527</module>
        <module>cloud-config-center-3344</module>
        <module>cloud-config-client-3355</module>
          <module>cloud-config-client-3366</module>
          <module>cloud-stream-rabbitmq-provider8801</module>
      </modules>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mybatis.spring.boot.version>1.3.2</mybatis.spring.boot.version>
      </properties>
    
      
      <dependencyManagement>
        <dependencies>
          
          <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.2.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
          </dependency>
          
          <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR1</version>
            <type>pom</type>
            <scope>import</scope>
          </dependency>
          
          <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.1.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
          </dependency>
          <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
          </dependency>
          <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
          </dependency>
          <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.spring.boot.version}</version>
          </dependency>
          <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
          </dependency>
          <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
          </dependency>
          <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
          </dependency>
        </dependencies>
      </dependencyManagement>
    
      <build>
        <plugins>
          <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
              <fork>true</fork>
              <addResources>true</addResources>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </project>

## 3 创建数据库和表 ##

用MySQL数据库名为test，表payment

CREATE DATABASE /*!32312 IF NOT EXISTS*/`test` /*!40100 DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci */;
    
    USE `test`;
    
    /*Table structure for table `payment` */
    
    DROP TABLE IF EXISTS `payment`;
    
    CREATE TABLE `payment` (
      `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
      `serial` varchar(200) COLLATE utf8_unicode_ci DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
    
    /*Data for the table `payment` */
    
    insert  into `payment`(`id`,`serial`) values (1,'007'),(2,'008'),(3,'009'),(4,'101');

# 二、支付微服务8001 #

新建PaymentMain8001模块

## 2.1 resource目录下新建 application.yml，配置pom.xml ##

server:
      port: 8001
    
    spring:
      application:
        name: cloud-payment-service
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: org.gjt.mm.mysql.Driver
        url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
        username: root
        password: 1234
    
    #将支付服务8001微服务发布到2台Eureka集群配置中
    eureka:
      client:
        register-with-eureka: true   #是否将自己注册到注册中心,集群必须设置为true配合ribbon
        fetch-registry: true    #是否从服务端抓取已有的注册信息
        service-url:
          defaultZone: http://localhost:7001/eureka
          #defaultZone: http://localhost:7001/eureka,http://localhost:7002/eureka #集群版
      instance:  #instance必须与client对齐
        instance-id: payment8001  #配置服务名
        prefer-ip-address: true  #访问路径可以显示IP
        lease-renewal-interval-in-seconds: 1  #向服务端发送心跳的时间间隔，单位为秒（默认是30秒），设置目的是加快频率
        lease-expiration-duration-in-seconds: 2 #收到最后一次心跳后等待时间上限，单位为秒（默认是90秒），超时将剔除
    
    mybatis:
      mapper-locations: classpath:mapper/*.xml
      type-aliases-package: com.atguigu.springcloud.entities  #所有Entity别名类所在包

pom.xml

## 2.2 新建启动类PaymentMain8001 ##

package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    @SpringBootApplication
    @EnableEurekaClient
    @EnableDiscoveryClient
    public class PaymentMain8001 { 
        /*Eureka自我保护机制 *某时刻某一个微服务不可用，Eureka不会立即清理，依旧会对该微服务进行保存 * 属于AP理论 * */
        public static void main(String[] args) { 
            SpringApplication.run(PaymentMain8001.class,args);
        }
    }

## 2.3 Controller层PaymentController ##

package com.atguigu.springcloud.controller;
    
    import com.atguigu.springcloud.entities.CommonResult;
    import com.atguigu.springcloud.entities.Payment;
    import com.atguigu.springcloud.service.PaymentService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.client.discovery.DiscoveryClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RestController;
    import javax.annotation.Resource;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Value;
    import java.util.List;
    
    @RestController
    @Slf4j
    public class PaymentController { 
        @Resource
        private PaymentService paymentService;
        @Value("${server.port}")
        private String serverPort;
        @Autowired
        private DiscoveryClient discoveryClient;
    
        @PostMapping(value="/payment/create")
        public CommonResult create(Payment payment){ 
            int result = paymentService.create(payment);
            log.info("插入结果:" + result);
            if (result > 0) { 
                return new CommonResult(200, "插入成功,serverPort: " + serverPort, result);
            } else { 
                return new CommonResult(444, "插入失败", null);
            }
        }
    
        @GetMapping(value="/payment/get/{id}")
        public CommonResult getPaymentById(@PathVariable("id") Long id){ 
             Payment paymentById =  paymentService.getPaymentById(id);
            log.info("查询结果:" + paymentById);
            if (paymentById != null) { 
                return new CommonResult(200, "查询成功,serverPort: "+ serverPort, paymentById);
            } else { 
                return new CommonResult(444, "没有对应记录，查询id:" + id, null);
            }
        }
    
        @GetMapping(value="/payment/discovery")
        public Object discovery(){ 
            List<String> services = discoveryClient.getServices();//获取服务列表清单
            for (String element: services ) { 
                log.info("****element: " +element);
            }
            //根据微服务名称“CLOUD-PAYMENT-SERVICE”获取微服务信息
            List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
            for (ServiceInstance instance:instances) { 
                log.info(instance.getServiceId()+"\t"+instance.getHost()+"\t"+instance.getPort()+"\t"+instance.getUri());
            }
            return this.discoveryClient;
        }
    
        @GetMapping("/payment/lb")
        public String getPaymentLB(){ 
            return serverPort;
        }
    
        //feign 超时测试
        @GetMapping("/payment/feign/timeout")
        public String paymentFeignTimeOut(){ 
            return serverPort;
        }
    }

## 2.4 Dao层 PaymentDao ##

package com.atguigu.springcloud.dao;
    
    import com.atguigu.springcloud.entities.Payment;
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    
    @Mapper
    public interface PaymentDao { 
        public int create(Payment payment);//写操作
    
        public Payment getPaymentById(@Param("id") Long id);//读操作
    
    }

## 2.5 resource目录下，新建PaymentMapper.xml ##

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.atguigu.springcloud.dao.PaymentDao">
        
       <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id" >
           insert into payment(serial) values(#{serial});
       </insert>
        
        <resultMap id="BaseResultMap" type="com.atguigu.springcloud.entities.Payment">
            <id column="id" property="id" jdbcType="BIGINT"></id>
            <id column="serial" property="serial" jdbcType="VARCHAR"></id>
        </resultMap>
    
        <select id="getPaymentById" parameterType="long" resultMap="BaseResultMap">
            select * from payment where  id = #{id};
        </select>
    </mapper>

在mybatis的配置文件中，有个叫keyProperty和useGeneratedKeys的属性。useGeneratedKeys 参数只针对 insert 语句生效，默认为 false。当设置为 true 时，表示如果插入的表以自增列为主键，则允许 JDBC 支持自动生成主键，并可将自动生成的主键返回。

具体用法：useGeneratedKeys=”true” keyProperty=”对应的主键的对象”。

## 2.6 Service层 接口PaymentService，实现类PaymentServiceImpl ##

PaymentService

package com.atguigu.springcloud.service;
    
    import com.atguigu.springcloud.entities.Payment;
    import org.apache.ibatis.annotations.Param;
    
    public interface PaymentService { 
        public int create(Payment payment);//写操作
    
        public Payment getPaymentById(@Param("id") Long id);//读操作
    }

PaymentServiceImpl

package com.atguigu.springcloud.service.impl;
    
    import com.atguigu.springcloud.dao.PaymentDao;
    import com.atguigu.springcloud.entities.Payment;
    import com.atguigu.springcloud.service.PaymentService;
    import org.springframework.stereotype.Service;
    import javax.annotation.Resource;
    
    @Service
    public class PaymentServiceImpl implements PaymentService { 
        // @Resource属于Java原生注解，而@Autowired属于Spring注解
        @Resource
        private PaymentDao paymentDao;
    
        @Override
        public int create(Payment payment) { 
            return paymentDao.create(payment);
        }
    
        @Override
        public Payment getPaymentById(Long id) { 
            return paymentDao.getPaymentById(id);
        }
    }

## 2.7 测试 ##

启动PaymentMain8001  
利用postman，执行查询操作http://localhost:8001/payment/get/2  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16]  
执行插入操作，结果如下  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 1]

# 三、订单微服务80 #

新建cloud-consumer-order80项目

## 3.1 resource目录下新建 application.yml，配置pom.xml ##

application.yml

server:
      port: 80
    
    spring:
      application:
        name: cloud-order-service
    
    #将订单服务80微服务发布到2台Eureka集群配置中
    eureka:
      client:
        register-with-eureka: true   #是否将自己注册到注册中心,集群必须设置为true配合ribbon
        fetch-registry: true    #是否从服务端抓取已有的注册信息
        service-url:
          defaultZone: http://localhost:7001/eureka  单机版
          #defaultZone: http://localhost:7001/eureka,http://localhost:7002/eureka #集群版

pom.xml

## 3.2 Controller层OrderController ##

package com.atguigu.springcloud.controller;
    
    import com.atguigu.springcloud.entities.CommonResult;
    import com.atguigu.springcloud.entities.Payment;
    import com.atguigu.springcloud.lb.LoadBalance;
    import com.atguigu.springcloud.lb.MyLB;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.client.discovery.DiscoveryClient;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    import javax.annotation.Resource;
    import java.net.URI;
    import java.util.List;
    
    @RestController
    @Slf4j
    public class OrderController { 
    
        @Autowired
        private LoadBalance loadBalance;
    
        @Autowired
        private DiscoveryClient discoveryClient;
        //public static final String PAYMENT_URL = "http://localhost:8001";
        public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";//负载均衡
    
        @Resource
        private RestTemplate restTemplate;
        //使用方式(url,requestMap,responseBean.class)三个参数分别代表rest请求地址、请求参数、http响应转换成的对象类型
        //RestTemplate提供了多种便捷访问远程Http服务的方法，
        //是一种简单便捷的访问restful服务的模板类，是spring提供的用于访问Rest服务的客户端模板工具集。
    
        //getForObject返回响应体重数据转化成的对象，即json
        //getForEntity返回对象是ResponseEntity对象，包含了响应中的一些重要信息，比如响应头、响应状态码、响应体等
    
        @GetMapping("/consumer/payment/create")
        public CommonResult<Payment> create(Payment payment){ 
            return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);
            //return restTemplate.postForEntity(PAYMENT_URL+"/payment/create",payment,CommonResult.class).getBody();
        }
    
        @GetMapping("/consumer/payment/get/{id}")
        public CommonResult<Payment> getPayment(@PathVariable("id") Long id){ 
            return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
        }
    
        @GetMapping("/consumer/payment/getForEntity/{id}")
        public CommonResult<Payment> getPayment2(@PathVariable("id") Long id){ 
            ResponseEntity<CommonResult> entity = restTemplate.getForEntity(PAYMENT_URL+"/payment/get"+id,CommonResult.class);
            if (entity.getStatusCode().is2xxSuccessful()){ //http请求编码2xx比如200
                return entity.getBody();
            }else{ 
                return new CommonResult<Payment>(444,"操作失败！");
            }
        }
    
        @GetMapping("/consumer/payment/lb")
        public String getPaymentLB(){ 
            List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
            if (instances == null || instances.size() <= 0) { 
                return null;
            }
            ServiceInstance serviceInstance = loadBalance.instance(instances);
            URI uri = serviceInstance.getUri();
    
            return restTemplate.getForObject(uri + "/payment/lb", String.class);
        }
    }

## 3.3 config层ApplicationContext ##

package com.atguigu.springcloud.config;
    
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.client.RestTemplate;
    
    @Configuration
    public class ApplicationContext { 
        //@Bean 代替了xml方式配置注入Spring
        @Bean
        //@LoadBalanced 手写负载均衡算法，则注释掉
        //开启负载均衡注解，轮询查询8001和8002的EurekaClient
        public RestTemplate getRestTemplate(){ 
            //RestTemplate提供了多种便捷访问远程http服务的方法
            //是一种简单便捷访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具类
            return new RestTemplate();
        }
    }

## 3.4 负载均衡以及手写负载均衡算法 ##

LoadBalance

package com.atguigu.springcloud.lb;
    
    import org.springframework.cloud.client.ServiceInstance;
    import java.util.List;
    
    public interface LoadBalance { 
        //手写负载均衡算法接口
        ServiceInstance instance(List<ServiceInstance> serviceInstances);//把当前服务器实例存入List
    }

MyLB

package com.atguigu.springcloud.lb;
    
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.stereotype.Component;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicInteger;
    
    //手写负载均衡算法
    @Component
    public class MyLB implements LoadBalance { 
        private AtomicInteger atomicInteger = new AtomicInteger(0);
        public final int getAndIncrement(){ 
            int current;
            int next;
            do{ 
                current = this.atomicInteger.get();
                next = current >= Integer.MAX_VALUE ? 0 : current+1;//当next下标大于MAX_VALUE时，清零，重写累加
            }while (!this.atomicInteger.compareAndSet(current,next));//如果当前值和预期值一致，则this.atomicInteger.compareAndSet(current,next)为true
                                                                        // !true则为false，跳出do while循环，打印出信息
            System.out.println("**********第几次访问，次数next："+next);
            return next;
        }
    
        //ribbon负载均衡算法原理：rest接口第几次请求数 % 服务器集群总数 = 实际调用服务器位置下标
        //每次重启后，rest接口计数从1开始
        @Override
        public ServiceInstance instance(List<ServiceInstance> serviceInstances) { 
            int index = getAndIncrement()%serviceInstances.size();
            return serviceInstances.get(index);
        }
    }

自定义负载均衡策略MySelfRule

package com.atguigu.myrule;
    
    import com.netflix.loadbalancer.IRule;
    import com.netflix.loadbalancer.RandomRule;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class MySelfRule { 
        //ribbon默认负载均衡策略是：轮询，这里自定义修改，设置为另一个负载均衡策略：随机
        //通过多次访问http:80//localhost/consumer/payment/get/1，发现随机落在8001和8002服务器
        @Bean
        public IRule myRule(){ 
           return new RandomRule();//定义为随机
        }
    }

测试(http类型默认端口80，可以省略)  
先启动7001，再启动8001，最后启动80  
访问http://localhost:7001/可以看到eurake已经注册了8001和80  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
http://localhost/consumer/payment/get/1  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
http://localhost:80/consumer/payment/create?serial=helloworld  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 4]

## 3.5 配置rundashbroad ##

运用spring cloud框架基于spring boot构建微服务，一般需要启动多个应用程序，在idea开发工具中，多个同时启动的应用

需要在RunDashboard运行仪表盘中可以更好的管理，但有时候idea中的RunDashboard窗口没有显示出来，也找不到直接的开启按钮

idea中打开Run Dashboard的方法如下

view > Tool Windows > Run Dashboard

如果上述列表找不到Run Dashboard,则可以在工程目录下找到.idea文件夹下的workspace.xml，在其中相应位置加入以下代码（替换）即可：

# 四、工程重构 #

将消费者和服者者的entities拷贝至新模块中，删除原来的entities包，clean、install cloud-api-commons 模块，在消费者、服务者pom.xml中分别引入依赖，测试运行。

## 4.1 新建模块 cloud-api-commons ##

pom.xml

实体类  
Payment

package com.atguigu.springcloud.entities;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import java.io.Serializable;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Payment implements Serializable { 
        private Long id;
        private String serial;
    }

CommonResult

package com.atguigu.springcloud.entities;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class CommonResult<T> { 
        private Integer code;
        private String message;
        private T data;
    
        public CommonResult(Integer code, String message) { 
            this(code, message, null);
        }
    }

[Link 1]: https://gitee.com/jike11231/spring-cloud2021.git
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_15_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/1305dfcdca8045f1ac2cb8db261cb772.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/3faded58b16e41cf8c76de26fc45be02.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/e5397b6ab0204aa2a013e66f0b30e3d4.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/f7848b6883914694a4964143dbd26298.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220829/08c7f35f1cb243ea837db26c33a12792.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220829/f8d76e30828f427a8725a3f4d6e99226.png