disruptor笔记之六：常见场景

淩亂°似流年 2022-10-18 01:56 124阅读 0赞

### 欢迎访问我的GitHub ###

> 这里分类和汇总了欣宸的全部原创(含配套源码)：[https://github.com/zq2599/blog\_demos][https_github.com_zq2599_blog_demos]

### 《disruptor笔记》系列链接 ###

1.  [快速入门][Link 1]
2.  [Disruptor类分析][Disruptor]
3.  [环形队列的基础操作(不用Disruptor类)][Disruptor 1]
4.  [事件消费知识点小结][Link 2]
5.  [事件消费实战][Link 3]
6.  [常见场景][Link 4]
7.  [等待策略][Link 5]
8.  [知识点补充(终篇)][Link 6]

### 本篇概览 ###

*  本文是《disruptor笔记》系列的第六篇，主要内容是将一些常用的消费模式做汇总，后续日常开发中如果有需要就能拿来即用；
 *  以下是常用的模式：

1.  多个消费者独立消费，[前文][Link 7]已实现，本篇跳过
2.  多个消费者共同消费，[前文][Link 7]已实现，本篇跳过
3.  既有独立消费，也有共同消费，[前文][Link 7]已实现，本篇跳过
4.  多个生产者和多个独立消费者：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]
5.  C1、C2独立消费，C3依赖C1和C2  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 1]
6.  C1独立消费，C2和C3也独立消费，但依赖C1，C4依赖C2和C3：  
    ![在这里插入图片描述][20210605103851389.png_pic_center]
7.  C1和C2独立消费，C3和C4也是独立消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4：  
    ![在这里插入图片描述][20210605104903983.png_pic_center]
8.  C1和C2**共同消费**，C3和C4也是**共同消费**，但C3和C4都依赖C1和C2，然后C5依赖C3和C4：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 2]
9.  C1和C2**共同消费**，C3和C4独立消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 3]
10. C1和C2独立消费，C3和C4是**共同消费**，但C3和C4都依赖C1和C2，然后C5依赖C3和C4：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 4]

### 关于本篇代码 ###

*  为了省事儿，本次不会新建工程，而是直接使用[前文][Link 7]的consume-mode模块，因此，下面这些类直接就直接使用了，无需重写代码：

1.  事件定义：OrderEvent
2.  事件工厂：OrderEventFactory
3.  事件生产者：OrderEventProducer
4.  用在独立消费场景的事件消费者：MailEventHandler
5.  用在共同消费场景的事件消费者：MailWorkHandler

### 源码下载 ###

*  本篇实战中的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog\_demos)：

<table> 
 <thead> 
  <tr> 
   <th align="left">名称</th> 
   <th align="left">链接</th> 
   <th align="left">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">项目主页</td> 
   <td align="left">https://github.com/zq2599/blog_demos</td> 
   <td align="left">该项目在GitHub上的主页</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(https)</td> 
   <td align="left">https://github.com/zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，https协议</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(ssh)</td> 
   <td align="left">git@github.com:zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，ssh协议</td> 
  </tr> 
 </tbody> 
</table>

*  这个git项目中有多个文件夹，本次实战的源码在disruptor-tutorials文件夹下，如下图红框所示：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 5]
 *  disruptor-tutorials是个父工程，里面有多个module，本篇实战的module是consume-mode，如下图红框所示：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 6]

### 多个生产者和多个独立消费者 ###

咱们即将实现下图的逻辑：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]

*  前面几篇文章所有实战的生产者都只有一个，到了本篇，为了让consume-mode模块的代码能够支持多生产者，咱们要对功能业务的抽象父类做以下两处改动：

1.  init方法原本为private型，现在为了能让子类重此方法，将其改为protected类型；
2.  增加名为publishWithProducer2的方法，可见内部只有抛出异常，要想其正常工作，需要子类自己来实现：

public void publishWithProducer2(String value) throws Exception { 
    	throw new Exception("父类未实现此方法，请在子类中重写此方法后再调用");
    }

*  为了实现多生产者功能，新增MultiProducerServiceImpl.java，有几处要注意的地方稍后会提到：

package com.bolingcavalry.service.impl;
    
    import com.bolingcavalry.service.*;
    import com.lmax.disruptor.BlockingWaitStrategy;
    import com.lmax.disruptor.dsl.Disruptor;
    import com.lmax.disruptor.dsl.ProducerType;
    import lombok.Setter;
    import org.springframework.scheduling.concurrent.CustomizableThreadFactory;
    import org.springframework.stereotype.Service;
    import javax.annotation.PostConstruct;
    
    @Service("multiProducerService")
    public class MultiProducerServiceImpl extends ConsumeModeService { 
    
        /** * 第二个生产者 */
        @Setter
        protected OrderEventProducer producer2;
    
        @PostConstruct
        @Override
        protected void init() { 
            // 实例化
            disruptor = new Disruptor<>(new OrderEventFactory(),
                    BUFFER_SIZE,
                    new CustomizableThreadFactory("event-handler-"),
                    // 生产类型是多生产者
                    ProducerType.MULTI,
                    // BlockingWaitStrategy是默认的等待策略
                    new BlockingWaitStrategy());
    
            // 留给子类实现具体的事件消费逻辑
            disruptorOperate();
    
            // 启动
            disruptor.start();
    
            // 第一个生产者
            setProducer(new OrderEventProducer(disruptor.getRingBuffer()));
    
            // 第二个生产者
            setProducer2(new OrderEventProducer(disruptor.getRingBuffer()));
        }
    
        @Override
        protected void disruptorOperate() { 
            // 一号消费者
            MailEventHandler c1 = new MailEventHandler(eventCountPrinter);
    
            // 二号消费者
            MailEventHandler c2 = new MailEventHandler(eventCountPrinter);
    
            // 调用handleEventsWithWorkerPool，表示创建的多个消费者以共同消费的模式消费
            disruptor.handleEventsWith(c1, c2);
        }
    
        @Override
        public void publishWithProducer2(String value) throws Exception { 
            producer2.onData(value);
        }
    }

*  上述代码有以下几处要注意：

1.  重写父类的init方法，主要是实例化Disruptor的时候，多传入两个参数：ProducerType.MULTI表示生产类型是多生产者，BlockingWaitStrategy是等待策略，之前的代码中咱们没有传此参数时，默认的就是BlockingWaitStrategy
2.  init方法中还执行了setProducer2方法，设置成员变量producer2
3.  重写publishWithProducer2方法，调用成员变量producer2发表事件
4.  重写disruptorOperate方法，里面设置了两个独立消费者

*  验证上述代码的方式依旧是单元测试，打开ConsumeModeServiceTest.java，新增以下代码，可见新增了两个线程同时执行发布事件的操作：

@Autowired
        @Qualifier("multiProducerService")
        ConsumeModeService multiProducerService;
    
    	@Test
        public void testMultiProducerService() throws InterruptedException { 
            log.info("start testMultiProducerService");
            CountDownLatch countDownLatch = new CountDownLatch(1);
    
            // 两个生产者，每个生产100个事件，一共生产两百个事件
            // 两个独立消费者，每人消费200个事件，因此一共消费400个事件
            int expectEventCount = EVENT_COUNT*4;
    
            // 告诉service，等消费到400个消息时，就执行countDownLatch.countDown方法
            multiProducerService.setCountDown(countDownLatch, expectEventCount);
    
            // 启动一个线程，用第一个生产者生产事件
            new Thread(() -> { 
                for(int i=0;i<EVENT_COUNT;i++) { 
                    log.info("publich {}", i);
                    multiProducerService.publish(String.valueOf(i));
                }
            }).start();
    
            // 再启动一个线程，用第二个生产者生产事件
            new Thread(() -> { 
                for(int i=0;i<EVENT_COUNT;i++) { 
                    log.info("publishWithProducer2 {}", i);
                    try { 
                        multiProducerService.publishWithProducer2(String.valueOf(i));
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                }
            }).start();
    
            // 当前线程开始等待，前面的service.setCountDown方法已经告诉过service，
            // 等消费到expectEventCount个消息时，就执行countDownLatch.countDown方法
            // 千万注意，要调用await方法，而不是wait方法！
            countDownLatch.await();
    
            // 消费的事件总数应该等于发布的事件数
            assertEquals(expectEventCount, multiProducerService.eventCount());
        }

*  测试结果如下，测试通过，符合预期：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 7]

### C1、C2独立消费，C3依赖C1和C2 ###

*  逻辑图如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 1]
 *  实现代码如下，非常简单，依赖关系用then即可实现：

package com.bolingcavalry.service.impl;
    
    import com.bolingcavalry.service.ConsumeModeService;
    import com.bolingcavalry.service.MailEventHandler;
    import com.bolingcavalry.service.MailWorkHandler;
    import com.bolingcavalry.service.SmsEventHandler;
    import org.springframework.stereotype.Service;
    
    @Service("scene5")
    public class Scene5 extends ConsumeModeService { 
    
        @Override
        protected void disruptorOperate() { 
            MailEventHandler c1 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c2 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c3 = new MailEventHandler(eventCountPrinter);
    
            disruptor
                    // C1、C2独立消费
                    .handleEventsWith(c1, c2)
                    // C3依赖C1和C2
                    .then(c3);
        }
    }

*  单元测试代码：

@Autowired
        @Qualifier("scene5")
        Scene5 scene5;
     
        @Test
        public void testScene5 () throws InterruptedException { 
            log.info("start testScene5");
            testConsumeModeService(scene5,
                    EVENT_COUNT,
                    // 三个独立消费者，一共消费300个事件
                    EVENT_COUNT * 3);
        }

*  为了节省篇幅，测试结果就不贴了，要注意的是，每个事件都一定是C1和C2先消费过，才会被C3消费到；

### C1独立消费，C2和C3也独立消费，但依赖C1，C4依赖C2和C3 ###

*  逻辑图如下：  
    ![在这里插入图片描述][20210605103851389.png_pic_center]
 *  实现代码如下：

package com.bolingcavalry.service.impl;
    
    import com.bolingcavalry.service.ConsumeModeService;
    import com.bolingcavalry.service.MailEventHandler;
    import org.springframework.stereotype.Service;
    
    @Service("scene6")
    public class Scene6 extends ConsumeModeService { 
    
        @Override
        protected void disruptorOperate() { 
            MailEventHandler c1 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c2 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c3 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c4 = new MailEventHandler(eventCountPrinter);
    
            disruptor
                    // C1
                    .handleEventsWith(c1)
                    // C2和C3也独立消费
                    .then(c2, c3)
                    // C4依赖C2和C3
                    .then(c4);
        }
    }

*  单元测试代码：

@Autowired
        @Qualifier("scene6")
        Scene6 scene6;
     
        @Test
        public void testScene6 () throws InterruptedException { 
            log.info("start testScene6");
            testConsumeModeService(scene6,
                    EVENT_COUNT,
                    // 四个独立消费者，一共消费400个事件
                    EVENT_COUNT * 4);
        }

### C1和C2独立消费，C3和C4也是独立消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4 ###

*  逻辑图如下：  
    ![在这里插入图片描述][20210605104903983.png_pic_center]
 *  实现代码如下：

package com.bolingcavalry.service.impl;
    
    import com.bolingcavalry.service.ConsumeModeService;
    import com.bolingcavalry.service.MailEventHandler;
    import org.springframework.stereotype.Service;
    
    @Service("scene7")
    public class Scene7 extends ConsumeModeService { 
    
        @Override
        protected void disruptorOperate() { 
            MailEventHandler c1 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c2 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c3 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c4 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c5 = new MailEventHandler(eventCountPrinter);
    
            disruptor
                    // C1和C2独立消费
                    .handleEventsWith(c1, c2)
                    // C3和C4也是独立消费，但C3和C4都依赖C1和C2
                    .then(c3, c4)
                    // 然后C5依赖C3和C4
                    .then(c5);
        }
    }

*  单元测试代码：

@Autowired
        @Qualifier("scene7")
        Scene7 scene7;
    
        @Test
        public void testScene7 () throws InterruptedException { 
            log.info("start testScene7");
            testConsumeModeService(scene7,
                    EVENT_COUNT,
                    // 五个独立消费者，一共消费500个事件
                    EVENT_COUNT * 5);
        }

### C1和C2**共同消费**，C3和C4也是**共同消费**，但C3和C4都依赖C1和C2，然后C5依赖C3和C4 ###

package com.bolingcavalry.service.impl;
    
    import com.bolingcavalry.service.ConsumeModeService;
    import com.bolingcavalry.service.MailEventHandler;
    import com.bolingcavalry.service.MailWorkHandler;
    import org.springframework.stereotype.Service;
    
    /** * @author will (zq2599@gmail.com) * @version 1.0 * @description: C1和C2共同消费，C3和C4也是共同消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4 * @date 2021/5/23 11:05 */
    @Service("scene8")
    public class Scene8 extends ConsumeModeService { 
    
        @Override
        protected void disruptorOperate() { 
            MailWorkHandler c1 = new MailWorkHandler(eventCountPrinter);
            MailWorkHandler c2 = new MailWorkHandler(eventCountPrinter);
            MailWorkHandler c3 = new MailWorkHandler(eventCountPrinter);
            MailWorkHandler c4 = new MailWorkHandler(eventCountPrinter);
            MailWorkHandler c5 = new MailWorkHandler(eventCountPrinter);
    
            disruptor
                    // C1和C2共同消费
                    .handleEventsWithWorkerPool(c1, c2)
                    // C3和C4也是独立消费，但C3和C4都依赖C1和C2
                    .thenHandleEventsWithWorkerPool(c3, c4)
                    // 然后C5依赖C3和C4
                    .thenHandleEventsWithWorkerPool(c5);
        }
    }

*  单元测试代码：

@Autowired
        @Qualifier("scene8")
        Scene8 scene8;
    
        @Test
        public void testScene8 () throws InterruptedException { 
            log.info("start testScene8");
            testConsumeModeService(scene8,
                    EVENT_COUNT,
                    // C1和C2共同消费，C3和C4共同消费，C5虽然只是一个，但也是共同消费模式,
                    // 也就是一共有三组消费者，所以一共消费300个事件
                    EVENT_COUNT * 3);
        }

### C1和C2**共同消费**，C3和C4独立消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4 ###

package com.bolingcavalry.service.impl;
    
    import com.bolingcavalry.service.ConsumeModeService;
    import com.bolingcavalry.service.MailEventHandler;
    import com.bolingcavalry.service.MailWorkHandler;
    import org.springframework.stereotype.Service;
    
    @Service("scene9")
    public class Scene9 extends ConsumeModeService { 
    
        @Override
        protected void disruptorOperate() { 
            MailWorkHandler c1 = new MailWorkHandler(eventCountPrinter);
            MailWorkHandler c2 = new MailWorkHandler(eventCountPrinter);
            MailEventHandler c3 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c4 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c5 = new MailEventHandler(eventCountPrinter);
    
            disruptor
                    // C1和C2共同消费
                    .handleEventsWithWorkerPool(c1, c2)
                    // C3和C4独立消费，但C3和C4都依赖C1和C2
                    .then(c3, c4)
                    // 然后C5依赖C3和C4
                    .then(c5);
        }
    }

*  单元测试代码：

@Autowired
        @Qualifier("scene9")
        Scene9 scene9;
    
        @Test
        public void testScene9 () throws InterruptedException { 
            log.info("start testScene9");
            testConsumeModeService(scene9,
                    EVENT_COUNT,
                    // C1和C2共同消费（100个事件），
                    // C3和C4独立消费（200个事件）,
                    // C5独立消费（100个事件）,
                    // 所以一共消费400个事件
                    EVENT_COUNT * 4);
        }

### C1和C2独立消费，C3和C4是**共同消费**，但C3和C4都依赖C1和C2，然后C5依赖C3和C4 ###

package com.bolingcavalry.service.impl;
    
    import com.bolingcavalry.service.ConsumeModeService;
    import com.bolingcavalry.service.MailEventHandler;
    import com.bolingcavalry.service.MailWorkHandler;
    import org.springframework.stereotype.Service;
    
    @Service("scene10")
    public class Scene10 extends ConsumeModeService { 
    
        @Override
        protected void disruptorOperate() { 
            MailEventHandler c1 = new MailEventHandler(eventCountPrinter);
            MailEventHandler c2 = new MailEventHandler(eventCountPrinter);
            MailWorkHandler c3 = new MailWorkHandler(eventCountPrinter);
            MailWorkHandler c4 = new MailWorkHandler(eventCountPrinter);
            MailEventHandler c5 = new MailEventHandler(eventCountPrinter);
    
            disruptor
                    // C1和C2共同消费
                    .handleEventsWith(c1, c2)
                    // C3和C4是共同消费，但C3和C4都依赖C1和C2
                    .thenHandleEventsWithWorkerPool(c3, c4)
                    // 然后C5依赖C3和C4
                    .then(c5);
        }
    }

*  单元测试代码：

@Test
        public void testScene10 () throws InterruptedException { 
            log.info("start testScene10");
            testConsumeModeService(scene10,
                    EVENT_COUNT,
                    // C1和C2独立消费（200个事件），
                    // C3和C4共同消费（100个事件）,
                    // C5独立消费（100个事件）,
                    // 所以一共消费400个事件
                    EVENT_COUNT * 4);
        }

*  至此，一些常见场景的代码已完成，希望本文能给您一些参考，帮您更得心应手的用好这个优秀的工具；

### 你不孤单，欣宸原创一路相伴 ###

1.  [Java系列][Java]
2.  [Spring系列][Spring]
3.  [Docker系列][Docker]
4.  [kubernetes系列][kubernetes]
5.  [数据库+中间件系列][Link 8]
6.  [DevOps系列][DevOps]

[https_github.com_zq2599_blog_demos]: https://github.com/zq2599/blog_demos
[Link 1]: https://blog.csdn.net/boling_cavalry/article/details/117185656
[Disruptor]: https://blog.csdn.net/boling_cavalry/article/details/117318462
[Disruptor 1]: https://blog.csdn.net/boling_cavalry/article/details/117386253
[Link 2]: https://blog.csdn.net/boling_cavalry/article/details/117395009
[Link 3]: https://blog.csdn.net/boling_cavalry/article/details/117405835
[Link 4]: https://blog.csdn.net/boling_cavalry/article/details/117575447
[Link 5]: https://blog.csdn.net/boling_cavalry/article/details/117608051
[Link 6]: https://blog.csdn.net/boling_cavalry/article/details/117636483
[Link 7]: https://xinchen.blog.csdn.net/article/details/117405835
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221014/98d62facf2934fe29a52f4aa2b3ea8ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221014/68b8f7ffc563427ba3a3f344858479ef.png
[20210605103851389.png_pic_center]: /images/20221014/1e8cf424576441d882c63bf2a82f2346.png
[20210605104903983.png_pic_center]: /images/20221014/c7103929037a410390bbe25b8483e03b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221014/7d57aad842d4410e8ed89b5e32b55dc8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221014/2d6551abf2f148a78687a07b9ea5c404.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221014/1f705d0347e04059a052cab45c949b0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221014/1c5856d1c9914123a6e5c51b47aed445.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221014/58869cfbfbbc4839ac0dfd0db72aba9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221014/c139da96d73046fb80dd13bb1b5f5ee5.png
[Java]: https://xinchen.blog.csdn.net/article/details/105068742
[Spring]: https://xinchen.blog.csdn.net/article/details/105086498
[Docker]: https://xinchen.blog.csdn.net/article/details/105086732
[kubernetes]: https://xinchen.blog.csdn.net/article/details/105086794
[Link 8]: https://xinchen.blog.csdn.net/article/details/105086850
[DevOps]: https://xinchen.blog.csdn.net/article/details/105086920