Java工程师的进阶之路

红太狼 2022-09-09 06:22 270阅读 0赞

### 目录 ###

*  知识点01：九大排序算法
 *  知识点02：二分查找算法
 *  知识点03：二叉树的遍历
 *  知识点04：Spring IOC
 *  知识点05：Spring AOP
 *  知识点06：Spring TX
 *  知识点07：Spring MVC
 *  知识点08：TCP三次握手
 *  知识点09：TCP四次挥手
 *  知识点10：单例设计模式

--------------------

# 知识点01：九大排序算法 #

public class Sort { 
        public static void main(String[] args) { 
            testTime();
            testSort();
        }
    
        public static void testTime() { 
            int[] arr = new int[10000];
            for (int i = 0; i < 10000; i++) { 
                arr[i] = (int) (Math.random() * 100 + 1);
            }
            long s = System.currentTimeMillis();
    // bubbleSort(arr);
    // selectionSort(arr);
    // insertionSort(arr);
    // shellSort(arr);
    // quickSort(arr, 0, arr.length - 1);
    // mergeSort(arr, 0, arr.length - 1, new int[arr.length]);
    // radixSort(arr);
    // countingSort(arr);
    // heapSort(arr);
            long e = System.currentTimeMillis();
            System.out.println((e - s) + "ms");
        }
    
        public static void testSort() { 
            int[] arr = new int[50];
            for (int i = 0; i < 50; i++) { 
                arr[i] = (int) (Math.random() * 100 + 1);
            }
    // bubbleSort(arr);
    // selectionSort(arr);
    // insertionSort(arr);
    // shellSort(arr);
    // quickSort(arr, 0, arr.length - 1);
    // mergeSort(arr, 0, arr.length - 1, new int[arr.length]);
    // radixSort(arr);
    // countingSort(arr);
    // heapSort(arr);
            System.out.println(Arrays.toString(arr));
        }
    
        //堆排序（大顶堆：升序算法，小顶堆：降序算法）
        public static void heapSort(int arr[]) { 
            //创建大顶堆
            for (int i = arr.length / 2 - 1; i >= 0; i--) { 
                heapAdjust(arr, i, arr.length);
            }
            //调整大顶堆
            for (int i = arr.length - 1; i > 0; i--) { 
                //交换元素
                int temp = arr[i];
                arr[i] = arr[0];
                arr[0] = temp;
                //调整新堆
                heapAdjust(arr, 0, i);
            }
        }
    
        //堆调整
        public static void heapAdjust(int arr[], int ci, int length) { 
            //缓存当前结点
            int temp = arr[ci];
            //开始循环调整
            for (int li = ci * 2 + 1; li < length; li = li * 2 + 1) { 
                //说明左子结点的值小于右子结点的值
                if (li + 1 < length && arr[li] < arr[li + 1]) { 
                    li = li + 1;
                }
                //说明当前子结点的值大于父结点的值
                if (arr[li] > temp) { 
                    arr[ci] = arr[li];
                    ci = li;
                } else { 
                    break;
                }
            }
            //放到调整位置
            arr[ci] = temp;
        }
    
        //计数排序：升序算法
        public static void countingSort(int[] arr) { 
            if (arr == null || arr.length == 0) return;
            int max = arr[0];
            int min = arr[0];
            for (int i = 1; i < arr.length; i++) { 
                if (arr[i] > max) max = arr[i];
                if (arr[i] < min) min = arr[i];
            }
            //统计次数
            int[] counts = new int[max - min + 1];
            for (int i = 0; i < arr.length; i++) { 
                counts[arr[i] - min]++;
            }
            //累加次数
            for (int i = 1; i < counts.length; i++) { 
                counts[i] += counts[i - 1];
            }
            //倒着重排
            int[] newArr = new int[arr.length];
            for (int i = arr.length - 1; i >= 0; i--) { 
                newArr[--counts[arr[i] - min]] = arr[i];
            }
            //复制数组
            for (int i = 0; i < arr.length; i++) { 
                arr[i] = newArr[i];
            }
        }
    
        //基数排序：升序算法
        public static void radixSort(int[] arr) { 
            if (arr == null || arr.length == 0) return;
            int max = arr[0];
            int min = arr[0];
            for (int i = 1; i < arr.length; i++) { 
                if (arr[i] > max) max = arr[i];
                if (arr[i] < min) min = arr[i];
            }
            for (int i = 0; i < arr.length; i++) { 
                arr[i] -= min;
            }
            int maxLength = String.valueOf(max - min).length();
            int[][] bucket = new int[10][arr.length];
            int[] bucketIndex = new int[10];
            for (int rounds = 0, base = 1; rounds < maxLength; rounds++, base *= 10) { 
                for (int i = 0; i < arr.length; i++) { 
                    int digit = arr[i] / base % 10;
                    bucket[digit][bucketIndex[digit]++] = arr[i];
                }
                int pos = 0;
                for (int i = 0; i < bucketIndex.length; i++) { 
                    for (int j = 0; j < bucketIndex[i]; j++) { 
                        arr[pos++] = bucket[i][j];
                    }
                    bucketIndex[i] = 0;
                }
            }
            for (int i = 0; i < arr.length; i++) { 
                arr[i] += min;
            }
        }
    
        //归并排序：升序算法
        public static void mergeSort(int[] arr, int L, int R, int[] temp) { 
            if (L >= R) return;
            int left = L, middle = (L + R) / 2, right = middle + 1, tIdx = L;
            mergeSort(arr, L, middle, temp);
            mergeSort(arr, right, R, temp);
            while (left <= middle && right <= R) { 
                if (arr[left] <= arr[right]) { 
                    temp[tIdx++] = arr[left++];
                } else { 
                    temp[tIdx++] = arr[right++];
                }
            }
            while (left <= middle) temp[tIdx++] = arr[left++];
            while (right <= R) temp[tIdx++] = arr[right++];
            for (int i = L; i <= R; i++) { 
                arr[i] = temp[i];
            }
        }
    
        //快速排序：升序算法
        public static void quickSort(int[] arr, int L, int R) { 
            if (L >= R) return;
            int left = L, right = R, pivot = arr[L];
            while (left < right) { 
                while (left < right && arr[right] >= pivot) right--;
                arr[left] = arr[right];
                while (left < right && arr[left] <= pivot) left++;
                arr[right] = arr[left];
            }
            arr[left] = pivot;
            quickSort(arr, L, left - 1);
            quickSort(arr, left + 1, R);
        }
    
        //希尔排序：升序算法
        public static void shellSort(int[] arr) { 
            for (int step = arr.length / 2; step > 0; step /= 2) { 
                for (int i = step; i < arr.length; i++) { 
                    int temp = arr[i];
                    int j = i - step;
                    while (j >= 0 && arr[j] > temp) { 
                        arr[j + step] = arr[j];
                        j -= step;
                    }
                    arr[j + step] = temp;
                }
            }
        }
    
        //插入排序：升序算法
        public static void insertionSort(int[] arr) { 
            for (int i = 1; i < arr.length; i++) { 
                int temp = arr[i];
                int j = i - 1;
                while (j >= 0 && arr[j] > temp) { 
                    arr[j + 1] = arr[j];
                    j -= 1;
                }
                arr[j + 1] = temp;
            }
        }
    
        //选择排序：升序算法
        public static void selectionSort(int[] arr) { 
            for (int i = 0; i < arr.length - 1; i++) { 
                int minIndex = i;
                for (int j = i + 1; j < arr.length; j++) { 
                    if (arr[minIndex] > arr[j]) { 
                        minIndex = j;
                    }
                }
                if (minIndex != i) { 
                    int temp = arr[minIndex];
                    arr[minIndex] = arr[i];
                    arr[i] = temp;
                }
            }
        }
    
        //冒泡排序：升序算法
        public static void bubbleSort(int[] arr) { 
            for (int i = 0; i < arr.length - 1; i++) { 
                for (int j = 0; j < arr.length - 1 - i; j++) { 
                    if (arr[j] > arr[j + 1]) { 
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

# 知识点02：二分查找算法 #

**递归版：**

public static int binarySearch(int[] arr, int target) { 
        return binarySearch(arr, 0, arr.length - 1, target);
    }
    
    private static int binarySearch(int[] arr, int left, int right, int target) { 
        if (left > right) return -1;
        int middle = (left + right) / 2;
        if (target < arr[middle]) { 
            return binarySearch(arr, left, middle - 1, target);
        } else if (target > arr[middle]) { 
            return binarySearch(arr, middle + 1, right, target);
        } else { 
            return middle;
        }
    }

**迭代版：**

public static int binarySearch(int[] arr, int target) { 
        return binarySearch(arr, 0, arr.length - 1, target);
    }
    
    private static int binarySearch(int[] arr, int left, int right, int target) { 
        while (left <= right) { 
            int middle = (left + right) / 2;
            if (target < arr[middle]) { 
                right = middle - 1;
            } else if (target > arr[middle]) { 
                left = middle + 1;
            } else { 
                return middle;
            }
        }
        return -1;
    }

# 知识点03：二叉树的遍历 #

**树结点：**

class TreeNode { 
        int data;
        TreeNode left;
        TreeNode right;
    
        public TreeNode() { }
    
        public TreeNode(int data) { 
            this.data = data;
        }
    }

**递归版：**

//中左右
    public static void preOrder(TreeNode root) { 
        if (root == null) return;
        System.out.print(root.data + " ");
        preOrder(root.left);
        preOrder(root.right);
    }
    
    //左中右
    public static void midOrder(TreeNode root) { 
        if (root == null) return;
        midOrder(root.left);
        System.out.print(root.data + " ");
        midOrder(root.right);
    }
    
    //左右中
    public static void postOrder(TreeNode root) { 
        if (root == null) return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.data + " ");
    }

**迭代版：**

//中左右 => 右左(中空)
    public static void preOrder(TreeNode root) { 
        if (root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) { 
            TreeNode node = stack.pop();
            if (node != null) { 
                if (node.right != null) stack.push(node.right);
                if (node.left != null) stack.push(node.left);
                stack.push(node);
                stack.push(null);
            } else { 
                node = stack.pop();
                System.out.print(node.data + " ");
            }
        }
    }
    
    //左中右 => 右(中空)左
    public static void midOrder(TreeNode root) { 
        if (root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) { 
            TreeNode node = stack.pop();
            if (node != null) { 
                if (node.right != null) stack.push(node.right);
                stack.push(node);
                stack.push(null);
                if (node.left != null) stack.push(node.left);
            } else { 
                node = stack.pop();
                System.out.print(node.data + " ");
            }
        }
    }
    
    //左右中 => (中空)右左
    public static void postOrder(TreeNode root) { 
        if (root == null) return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) { 
            TreeNode node = stack.pop();
            if (node != null) { 
                stack.push(node);
                stack.push(null);
                if (node.right != null) stack.push(node.right);
                if (node.left != null) stack.push(node.left);
            } else { 
                node = stack.pop();
                System.out.print(node.data + " ");
            }
        }
    }

**层序遍历：**

public static void layerOrder(TreeNode root) { 
        if (root == null) return;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) { 
            TreeNode node = queue.poll();
            System.out.print(node.data + " ");
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
    }

# 知识点04：Spring IOC #

**执行流程：**

![0f8977d1746f815ad731be0daebfca54.png][]

**生命周期：**

![0bcc2bdcd39ac9871bc3143132680926.png][]

**循环依赖：**

<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"><code>private final Map&lt;String, Object&gt; singletonObjects = new ConcurrentHashMap&lt;&gt;(256);</code></td> 
   <td align="left">成品对象</td> 
  </tr> 
  <tr> 
   <td align="left">二级缓存</td> 
   <td align="left"><code>private final Map&lt;String, Object&gt; earlySingletonObjects = new ConcurrentHashMap&lt;&gt;(16);</code></td> 
   <td align="left">半成品对象</td> 
  </tr> 
  <tr> 
   <td align="left">三级缓存</td> 
   <td align="left"><code>private final Map&lt;String, ObjectFactory&lt;?&gt;&gt; singletonFactories = new HashMap&lt;&gt;(16);</code></td> 
   <td align="left">lambda表达式</td> 
  </tr> 
 </tbody> 
</table>

**1、如果只有一级缓存能否解决循环依赖问题？**

如果只有一级缓存的话，那就意味着成品对象和半成品对象都要放到一级缓存中，在获取对象的时候，就有可能获取到半成品对象，而这个半成品对象是不能直接使用的，因此需要使用一级缓存存放成品对象，用二级缓存存放半成品对象。

**2、只有一级二级缓存能否解决循环依赖问题？**

只有一级二级缓存可以解决循环依赖问题，但是这个是有前提条件的，前提是不使用AOP，如果开启了AOP，那么Spring将会创建代理对象，如果存在代理对象循环依赖问题任然存在。

**3、那么问题又来了，为什么需要三级缓存呢？**

三级缓存是为了解决代理过程中的循环依赖问题。

**4、使用代码演示一下循环依赖执行整个流程？**

![8f6f2c3e03d3da00f42a2901b4c43493.png][]

public class ABTest { 
        public static void main(String[] args) { 
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("ab.xml");
            A a = applicationContext.getBean(A.class);
            System.out.println(a);
            B b = applicationContext.getBean(B.class);
            System.out.println(b);
        }
    }

![771213639b91e2c586b1fb9e963781a2.png][]

![21231c558548018d6c716db4ec121105.png][]

# 知识点05：Spring AOP #

**常用术语：**

*  连接点（Join Point）：代表类中有哪些方法可以被增强，这些可以被增强的方法称为连接点。
 *  切入点（Pointcut）：类中虽然有很多方法可以被增强，但是只有实际被增强的方法称为切入点。
 *  通知（Advice）：通知描述了增强逻辑代码在切入点处何时执行。
    
     *  前置通知，Before Advice
     *  后置通知，AfterReturning Advice
     *  异常通知，AfterThrowing Advice
     *  最终通知，After Advice
     *  环绕通知，Around Advice
 *  目标对象（Target Object）：被增强的对象称为目标对象，由于AOP框架是使用动态代理实现的，因此该对象始终是代理对象。
 *  织入（Weaving）：把通知应用到目标对象的切入点的过程就是织入。
 *  切面（Aspect）：切面是一系列通知和切入点的结合。

**代理过程：**

![d807d2d415c29e08d6ec3f20e064be41.png][]

**执行过程：**

![7c79f939c11720e2bc35f2e316c2e0e4.png][]

# 知识点06：Spring TX #

**事务特性：**

*  原子性（Atomicity）：强调事务的不可分割，要么全成功要么全失败。
 *  一致性（Consistency）：事务的执行的前后，数据的完整性保持一致。
 *  隔离性（Isolation）：一个事务的执行中，不该受到其他事务干扰。
 *  持久性（Durability）：一个事务一旦结束，数据就会持久到数据库。

**隔离级别：**

若不考虑事务的隔离性，可能会引发读安全性问题：

*  脏读：一个事务读到了另一个事务未提交的数据。
 *  不可重复读：一个事务读到了另一个事务已经提交的 update 的数据，导致多次查询结果不一致。
 *  幻读 / 虚读：一个事务读到了另一个事务已经提交的 insert 的数据，导致多次查询结果不一致。

要想解决读安全性问题，需要给事务设置隔离级别：

<table> 
 <thead> 
  <tr> 
   <th align="left">隔离级别</th> 
   <th align="left">说明</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">ISOLATION_READ_UNCOMMITTED</td> 
   <td align="left">读未提交</td> 
   <td align="left">不能解决以上所有读问题，效率最高，安全性最低，一般不用</td> 
  </tr> 
  <tr> 
   <td align="left">ISOLATION_READ_COMMITTED</td> 
   <td align="left">读已提交</td> 
   <td align="left">避免脏读，不可重复读和幻读有可能发生，Oracle默认的隔离级别</td> 
  </tr> 
  <tr> 
   <td align="left">ISOLATION_REPEATABLE_READ</td> 
   <td align="left">可重复读</td> 
   <td align="left">避免脏读、不可重复读，幻读有可能发生，MySQL默认的隔离级别</td> 
  </tr> 
  <tr> 
   <td align="left">ISOLATION_SERIALIZABLE</td> 
   <td align="left">串行化</td> 
   <td align="left">可以解决以上所有读问题，效率最差，安全性最高，一般不用</td> 
  </tr> 
 </tbody> 
</table>

**传播行为：**

<table> 
 <thead> 
  <tr> 
   <th align="left">传播行为</th> 
   <th align="left">当前不存在事务</th> 
   <th align="left">当前存在事务</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">PROPAGATION_REQUIRED</td> 
   <td align="left">新建事务</td> 
   <td align="left">使用当前事务</td> 
  </tr> 
  <tr> 
   <td align="left">PROPAGATION_SUPPORTS</td> 
   <td align="left">不使用事务</td> 
   <td align="left">使用当前事务</td> 
  </tr> 
  <tr> 
   <td align="left">PROPAGATION_MANDATORY</td> 
   <td align="left">抛出异常</td> 
   <td align="left">使用当前事务</td> 
  </tr> 
  <tr> 
   <td align="left">PROPAGATION_REQUIRES_NEW</td> 
   <td align="left">新建事务</td> 
   <td align="left">挂起当前事务，新建事务</td> 
  </tr> 
  <tr> 
   <td align="left">PROPAGATION_NOT_SUPPORTED</td> 
   <td align="left">不使用事务</td> 
   <td align="left">挂起当前事务</td> 
  </tr> 
  <tr> 
   <td align="left">PROPAGATION_NEVER</td> 
   <td align="left">不使用事务</td> 
   <td align="left">抛出异常</td> 
  </tr> 
  <tr> 
   <td align="left">PROPAGATION_NESTED</td> 
   <td align="left">新建事务</td> 
   <td align="left">嵌套事务</td> 
  </tr> 
 </tbody> 
</table>

> 参考：org.springframework.transaction.support.AbstractPlatformTransactionManager\#getTransaction
> 
> 参考：org.springframework.transaction.support.AbstractPlatformTransactionManager\#handleExistingTransaction

**执行过程：**

![466bf3818c20532fdbb6ed0553440c43.png][]

> 提交：org.springframework.transaction.support.AbstractPlatformTransactionManager\#commit
> 
> 回滚：org.springframework.transaction.support.AbstractPlatformTransactionManager\#rollback

![231be3805ee21a37f87f2276a739dd71.png][]

# 知识点07：Spring MVC #

**DispatcherServlet初始过程：**

![f7b40c302a27bb0910663dd4bb679235.png][]

**DispatcherServlet请求过程：**

![d183b7f99ba38575af4e32f44f1b4470.png][]

**DispatcherServlet执行流程：**

![520527914f435bd4637c6154f1151d19.png][]

# 知识点08：TCP三次握手 #

![b2f32966b3e49d5f48f17796bd69ba82.png][]

*  **第一次握手：** 起初两端都处于CLOSED关闭状态，Client将标志位SYN置为1，随机产生一个值seq=x，并将该数据包发送给Server，Client进入SYN-SENT状态，等待Server确认；
 *  **第二次握手：** Server收到数据包后由标志位SYN=1得知Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=x+1，随机产生一个值seq=y，并将该数据包发送给Client以确认连接请求，Server进入SYN-RCVD状态，此时操作系统为该TCP连接分配TCP缓存和变量；
 *  **第三次握手：** Client收到确认后，检查ack是否为x+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=y+1，并且此时操作系统为该TCP连接分配TCP缓存和变量，并将该数据包发送给Server，Server检查ack是否为y+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client和Server就可以开始传输数据。

# 知识点09：TCP四次挥手 #

![3180027ff40f1321f67a12308ac04176.png][]

*  **第一次挥手：** A的应用进程先向其TCP发出连接释放报文段（**FIN=1，序号seq=u**），并停止再发送数据，主动关闭TCP连接，进入FIN-WAIT-1（终止等待1）状态，等待B的确认。
 *  **第二次挥手：** B收到连接释放报文段后即发出确认报文段，（**ACK=1，序号seq=v，确认号ack=u+1**），B进入CLOSE-WAIT（关闭等待）状态，此时的TCP处于半关闭状态，A到B的连接释放。A收到B的确认后，进入FIN-WAIT-2（终止等待2）状态，等待B发出的连接释放报文段。
 *  **第三次挥手：** B没有要向A发出的数据，B发出连接释放报文段（**FIN=1，ACK=1，序号seq=w，确认号ack=u+1**），B进入LAST-ACK（最后确认）状态，等待A的确认。
 *  **第四次挥手：** A收到B的连接释放报文段后，对此发出确认报文段（**ACK=1，序号seq=u+1，确认号ack=w+1**），A进入TIME-WAIT（时间等待）状态。此时TCP未释放掉，需要经过时间等待计时器设置的时间2MSL后，A才进入CLOSED状态。

# 知识点10：单例设计模式 #

**饿汉式：**

class Singleton { 
        private Singleton() { }
    
        private final static Singleton instance = new Singleton();
    
        public static Singleton getInstance() { 
            return instance;
        }
    }
    
    public class SingletonTest { 
        public static void main(String[] args) { 
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
            System.out.println(instance1 == instance2);
        }
    }

**懒汉式：**

class Singleton { 
        private Singleton() { }
    
        private static Singleton instance;
    
        public static synchronized Singleton getInstance() { 
            if (instance == null) { 
                instance = new Singleton();
            }
            return instance;
        }
    }
    
    public class SingletonTest { 
        public static void main(String[] args) { 
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
            System.out.println(instance1 == instance2);
        }
    }

**双检锁：**

class Singleton { 
        private Singleton() { }
    
        private volatile static Singleton instance;
    
        public static Singleton getInstance() { 
            if (instance == null) { 
                synchronized (Singleton.class) { 
                    if (instance == null) { 
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
    
    public class SingletonTest { 
        public static void main(String[] args) { 
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
            System.out.println(instance1 == instance2);
        }
    }

[0f8977d1746f815ad731be0daebfca54.png]: /images/20220829/83e3c7557f964cba91ef7d3707a4de08.png
[0bcc2bdcd39ac9871bc3143132680926.png]: /images/20220829/b1d5d2f4a1c6482d868f3339571dfef5.png
[8f6f2c3e03d3da00f42a2901b4c43493.png]: /images/20220829/c8ad74804fb04305b5957cd3a94f3325.png
[771213639b91e2c586b1fb9e963781a2.png]: /images/20220829/7f2d02000fb3474491dc0dd757187b9a.png
[21231c558548018d6c716db4ec121105.png]: /images/20220829/fb2e4a1500094a42a00aa070df7fb6e5.png
[d807d2d415c29e08d6ec3f20e064be41.png]: /images/20220829/284cf34f7d7141b5a41d25cd0db2dea3.png
[7c79f939c11720e2bc35f2e316c2e0e4.png]: /images/20220829/64988e5668e44b069e52a9b115888d9d.png
[466bf3818c20532fdbb6ed0553440c43.png]: /images/20220829/11cea3ea13a247aa97c1eca26d8807a6.png
[231be3805ee21a37f87f2276a739dd71.png]: /images/20220829/aea27a36857143229c7ff5656d17b32d.png
[f7b40c302a27bb0910663dd4bb679235.png]: /images/20220829/061ff59a9aa74a5885852f888b32f1da.png
[d183b7f99ba38575af4e32f44f1b4470.png]: /images/20220829/f38d53c91fe948219f12b40aa98fb591.png
[520527914f435bd4637c6154f1151d19.png]: /images/20220829/8ecdc8ad756a48c2a1c4b7f6960435ff.png
[b2f32966b3e49d5f48f17796bd69ba82.png]: /images/20220829/d80b10fea4ef4c92948e20c3009a0fb0.png
[3180027ff40f1321f67a12308ac04176.png]: /images/20220829/d2c3afc0d69f42d482865fffb3e9310f.png