赵俊

nginx 禁止直接访问 http 端口

2025-05-07T20:45:00+08:00

对于家宽公网 ip 来说，没有标准的 80, 443 端口，为了安全考虑对外使用一个 nginx 作为出口，并配置 https 协议使用一个端口，不配置 http，这时直接访问 https://example.com:port 会提示：400 The plain HTTP request was sent to HTTPS port</code>。</p>

可我不想让用户看到这个提示来知道可以切换为 https 访问，解决办法为在 nginx 的 server</code> 代码块中配置：</p>

error_page 497 =444 @close;</span></span>
</span>
location @close {</span></span>
   return 444;</span></span>
}</span></span></code></pre>



修复 docker buildx 编译后，manifest 包含 unknown 的问题
2024-10-07T19:32:00+08:00
省流：自 buildx 0.10 版本开始，就可能会出现这个问题，解决版本是 docker buildx 时增加参数 --provenance=false</code>。</p>
问题复现</h2>
先来看示例，如有 Dockerfile</code>:</p>
FROM alpine</span></span>
RUN uname -a > /os.txt</span></span>
</span>
CMD cat /os.txt</span></span></code></pre>
通过以下命令构建 Multi-platform</code> 镜像:</p>
docker</span> buildx</span> create</span> -</span>-driver</span> docker-container</span> -</span>-use</span></span>
docker</span> buildx</span> build</span> -</span>-platform</span> linux/amd64,linux/arm64</span> -</span>-push</span> -</span>-tag</span> zhaojun1998/buildx-demo:latest</span> .</span></span></code></pre>
推送后，通过 docker manifest inspect zhaojun1998/buildx-demo:latest</code> 查看：</p>
{</span></span>
   "</span>schemaVersion</span>"</span>:</span> 2</span>,</span></span>
   "</span>mediaType</span>"</span>:</span> "</span>application/vnd.oci.image.index.v1+json</span>"</span>,</span></span>
   "</span>manifests</span>"</span>:</span> [</span></span>
      {</span></span>
         "</span>mediaType</span>"</span>:</span> "</span>application/vnd.oci.image.manifest.v1+json</span>"</span>,</span></span>
         "</span>size</span>"</span>:</span> 668</span>,</span></span>
         "</span>digest</span>"</span>:</span> "</span>sha256:5a0b3d0151d5505f6ab6bf2f6824b2d8fdcfcd0ae7cf9f2403606c6fccaf27f2</span>"</span>,</span></span>
         "</span>platform</span>"</span>:</span> {</span></span>
            "</span>architecture</span>"</span>:</span> "</span>amd64</span>"</span>,</span></span>
            "</span>os</span>"</span>:</span> "</span>linux</span>"</span></span>
         }</span></span>
      }</span>,</span></span>
      {</span></span>
         "</span>mediaType</span>"</span>:</span> "</span>application/vnd.oci.image.manifest.v1+json</span>"</span>,</span></span>
         "</span>size</span>"</span>:</span> 668</span>,</span></span>
         "</span>digest</span>"</span>:</span> "</span>sha256:38da41f844e3bfae577f8b768b53a4980838bba97c6952aaae4debf3ea66cee7</span>"</span>,</span></span>
         "</span>platform</span>"</span>:</span> {</span></span>
            "</span>architecture</span>"</span>:</span> "</span>arm64</span>"</span>,</span></span>
            "</span>os</span>"</span>:</span> "</span>linux</span>"</span></span>
         }</span></span>
      }</span>,</span></span>
      {</span></span>
         "</span>mediaType</span>"</span>:</span> "</span>application/vnd.oci.image.manifest.v1+json</span>"</span>,</span></span>
         "</span>size</span>"</span>:</span> 566</span>,</span></span>
         "</span>digest</span>"</span>:</span> "</span>sha256:6749a2e66b9e0e9cfc751e215e1036385c9cfd17e68bc8feca771381ce8ce806</span>"</span>,</span></span>
         "</span>platform</span>"</span>:</span> {</span></span>
            "</span>architecture</span>"</span>:</span> "</span>unknown</span>"</span>,</span></span>
            "</span>os</span>"</span>:</span> "</span>unknown</span>"</span></span>
         }</span></span>
      }</span>,</span></span>
      {</span></span>
         "</span>mediaType</span>"</span>:</span> "</span>application/vnd.oci.image.manifest.v1+json</span>"</span>,</span></span>
         "</span>size</span>"</span>:</span> 566</span>,</span></span>
         "</span>digest</span>"</span>:</span> "</span>sha256:f0b8829a483c98b1bc7fd0a8b16765fe5b29cca632a13db971c0c3749df09c3f</span>"</span>,</span></span>
         "</span>platform</span>"</span>:</span> {</span></span>
            "</span>architecture</span>"</span>:</span> "</span>unknown</span>"</span>,</span></span>
            "</span>os</span>"</span>:</span> "</span>unknown</span>"</span></span>
         }</span></span>
      }</span></span>
   ]</span></span>
}</span></span></code></pre>
这里面有几个问题：</p>

mediaType 版本为 application/vnd.oci.image.index.v1+json</code>，最新版本为 v2。</li>
下面有两个 platform.architecture</code> 与 platform.os</code> 为 unknown</code> 的数据项。</li>
</ol>
有些工具无法正常处理这种情况的镜像，如阿里的 image-syncer</a></p>
解决办法</h2>
构建命令中增加 --provenance=false</code>：</p>
docker</span> buildx</span> build</span> -</span>-provenance=false</span> -</span>-platform</span> linux/amd64,linux/arm64</span> -</span>-tag</span> zhaojun1998/buildx-demo:no-provenance</span> -</span>-push</span> .</span></span></code></pre>
然后再通过 docker manifest inspect zhaojun1998/buildx-demo:no-provenance</code> 查看：</p>
{</span></span>
   "</span>schemaVersion</span>"</span>:</span> 2</span>,</span></span>
   "</span>mediaType</span>"</span>:</span> "</span>application/vnd.docker.distribution.manifest.list.v2+json</span>"</span>,</span></span>
   "</span>manifests</span>"</span>:</span> [</span></span>
      {</span></span>
         "</span>mediaType</span>"</span>:</span> "</span>application/vnd.docker.distribution.manifest.v2+json</span>"</span>,</span></span>
         "</span>size</span>"</span>:</span> 696</span>,</span></span>
         "</span>digest</span>"</span>:</span> "</span>sha256:c2f325142a90e152e0ea9eca07f5de281e183028da40991d5354b08da913da62</span>"</span>,</span></span>
         "</span>platform</span>"</span>:</span> {</span></span>
            "</span>architecture</span>"</span>:</span> "</span>amd64</span>"</span>,</span></span>
            "</span>os</span>"</span>:</span> "</span>linux</span>"</span></span>
         }</span></span>
      }</span>,</span></span>
      {</span></span>
         "</span>mediaType</span>"</span>:</span> "</span>application/vnd.docker.distribution.manifest.v2+json</span>"</span>,</span></span>
         "</span>size</span>"</span>:</span> 696</span>,</span></span>
         "</span>digest</span>"</span>:</span> "</span>sha256:8211d0f98a9a8a6f4b87826a2cb78ae375e76c2e5d6fbaaee46709f9f422022d</span>"</span>,</span></span>
         "</span>platform</span>"</span>:</span> {</span></span>
            "</span>architecture</span>"</span>:</span> "</span>arm64</span>"</span>,</span></span>
            "</span>os</span>"</span>:</span> "</span>linux</span>"</span></span>
         }</span></span>
      }</span></span>
   ]</span></span>
}</span></span></code></pre>
现在可以发现，上面的两个问题已经解决了。</p>
已有镜像修复</h2>
上面的可以在新推送镜像时避免产生问题，但是对于已有镜像有时候不方便重新制作，可以通过以下办法修复已有镜像：</p>
去除 unknown 部分</h3>
可以用以下脚本 fix-image.sh</code> 来解决：</p>
#!/bin/bash</span></span>
</span>
set -v</span></span>
set -e</span></span>
</span>
# 检查是否提供了镜像地址</span></span>
if [ -z "$1" ]; then</span></span>
  echo "请提供镜像地址"</span></span>
  exit 1</span></span>
fi</span></span>
</span>
IMAGE=$1</span></span>
</span>
# 获取镜像的 manifest</span></span>
MANIFEST=$(docker manifest inspect $IMAGE)</span></span>
</span>
# 检查是否成功获取 manifest</span></span>
if [ $? -ne 0 ]; then</span></span>
  echo "获取 manifest 失败"</span></span>
  exit 1</span></span>
fi</span></span>
</span>
echo "获取到 manifest 为: $MANIFEST"</span></span>
</span>
# 解析 manifest，移除 architecture 或 os 为 unknown 的条目</span></span>
FILTERED_MANIFEST=$(echo $MANIFEST | jq 'del(.manifests[] | select(.platform.architecture == "unknown" or .platform.os == "unknown"))')</span></span>
</span>
echo "过滤后 manifest 为: $FILTERED_MANIFEST"</span></span>
</span>
# 检查是否有剩余的条目</span></span>
if [ $(echo $FILTERED_MANIFEST | jq '.manifests | length') -eq 0 ]; then</span></span>
  echo "过滤后没有剩余的条目，退出"</span></span>
  exit 1</span></span>
fi</span></span>
</span>
# 提取剩余条目的 digest</span></span>
DIGESTS=$(echo $FILTERED_MANIFEST | jq -r '.manifests[].digest')</span></span>
</span>
# 准备 docker manifest create 命令</span></span>
NEW_IMAGE="${IMAGE}"   # 这里可以自行决定修复后的镜像是否和原来的 tag 一样，如增加 -fix</span></span>
CREATE_CMD="docker manifest create $NEW_IMAGE"</span></span>
</span>
for DIGEST in $DIGESTS; do</span></span>
  CREATE_CMD="$CREATE_CMD --amend ${IMAGE%%:*}@$DIGEST"</span></span>
done</span></span>
</span>
# 执行 docker manifest create 命令</span></span>
eval $CREATE_CMD</span></span>
</span>
# 推送新的 manifest</span></span>
docker manifest push $NEW_IMAGE</span></span>
</span>
echo "新的 manifest 已创建并推送: $NEW_IMAGE"</span></span></code></pre>
使用办法为 ./fix-image.sh zhaojun1998/buildx-demo:latest</code>，可以看到修复后的 manifest 变为了：</p>
{</span></span>
  "</span>schemaVersion</span>"</span>:</span> 2</span>,</span></span>
  "</span>mediaType</span>"</span>:</span> "</span>application/vnd.oci.image.index.v1+json</span>"</span>,</span></span>
  "</span>manifests</span>"</span>:</span> [</span></span>
    {</span></span>
      "</span>mediaType</span>"</span>:</span> "</span>application/vnd.oci.image.manifest.v1+json</span>"</span>,</span></span>
      "</span>size</span>"</span>:</span> 668</span>,</span></span>
      "</span>digest</span>"</span>:</span> "</span>sha256:d756e0a11dd550bb5ea6affd46352119aee6f16981fa588667c54929efa95589</span>"</span>,</span></span>
      "</span>platform</span>"</span>:</span> {</span></span>
        "</span>architecture</span>"</span>:</span> "</span>amd64</span>"</span>,</span></span>
        "</span>os</span>"</span>:</span> "</span>linux</span>"</span></span>
      }</span></span>
    }</span>,</span></span>
    {</span></span>
      "</span>mediaType</span>"</span>:</span> "</span>application/vnd.oci.image.manifest.v1+json</span>"</span>,</span></span>
      "</span>size</span>"</span>:</span> 668</span>,</span></span>
      "</span>digest</span>"</span>:</span> "</span>sha256:ef6cd7110abcd9eb9c1c402e46c6de4de6138e5e0ef6f7b84b81a56d64b84212</span>"</span>,</span></span>
      "</span>platform</span>"</span>:</span> {</span></span>
        "</span>architecture</span>"</span>:</span> "</span>arm64</span>"</span>,</span></span>
        "</span>os</span>"</span>:</span> "</span>linux</span>"</span></span>
      }</span></span>
    }</span></span>
  ]</span></span>
}</span></span></code></pre>升级镜像规范版本</h2>
根据自己的系统架构安装 regctl</a>，然后执行命令：</p>
regctl</span> image</span> mod</span> zhaojun1998/buildx-demo:latest</span> -</span>-to-docker</span> -</span>-replace</span></span></code></pre>
再查看 manifest</code> 为：</p>
{</span></span>
   "</span>schemaVersion</span>"</span>:</span> 2</span>,</span></span>
   "</span>mediaType</span>"</span>:</span> "</span>application/vnd.docker.distribution.manifest.list.v2+json</span>"</span>,</span></span>
   "</span>manifests</span>"</span>:</span> [</span></span>
      {</span></span>
         "</span>mediaType</span>"</span>:</span> "</span>application/vnd.docker.distribution.manifest.v2+json</span>"</span>,</span></span>
         "</span>size</span>"</span>:</span> 587</span>,</span></span>
         "</span>digest</span>"</span>:</span> "</span>sha256:89d1d24005f61c825f1e07d819ce52c71c0c4ba96d7457d9b9f40dde59c31c78</span>"</span>,</span></span>
         "</span>platform</span>"</span>:</span> {</span></span>
            "</span>architecture</span>"</span>:</span> "</span>amd64</span>"</span>,</span></span>
            "</span>os</span>"</span>:</span> "</span>linux</span>"</span></span>
         }</span></span>
      }</span>,</span></span>
      {</span></span>
         "</span>mediaType</span>"</span>:</span> "</span>application/vnd.docker.distribution.manifest.v2+json</span>"</span>,</span></span>
         "</span>size</span>"</span>:</span> 587</span>,</span></span>
         "</span>digest</span>"</span>:</span> "</span>sha256:c1cd468c5476d0c33ca877a0dce7871d55550fdfbc00466f450f3bf63e5ea8ac</span>"</span>,</span></span>
         "</span>platform</span>"</span>:</span> {</span></span>
            "</span>architecture</span>"</span>:</span> "</span>arm64</span>"</span>,</span></span>
            "</span>os</span>"</span>:</span> "</span>linux</span>"</span></span>
         }</span></span>
      }</span></span>
   ]</span></span>
}</span></span></code></pre>参考</h2>

https://github.com/docker/buildx/issues/1507</li>
https://github.com/docker/buildx/issues/1509#issuecomment-1378454396</li>
https://github.com/docker/buildx/issues/1964#issuecomment-1644634461</li>
https://stackoverflow.com/questions/75692640/modify-docker-image-with-older-manifest-format</li>
</ul>


leetcode 3152. 特殊数组 II
2024-08-13T19:45:00+08:00
https://leetcode.cn/problems/special-array-ii/description/</p>
题目</h2>
如果数组的每一对相邻元素都是两个奇偶性不同的数字，则该数组被认为是一个 特殊数组</strong> 。</p>
你有一个整数数组 nums</code> 和一个二维整数矩阵 queries</code>，对于 queries[i] = [fromi, toi]</code>，请你帮助你检查子数组 nums[fromi..toi]</code> 是不是一个 特殊数组</strong> 。</p>
返回布尔数组 answer</code>，如果 $nums[from_i..to_i]$ 是特殊数组，则 answer[i]</code> 为 true</code> ，否则，answer[i]</code> 为 false</code> 。</p>
示例 1：</strong></p>
输入：</strong> nums = [3,4,1,2,6], queries = [[0,4]]
输出：</strong> [false]
解释：</strong>
子数组是 [3,4,1,2,6]</code>。2 和 6 都是偶数。</p>
示例 2：</strong></p>
输入：</strong> nums = [4,3,1,6], queries = [[0,2],[2,3]]
输出：</strong> [false,true]
解释：</strong></p>

子数组是 [4,3,1]</code>。3 和 1 都是奇数。因此这个查询的答案是 false</code>。</li>
子数组是 [1,6]</code>。只有一对：(1,6)</code>，且包含了奇偶性不同的数字。因此这个查询的答案是 true</code>。</li>
</ol>
思路</h2>
首先，如果一个区间是特殊数组，那它的任意子区间也一定是特殊数组。</p>
那么我们可以记录 nums</code> 中每个下标的最大特殊数组长度，如:</p>
[3,4,1,2,6,1,3] nums</span></span>
[1,2,3,4,1,2,1] dp</span></span></code></pre>
如 dp[5]</code> 为 2</code>，表示 dp[4 - 5]</code> 是特殊数组, 那么对于区间 [i, j]</code>，只要判断 dp[j]</code> 的值(以该下标为结尾的最长特殊数组长度)大于等于当前区间长度 j - i + 1</code> 就表示包含了该区间，就肯定是特殊数组。</p>
代码</h2>
class</span> Solution</span> {</span></span>
    public</span> boolean</span>[</span>]</span> isArraySpecial</span>(</span>int</span>[</span>]</span> nums</span>,</span> int</span>[</span>]</span>[</span>]</span> queries</span>)</span> {</span></span>
        int</span> n</span> =</span> nums</span>.</span>length</span>;</span></span>
        int</span>[</span>]</span> dp</span> =</span> new</span> int</span>[</span>n</span>]</span>;</span></span>
        Arrays</span>.</span>fill</span>(</span>dp</span>,</span> 1</span>)</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 1</span>;</span> i </span><</span> n</span>;</span> i</span>++</span>)</span> {</span></span>
            if</span> (</span>nums</span>[</span>i</span>]</span> %</span> 2</span> !=</span> nums</span>[</span>i </span>-</span> 1</span>]</span> %</span> 2</span>)</span> {</span></span>
                dp</span>[</span>i</span>]</span> =</span> dp</span>[</span>i </span>-</span> 1</span>]</span> +</span> 1</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        boolean</span>[</span>]</span> res</span> =</span> new</span> boolean</span>[</span>queries</span>.</span>length</span>]</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> queries</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
            int</span> x</span> =</span> queries</span>[</span>i</span>]</span>[</span>0</span>]</span>,</span> y </span>=</span> queries</span>[</span>i</span>]</span>[</span>1</span>]</span>;</span></span>
            res</span>[</span>i</span>]</span> =</span> dp</span>[</span>y</span>]</span> >=</span> y </span>-</span> x </span>+</span> 1</span>;</span></span>
        }</span></span>
</span>
        return</span> res</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


leetcode 3132. 找出与数组相加的整数 II
2024-08-09T19:45:00+08:00
https://leetcode.cn/problems/find-the-integer-added-to-array-ii/description/</p>
题目</h2>
给你两个整数数组 nums1</code> 和 nums2</code>。
从 nums1</code> 中移除两个元素，并且所有其他元素都与变量 x</code> 所表示的整数相加。如果 x</code> 为负数，则表现为元素值的减少。
执行上述操作后，nums1</code> 和 nums2</code> 相等</strong> 。当两个数组中包含相同的整数，并且这些整数出现的频次相同时，两个数组 相等</strong> 。
返回能够实现数组相等的 最小</strong> 整数 x</code> 。</p>
示例 1:</strong>
输入：</strong> nums1 = [4,20,16,12,8], nums2 = [14,18,10]</code>
输出：</strong> -2</code>
解释：</strong>
移除 nums1</code> 中下标为 [0,4]</code> 的两个元素，并且每个元素与 -2</code> 相加后，nums1</code> 变为 [18,14,10]</code> ，与 nums2</code> 相等。</p>
示例 2:</strong>
输入：</strong> nums1 = [3,5,5,3], nums2 = [7,7]</code>
输出：</strong> 2</code>
解释：</strong>
移除 nums1</code> 中下标为 [0,3]</code> 的两个元素，并且每个元素与 2</code> 相加后，nums1</code> 变为 [7,7]</code> ，与 nums2</code> 相等。</p>
提示：</strong></p>

3 <= nums1.length <= 200</code></li>
nums2.length == nums1.length - 2</code></li>
0 <= nums1[i], nums2[i] <= 1000</code></li>
测试用例以这样的方式生成：存在一个整数 x</code>，nums1</code> 中的每个元素都与 x</code> 相加后，再移除两个元素，nums1</code> 可以与 nums2</code> 相等。</li>
</ul>
思路</h2>
先将 $nums1$ 和 $nums2$ 升序排序，根据题意 $num1$ 中只有 2 个多余的值，其余的值依次(因为我们排过序了)和 $nums2$ 中的值差值一样。
既然只有 2 个多余值，那么 $nums1[0], num1[1], num1[2]$ 中肯定至少有一个是正确差值, 标记这个下标为 k(即 k 依次等于 0,1,2)，将 $nums1[k]$ 与 $nums2[0]$ 的差值假定为正确差值 $diff$，然后依次比较之后的元素，即从 $num1[k + 1], nums2[1]$ 开始比较差值如等于 $diff$ 则 $count + 1$, 直到遍历完整个数组，等于 $diff$ 的数量为 $nums2.length$，表示我们假定的差值是对的。</p>
具体逻辑为用双指针 $x = k + 1, y = 1$，$x$ 是 $nums1$ 的下标，$y$ 是 $nums2$ 的下标, $count$ 基础值为 1 (假定那个值是对的)：</p>

如果 $nums1[x] - num2[y] == diff$，则 count + 1，然后将 x, y 都向后移动一位继续比较。</li>
如果 $nums2[x] - num2[y] != diff$，这时可能 x 是多余的值，只将 x 向后移动一位继续比较。</li>
直到 x 达到 nums1 的末尾或 y 到了 nums2 的末尾，判断 count 是否 nums2 的长度，是的话返回假定的正确差值 diff 即可。</li>
</ul>


这里面有一些细节可以优化：</p>

我们 count 初始值是 1，y 初始值也是 1，都是差值等于 diff 时才 +1，那我们就不用声明 count 了，直接用 y 即可。</li>
如果 x 和 y 的距离大于了 2，那就说明碰到了不止 2 个多余的值，这说明我们假定的 diff 是错的，可以直接停止循环，用下个假定的 diff 继续找。</li>
</ul>

还有一个要注意的是，我们要先将 k = 2，再 = 1，再 = 0，因为题意要找的是最小的差值，而我们是按升序排序的，靠后的下标值越大，相较与 nums1 的差值也就越小。如 nums1 = [3,3,5,5], num2 = [7,7] 这种情况，如果我们 k 从 0 开始的话，找到的结果就是 4，其实答案应该是 2。</p>
</blockquote>
代码</h2>
class</span> Solution</span> {</span></span>
    public</span> int</span> minimumAddedInteger</span>(</span>int</span>[</span>]</span> nums1</span>,</span> int</span>[</span>]</span> nums2</span>)</span> {</span></span>
        Arrays</span>.</span>sort</span>(</span>nums1</span>)</span>;</span></span>
        Arrays</span>.</span>sort</span>(</span>nums2</span>)</span>;</span></span>
</span>
        int</span> m</span> =</span> nums1</span>.</span>length</span>;</span></span>
        int</span> n</span> =</span> nums2</span>.</span>length</span>;</span></span>
</span>
        for</span> (</span>int</span> k</span> =</span> 2</span>;</span> k </span>>=</span> 0</span>;</span> k</span>--</span>)</span> {</span></span>
            int</span> diff</span> =</span> nums2</span>[</span>0</span>]</span> -</span> nums1</span>[</span>k</span>]</span>;</span></span>
            int</span> x</span> =</span> k </span>+</span> 1</span>,</span> y </span>=</span> 1</span>;</span></span>
            while</span>(</span>x </span><</span> m </span>&&</span> y </span><</span> n </span>&&</span> x </span>-</span> y </span><=</span> 2</span>)</span> {</span></span>
                if</span> (</span>nums2</span>[</span>y</span>]</span> -</span> nums1</span>[</span>x</span>]</span> ==</span> diff</span>)</span> {</span></span>
                    y</span>++</span>;</span></span>
                }</span></span>
                x</span>++</span>;</span></span>
            }</span></span>
</span>
            if</span> (</span>y </span>==</span> n</span>)</span> {</span></span>
                return</span> diff</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> 0</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


代码命名之 Spring
2024-05-19T09:55:00+08:00
开发中对于业务功能开发一般我们命令都是 Controller</code>, Service</code>, ServiceImpl</code>, Mapper</code>, Repository</code> 之类的，但是对于一些特殊的功能我们需要自定义命名，这里我们参考下 Spring 源码中的命名规范。</p>
初始化 Initializer</h2>
Spring 中的初始化类一般都是以 Initializer</code> 结尾，如 ApplicationContextInitializer</code>, BeanFactoryPostProcessor</code>, BeanPostProcessor</code> 等。</p>
@</span>FunctionalInterface</span></span>
public</span> interface</span> ApplicationContextInitializer</span><</span>C</span> extends</span> ConfigurableApplicationContext</span>></span> {</span></span>
</span>
	/**</span></span>
	 * Initialize the given application context.</span></span>
	 * </span>@param</span> applicationContext</span> the application to configure</span></span>
	 */</span></span>
	void</span> initialize</span>(</span>C</span> applicationContext</span>)</span>;</span></span>
</span>
}</span></span></code></pre>管理器 Manager</h2>
Spring 中的管理器一般都是以 Manager</code> 结尾，如 TransactionManager</code>, CacheManager</code>, DataSourceTransactionManager</code> 等。</p>

管理器可以理解为对某一类资源的管理，如事务管理器，缓存管理器等。</p>
</blockquote>
public</span> interface</span> TransactionManager</span></span>
{</span></span>
    /**</span></span>
     *  Starts a new transaction, and associate it with the calling thread.</span></span>
     *</span></span>
     *  </span>@throws</span> NotSupportedException</span> If the calling thread is already</span></span>
     *          associated with a transaction, and nested transactions are</span></span>
     *          not supported.</span></span>
     *  </span>@throws</span> SystemException</span> If the transaction service fails in an</span></span>
     *          unexpected way.</span></span>
     */</span></span>
    public</span> void</span> begin</span>(</span>)</span> throws</span> NotSupportedException</span>,</span> SystemException</span>;</span></span>
</span>
    /**</span></span>
     *  Commit the transaction associated with the calling thread.</span></span>
     *</span></span>
     *  </span>@throws</span> RollbackException</span> If the transaction was marked for rollback</span></span>
     *          only, the transaction is rolled back and this exception is</span></span>
     *          thrown.</span></span>
     *  </span>@throws</span> IllegalStateException</span> If the calling thread is not associated</span></span>
     *          with a transaction.</span></span>
     *  </span>@throws</span> SystemException</span> If the transaction service fails in an</span></span>
     *          unexpected way.</span></span>
     *  </span>@throws</span> HeuristicMixedException</span> If a heuristic decision was made and</span></span>
     *          some some parts of the transaction have been committed while</span></span>
     *          other parts have been rolled back.</span></span>
     *  </span>@throws</span> HeuristicRollbackException</span> If a heuristic decision to roll</span></span>
     *          back the transaction was made.</span></span>
     *  </span>@throws</span> SecurityException</span> If the caller is not allowed to commit this</span></span>
     *          transaction.</span></span>
     */</span></span>
    public</span> void</span> commit</span>(</span>)</span> throws</span> RollbackException</span>,</span> HeuristicMixedException</span>,</span></span>
                   HeuristicRollbackException</span>,</span> SecurityException</span>,</span></span>
                   IllegalStateException</span>,</span> SystemException</span>;</span></span>
</span>
   //</span> ......省略其他方法</span></span>
}</span></span></code></pre>处理器</h2>
Spring 中对处理器有两种命令方式：</p>

一种是以 Handler</code> 结尾，如 HandlerInterceptor</code>, HandlerMethodArgumentResolver</code>, HandlerMethodReturnValueHandler</code> 等。</li>
另一种是以 Processor</code> 结尾，如 BeanPostProcessor</code>, BeanFactoryPostProcessor</code>, BeanDefinitionRegistryPostProcessor</code> 等。</li>
</ul>
这两种的区别我个人理解是：</p>

Handler</code> 用的比较多，一般是对特定类型或事件进行处理，多用于责任链模式中。</li>
Processor</code> 一般表示对特定阶段做处理，如预处理，后处理等。</li>
</ul>
Processor</h3>
Spring 中常见的 Processor</code> 有 BeanPostProcessor</code>, BeanFactoryPostProcessor</code>, BeanDefinitionRegistryPostProcessor</code> 等。</p>
如下面的 BeanPostProcessor</code> 接口用于提供在 Bean 初始化前后进行一些处理的能力。</p>
public</span> interface</span> BeanPostProcessor</span> {</span></span>
</span>
	/**</span></span>
	 * Apply this {@code BeanPostProcessor} to the given new bean instance <i>before</i> any bean</span></span>
	 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}</span></span>
	 * or a custom init-method). The bean will already be populated with property values.</span></span>
	 * The returned bean instance may be a wrapper around the original.</span></span>
	 * <p>The default implementation returns the given {@code bean} as-is.</span></span>
	 * </span>@param</span> bean</span> the new bean instance</span></span>
	 * </span>@param</span> beanName</span> the name of the bean</span></span>
	 * </span>@return</span> the bean instance to use, either the original or a wrapped one;</span></span>
	 * if {@code null}, no subsequent BeanPostProcessors will be invoked</span></span>
	 * </span>@throws</span> org.springframework.beans.BeansException</span> in case of errors</span></span>
	 * </span>@see</span> org.springframework.beans.factory.InitializingBean#afterPropertiesSet</span></span>
	 */</span></span>
	@</span>Nullable</span></span>
	default</span> Object</span> postProcessBeforeInitialization</span>(</span>Object</span> bean</span>,</span> String</span> beanName</span>)</span> throws</span> BeansException</span> {</span></span>
		return</span> bean</span>;</span></span>
	}</span></span>
</span>
	/**</span></span>
	 * Apply this {@code BeanPostProcessor} to the given new bean instance <i>after</i> any bean</span></span>
	 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}</span></span>
	 * or a custom init-method). The bean will already be populated with property values.</span></span>
	 * The returned bean instance may be a wrapper around the original.</span></span>
	 * <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean</span></span>
	 * instance and the objects created by the FactoryBean (as of Spring 2.0). The</span></span>
	 * post-processor can decide whether to apply to either the FactoryBean or created</span></span>
	 * objects or both through corresponding {@code bean instanceof FactoryBean} checks.</span></span>
	 * <p>This callback will also be invoked after a short-circuiting triggered by a</span></span>
	 * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,</span></span>
	 * in contrast to all other {@code BeanPostProcessor} callbacks.</span></span>
	 * <p>The default implementation returns the given {@code bean} as-is.</span></span>
	 * </span>@param</span> bean</span> the new bean instance</span></span>
	 * </span>@param</span> beanName</span> the name of the bean</span></span>
	 * </span>@return</span> the bean instance to use, either the original or a wrapped one;</span></span>
	 * if {@code null}, no subsequent BeanPostProcessors will be invoked</span></span>
	 * </span>@throws</span> org.springframework.beans.BeansException</span> in case of errors</span></span>
	 * </span>@see</span> org.springframework.beans.factory.InitializingBean#afterPropertiesSet</span></span>
	 * </span>@see</span> org.springframework.beans.factory.FactoryBean</span></span>
	 */</span></span>
	@</span>Nullable</span></span>
	default</span> Object</span> postProcessAfterInitialization</span>(</span>Object</span> bean</span>,</span> String</span> beanName</span>)</span> throws</span> BeansException</span> {</span></span>
		return</span> bean</span>;</span></span>
	}</span></span>
</span>
}</span></span></code></pre>Handler</h3>
Spring 中常见的 Handler</code> 有 HandlerInterceptor</code>, HandlerMethodArgumentResolver</code>, HandlerMethodReturnValueHandler</code> 等。</p>
如下面的 HandlerMethodReturnValueHandler</code> 接口用于处理方法返回值。</p>
public</span> interface</span> HandlerMethodReturnValueHandler</span> {</span></span>
</span>
	/**</span></span>
	 * Whether the given {@linkplain MethodParameter method return type} is</span></span>
	 * supported by this handler.</span></span>
	 * </span>@param</span> returnType</span> the method return type to check</span></span>
	 * </span>@return</span> {@code true} if this handler supports the supplied return type;</span></span>
	 * {@code false} otherwise</span></span>
	 */</span></span>
	boolean</span> supportsReturnType</span>(</span>MethodParameter</span> returnType</span>)</span>;</span></span>
</span>
	/**</span></span>
	 * Handle the given return value by adding attributes to the model and</span></span>
	 * setting a view or setting the</span></span>
	 * {@link ModelAndViewContainer#setRequestHandled} flag to {@code true}</span></span>
	 * to indicate the response has been handled directly.</span></span>
	 * </span>@param</span> returnValue</span> the value returned from the handler method</span></span>
	 * </span>@param</span> returnType</span> the type of the return value. This type must have</span></span>
	 * previously been passed to {@link #supportsReturnType} which must</span></span>
	 * have returned {@code true}.</span></span>
	 * </span>@param</span> mavContainer</span> the ModelAndViewContainer for the current request</span></span>
	 * </span>@param</span> webRequest</span> the current request</span></span>
	 * </span>@throws</span> Exception</span> if the return value handling results in an error</span></span>
	 */</span></span>
	void</span> handleReturnValue</span>(</span>@</span>Nullable</span> Object</span> returnValue</span>,</span> MethodParameter</span> returnType</span>,</span></span>
			ModelAndViewContainer</span> mavContainer</span>,</span> NativeWebRequest</span> webRequest</span>)</span> throws</span> Exception</span>;</span></span></code></pre>持有者 Holder</h2>
如果一个类是用来持有某个资源并包含一些操作资源的方法，那么这个类一般都是以 Holder</code> 结尾，如 BeanDefinitionHolder</code>, BeanFactoryPostProcessorBeanDefinitionRegistry</code>, BeanDefinitionRegistryPostProcessorBeanDefinitionHolder</code> 等。</p>
以 BeanDefinitionHolder</code> 为例，这个类用于持有 BeanDefinition</code> 对象，还包含一些方法，如 matchesName</code> 方法用于判断输入的指定名称是否匹配当前 Holder 持有的 BeanDefinition 对象名称或别名；getShortDescription</code> 方法用于获取 BeanDefinition 的简短描述。</p>
public</span> class</span> BeanDefinitionHolder</span> implements</span> BeanMetadataElement</span> {</span></span>
</span>
	private</span> final</span> BeanDefinition</span> beanDefinition</span>;</span></span>
</span>
	private</span> final</span> String</span> beanName</span>;</span></span>
</span>
	@</span>Nullable</span></span>
	private</span> final</span> String</span>[</span>]</span> aliases</span>;</span></span>
</span>
	/**</span></span>
	 * Create a new BeanDefinitionHolder.</span></span>
	 * </span>@param</span> beanDefinition</span> the BeanDefinition to wrap</span></span>
	 * </span>@param</span> beanName</span> the name of the bean, as specified for the bean definition</span></span>
	 */</span></span>
	public</span> BeanDefinitionHolder</span>(</span>BeanDefinition</span> beanDefinition</span>,</span> String</span> beanName</span>)</span> {</span></span>
		this</span>(</span>beanDefinition</span>,</span> beanName</span>,</span> null</span>)</span>;</span></span>
	}</span></span>
</span>
	/**</span></span>
	 * Create a new BeanDefinitionHolder.</span></span>
	 * </span>@param</span> beanDefinition</span> the BeanDefinition to wrap</span></span>
	 * </span>@param</span> beanName</span> the name of the bean, as specified for the bean definition</span></span>
	 * </span>@param</span> aliases</span> alias names for the bean, or {@code null} if none</span></span>
	 */</span></span>
	public</span> BeanDefinitionHolder</span>(</span>BeanDefinition</span> beanDefinition</span>,</span> String</span> beanName</span>,</span> @</span>Nullable</span> String</span>[</span>]</span> aliases</span>)</span> {</span></span>
		Assert</span>.</span>notNull</span>(</span>beanDefinition</span>,</span> "</span>BeanDefinition must not be null</span>"</span>)</span>;</span></span>
		Assert</span>.</span>notNull</span>(</span>beanName</span>,</span> "</span>Bean name must not be null</span>"</span>)</span>;</span></span>
		this</span>.</span>beanDefinition</span> =</span> beanDefinition</span>;</span></span>
		this</span>.</span>beanName</span> =</span> beanName</span>;</span></span>
		this</span>.</span>aliases</span> =</span> aliases</span>;</span></span>
	}</span></span>
</span>
	/**</span></span>
	 * Determine whether the given candidate name matches the bean name</span></span>
	 * or the aliases stored in this bean definition.</span></span>
	 */</span></span>
	public</span> boolean</span> matchesName</span>(</span>@</span>Nullable</span> String</span> candidateName</span>)</span> {</span></span>
		return</span> (</span>candidateName </span>!=</span> null</span> &&</span> (</span>candidateName</span>.</span>equals</span>(</span>this</span>.</span>beanName</span>)</span> ||</span></span>
				candidateName</span>.</span>equals</span>(</span>BeanFactoryUtils</span>.</span>transformedBeanName</span>(</span>this</span>.</span>beanName</span>)</span>)</span> ||</span></span>
				ObjectUtils</span>.</span>containsElement</span>(</span>this</span>.</span>aliases</span>,</span> candidateName</span>)</span>)</span>)</span>;</span></span>
	}</span></span>
</span>
	/**</span></span>
	 * Return a friendly, short description for the bean, stating name and aliases.</span></span>
	 * </span>@see</span> #getBeanName()</span></span>
	 * </span>@see</span> #getAliases()</span></span>
	 */</span></span>
	public</span> String</span> getShortDescription</span>(</span>)</span> {</span></span>
		if</span> (</span>this</span>.</span>aliases</span> ==</span> null</span>)</span> {</span></span>
			return</span> "</span>Bean definition with name '</span>"</span> +</span> this</span>.</span>beanName</span> +</span> "</span>'</span>"</span>;</span></span>
		}</span></span>
		return</span> "</span>Bean definition with name '</span>"</span> +</span> this</span>.</span>beanName</span> +</span> "</span>' and aliases [</span>"</span> +</span> StringUtils</span>.</span>arrayToCommaDelimitedString</span>(</span>this</span>.</span>aliases</span>)</span> +</span> '</span>]</span>'</span>;</span></span>
	}</span></span>
</span>
	/**</span></span>
	 * Return a long description for the bean, including name and aliases</span></span>
	 * as well as a description of the contained {@link BeanDefinition}.</span></span>
	 * </span>@see</span> #getShortDescription()</span></span>
	 * </span>@see</span> #getBeanDefinition()</span></span>
	 */</span></span>
	public</span> String</span> getLongDescription</span>(</span>)</span> {</span></span>
		return</span> getShortDescription</span>(</span>)</span> +</span> "</span>: </span>"</span> +</span> this</span>.</span>beanDefinition</span>;</span></span>
	}</span></span>
    </span></span>
    //</span> ......省略其他方法</span></span>
</span>
}</span></span></code></pre>执行器 Executor</h2>
执行器一般是用来执行某个任务的，多和线程池有关，Spring 中的执行器一般都是以 Executor</code> 结尾，如 TaskExecutor</code>, AsyncTaskExecutor</code>, AsyncListenableTaskExecutor</code> 等。</p>
工具类 Utils</h2>
工具类一般包含一些静态方法，用于提供一些工具方法，Spring 中的工具类一般都是以 Utils</code> 结尾，如 ClassUtils</code>, BeanUtils</code>, StringUtils</code> 等。</p>


Git 笔记
2024-05-08T19:10:00+08:00
1. 基础概念</h2>

工作区 Working Directory: 就是你在文件管理器中看到的目录，包含你的文件，.git</code> 目录，里面包含所有内容，如修改但未跟踪(未添加到暂存区)的文件，git add 暂存的文件、git commit 提交后的版本库、当前所处分支等信息。</li>
版本库 Repository: 工作区下有个 .git</code> 目录，里面存储了 git</code> 运行所需的所有数据，包括暂存区 stage、分支信息、提交信息等。</li>
暂存区 Stage:</li>
</ul>
2. 暂存区 stage</h2>
2.1. 添加到暂存区 stage</h3>
#</span> 添加所有文件</span></span>
git</span> add</span> .</span></span>
</span>
#</span> 添加指定文件</span></span>
git</span> add</span> file.txt</span></span>
</span>
#</span> 添加指定目录</span></span>
git</span> add</span> dir/</span></span>
</span>
#</span> 使用通配符</span></span>
git</span> add</span> *</span>.txt</span></span></code></pre>2.2. 从暂存区移除</h3>
#</span> 移除所有文件, 其中 HEAD 表示最新的提交</span></span>
git</span> reset</span> HEAD</span></span>
</span>
#</span> 移除指定文件</span></span>
git</span> reset</span> HEAD</span> file.txt</span></span>
</span>
#</span> 新语法</span></span>
git</span> restore</span> -</span>-staged</span> file.txt</span></span></code></pre>

这样操作不会恢复你修改的内容，只是从暂存区移除而已。</p>
</blockquote>
3. 提交到本地仓库 commit</h2>
#</span> 指定消息提交</span></span>
git</span> commit</span> -</span>m</span> "</span>message</span>"</span></span>
</span>
#</span> 添加所有文件到暂存区并提交 (等于自动先执行了 git add .)</span></span>
git</span> commit</span> -</span>am</span> "</span>message</span>"</span></span></code></pre>4. 查看提交记录 log</h2>
#</span> 查看提交记录</span></span>
git</span> log</span></span>
</span>
#</span> 以每条记录一行的简洁方式查看</span></span>
git</span> log</span> -</span>-pretty=oneline</span></span>
</span>
#</span> 包含分支的图表情况</span></span>
git</span> log</span> -</span>-graph</span></span></code></pre>

显示的结果是当前提交以及之前的提交，时间倒序排列。</p>
</blockquote>
5. 回退到上个版本 reset</h2>
#</span> 恢复到上个版本</span></span>
git</span> reset</span> -</span>-hard</span> HEAD^</span></span>
</span>
#</span> 恢复到上上个版本</span></span>
git</span> reset</span> -</span>-hard</span> HEAD^^</span></span>
</span>
#</span> 恢复到上 n 个版本</span></span>
git</span> reset</span> -</span>-hard</span> HEAD~n</span></span>
</span>
#</span> 恢复到指定 commit_id 的版本, commit_id 可以通过 git log 查看</span></span>
git</span> reset</span> -</span>-hard</span> commit_id</span></span></code></pre>6. 查看操作记录 reflog</h2>
如你提交了 5 个版本，恢复到了第 2 次提交后，你想再恢复到第 5 次，但通过 git log</code> 只能看到第 1-2 次提交的记录，第 3-5 次提交的记录看不到了，这时可以通过 git reflog</code> 查看所有操作记录。</p>
git</span> reflog</span></span></code></pre>7. 撤销修改 checkout</h2>
#</span> 撤销工作区的修改</span></span>
git</span> checkout</span> -</span>-</span> file</span></span>
</span>
#</span> 新语法</span></span>
git</span> restore</span> file.txt</span></span></code></pre>
注意上面的命令是撤销工作区</strong>的修改，具体分为以下几种情况：</p>

文件修改自修改后还未提交到暂存区：撤销后文件会和版本库的内容一致。</li>
文件提交到过暂存区，但再次修改后未提交到暂存区：撤销后文件会和暂存区的内容一致。</li>
</ul>
如果已经提交到了暂存区，可以参考上面的 从暂存区移除</a>.</p>

其中 --</code> 是为了避免歧义，表示后面的是文件名，不是分支名。</p>
</blockquote>
8. 比较差异</h2>
#</span> 工作区与暂存区比较</span></span>
git</span> diff</span> file</span> </span></span>
</span>
#</span> 暂存区与版本库比较, 也可以用 --staged, 效果是一样的</span></span>
git</span> diff</span> -</span>-cached</span> file</span></span>
</span>
#</span> 工作区与版本库比较</span></span>
git</span> diff</span> HEAD</span> file</span></span>
</span>
#</span> 工作区和某次提交比较</span></span>
git</span> diff</span> commit_id</span> file</span></span>
</span>
#</span> 比较两次提交</span></span>
git</span> diff</span> commit_id1</span> commit_id2</span></span></code></pre>9. 分支管理 branch</h2>
9.1. 创建, 查看, 切换, 合并, 删除分支</h3>
9.1.1. 添加分支</h4>
#</span> 创建分支</span></span>
git</span> branch</span> branch_name</span></span>
</span>
#</span> 创建并切换到该分支</span></span>
git</span> checkout</span> -</span>b</span> branch_name</span></span>
git</span> switch</span> -</span>c</span> branch_name</span></span></code></pre>9.1.2. 查看分支</h4>
#</span> 查看所有分支</span></span>
git</span> branch</span></span></code></pre>9.1.3. 切换分支</h4>
git</span> checkout</span> branch_name</span></span>
git</span> switch</span> branch_name</span></span></code></pre>9.1.4. 合并分支 merge</h4>
#</span> 合并指定分支到当前分支</span></span>
git</span> merge</span> branch_name</span></span>
</span>
#</span> 合并分支时，加上 --no-ff 参数就可以用普通模式合并，合并后的历史有分支，能看出来曾经做过合并，而默认的 fast forward 合并就看不出来曾经做过合并。</span></span>
#</span> 如 master 合并 dev 分支的修改，从指针上说：</span></span>
#</span>        fast forward 模式: 直接将 master 指针指向 dev 指针指向的内容.</span></span>
#</span>     no fast forward 模式: master 新建了一个跟 dev 指针内容一样的空间，并将 master 指向这个新 new 的指针. </span></span>
git</span> merge</span> -</span>-no-ff</span> -</span>m</span> "</span>merge branch xxx</span>"</span> branch_name</span></span></code></pre>9.1.5. 删除分支</h4>
git</span> branch</span> -</span>d</span> branch_name</span></span>
</span>
#</span> 如果分支未合并，则上面的命令会删除失败，需使用 -D 参数强制删除</span></span>
git</span> branch</span> -</span>D</span> branch_name</span></span></code></pre>9.1.6. 重命名分支</h4>
#</span> 修改当前所在分支名</span></span>
git</span> branch</span> -</span>m</span> new_branch_name</span></span>
</span>
#</span> 修改指定分支名</span></span>
git</span> branch</span> -</span>m</span> old_branch_name</span> new_branch_name</span></span></code></pre>9.2. 冲突解决</h3>
当合并分支时，如果有冲突，会提示：</p>
Auto-merging</span> file.txt</span></span>
CONFLICT</span> (content</span>): Merge conflict in file.txt</span></span>
Automatic</span> merge</span> failed</span>;</span> fix</span> conflicts</span> and</span> then</span> commit</span> the</span> result.</span></span></code></pre>
执行 git status</code> 会显示冲突的文件：</p>
On</span> branch</span> main</span></span>
You</span> have</span> unmerged</span> paths.</span></span>
  (</span>fix</span> conflicts</span> and</span> run</span> "</span>git commit</span>"</span>)</span></span>
  (</span>use</span> "</span>git merge --abort</span>"</span> to</span> abort</span> the</span> merge</span>)</span></span>
</span>
Unmerged</span> paths:</span></span>
  (</span>use</span> "</span>git add <file>...</span>"</span> to</span> mark</span> resolution</span>)</span></span>
	both</span> modified:</span>   file.txt</span></span>
</span>
no</span> changes</span> added</span> to</span> commit</span> (use</span> "</span>git add</span>"</span> and/or</span> "</span>git commit -a</span>"</span>)</span></span></code></pre>
提示我们有两个选择，手动解决冲突或放弃合并。</p>
放弃冲突将会恢复合并前的状态：</p>
git</span> merge</span> -</span>-abort</span></span></code></pre>
手动合并的话，需要编辑冲突的文件，先来看看冲突文件的内容：</p>
hello</span> world</span> java</span> !</span></span>
nihao</span></span>
hello</span> python</span>;</span></span>
add</span> from</span> main</span> branch</span></span>
<<<</span><<<</span><</span> HEAD</span></span>
2</span></span>
=</span>=</span>=</span>=</span>=</span>=</span>=</span></span>
1</span></span>
>>>>>>></span> dev</span></span></code></pre>
上面的内容表示冲突的部分，<<<<<<< HEAD</code> 到 =======</code> 之间是当前分支的内容，=======</code> 到 >>>>>>> dev</code> 之间是合并的分支的内容，我们需要手动解决冲突，编辑后再提交。</p>
10. 高级技巧</h2>
10.1. stash 暂存区</h3>
如你正在开发一个功能，但突然有个 bug 需要修复，但是你本地还有开发一半的功能没法提交，这时可以使用 git stash</code> 命令将当前工作区的内容暂存起来，等 bug 修复后再恢复。</p>
#</span> 暂存当前工作区</span></span>
git</span> stash</span></span></code></pre>
修复 bug 后，回到开发分支后可以通过 git stash list</code> 查看暂存的内容:</p>
stash@</span>{</span>0</span>}</span>:</span> WIP</span> on</span> main:</span> 1389c31</span> merge</span> bug</span> branch</span></span></code></pre>
stash@{0}</code> 表示最新一次暂存</strong>的内容，如果多次暂存会以压栈的方式存储，后面的内容是暂存时的</strong>分支信息：WIP</code> 表示工作区（Working Directory）的意思，main</code> 表示当前分支，1389c31</code> 表示提交的 commit_id，merge bug branch</code> 表示提交的消息。</p>
可以通过 git stash apply</code> 恢复暂存的内容（恢复栈顶也就是最新一次暂存的内容），不过恢复完后没有从栈中移除，可以通过 git stash drop</code> 删除栈顶的内容，或者恢复时使用 git stash pop</code> 恢复并删除栈顶的内容。</p>
如果你不是要恢复栈顶的内容，可以通过 git stash list</code> 查看暂存列表信息，然后通过 git stash apply stash@{n}</code> 恢复指定的内容。</p>
命令参考：</p>
命令</th> 说明</th></tr></thead>

git stash list</code></td> 查看暂存列表</td></tr>
git stash apply stash@{n}</code></td> 恢复暂存内容</td></tr>
git stash drop stash@{n}</code></td> 删除暂存内容</td></tr>
git stash pop stash@{n}</code></td> 恢复并删除暂存内容</td></tr>
git stash show stash@{n}</code></td> 查看暂存的内容(修改的文件)</td></tr>
git stash branch branch_name stash@{n}</code></td> 从暂存创建新分支</td></tr>
git stash save "message"</code></td> 暂存并添加消息</td></tr>
git stash create</code></td> 创建一个暂存，但不应用</td></tr>
git stash clear</code></td> 清空暂存列表</td></tr>
</tbody></table>
10.2. cherry-pick 优选</h3>
如你有两个分支 master</code>, dev</code>, 你正在 dev</code> 分支开发，按照上一节的 stash</code> 功能你为了修复紧急问题创建了个 bug</code> 分支，修复后合并到 master</code> 分支。</p>
但是你正在开发的 dev</code> 分支也需要这个修复，这时可以使用 cherry-pick</code> 命令将 master</code> 分支的修复 "复制"</strong> 到 dev</code> 分支。</p>
如:</p>
#</span> 在 dev 上执行, commit_id 是 master 分支的修复提交</span></span>
git</span> cherry-pick</span> commit_id</span></span></code></pre>
这样会自动将指定的 commit</code> 复制到当前分支并提交(如果有冲突需要手动解决)，提交的日期、提交人、提交消息也是和优选的提交一样。</p>
11. 多人协作 - 远程仓库</h2>
命令</th> 说明</th></tr></thead>

git remote</code></td> 查看远程仓库名称</td></tr>
git remote -v</code></td> 查看远程仓库详细信息</td></tr>
git remote add <fetch|push> origin repo_url</code></td> 添加远程仓库, fetch 是拉取, push 是推送</td></tr>
git remote rm origin</code></td> 删除远程仓库</td></tr>
git remote show origin</code></td> 查看远程仓库详细信息</td></tr>
git clone repo_url</code></td> 克隆远程仓库</td></tr>
git push origin master</code></td> 把当前所在本地分支推送到远程仓库 origin 的 master 分支</td></tr>
git push -u origin branch_name</code></td> 一次性推送并关联远程分支</td></tr>
git pull origin master</code></td> 拉取远程仓库 origin 的 master 分支</td></tr>
git branch --set-upstream-to=origin/branch_name branch_name</code></td> 关联远程分支</td></tr>
git branch -vv</code></td> 查看本地分支关联的远程分支</td></tr>
</tbody></table>
关联远程仓库分支</h3>
git clone</code> 时默认只会克隆远程仓库的主分支，如果想克隆其他分支，可以通过 git checkout -b branch_name origin/branch_name</code> 创建并切换到指定分支，后面的 origin/branch_name</code> 是关联的远程分支，如果不指定就是基于当前本地的分支创建新分支，而不是关联获取远程分支了。</p>
如果你在本地创建了一个新分支，想推送到远程仓库，可以通过 git push origin branch_name</code> 推送到远程仓库，如果远程仓库没有这个分支，会自动创建。</p>
不过这样你每次推送都需要指定 origin branch_name</code>，可以通过 git push -u origin branch_name</code> 一次性推送并关联远程分支，以后推送就可以直接 git push</code> 了。</p>
如果你忘记加 -u</code> 参数，可以通过 git branch --set-upstream-to=origin/branch_name branch_name</code> 关联远程分支。</p>
你可以通过 git branch -vv</code> 查看本地分支关联的远程分支。</p>


使用 Gost 来实现 sniproxy
2024-05-07T20:54:00+08:00
之前介绍过使用 sniproxy</a> 和 nginx stream</a> 来实现 sni 代理，今天介绍使用 gost 来实现 sni 代理，这个更方便，且项目更活跃。</p>
部署 nginx (docker)</h2>
docker</h3>
docker</span> run</span> -</span>d</span> -</span>-name</span> gost</span> -</span>p</span> 443:443</span> -</span>v</span> $(</span>pwd</span>)</span>/gost.yml:/etc/gost/gost.yml</span> gogost/gost</span></span></code></pre>docker-compose</h3>
v</span>ersion</span>:</span> '</span>3.3</span>'</span></span>
s</span>ervices</span>:</span></span>
  g</span>ost</span>:</span></span>
    i</span>mage</span>:</span> g</span>ogost/gost</span></span>
    c</span>ontainer_name</span>:</span> g</span>ost</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    p</span>orts</span>:</span></span>
      -</span> "</span>443:443</span>"</span></span>
    v</span>olumes</span>:</span></span>
      -</span> .</span>/gost.yml:/etc/gost/gost.yml</span></span></code></pre>
其中 gost.yml</code> 配置如下：</p>
s</span>ervices</span>:</span></span>
-</span> n</span>ame</span>:</span> s</span>ni-service</span></span>
  a</span>ddr</span>:</span> "</span>:443</span>"</span></span>
  l</span>istener</span>:</span></span>
    t</span>ype</span>:</span> t</span>cp</span></span>
  h</span>andler</span>:</span></span>
    t</span>ype</span>:</span> s</span>ni</span></span>
  a</span>dmissions</span>:</span> </span></span>
  -</span> s</span>ni-admission</span></span>
</span>
a</span>dmissions</span>:</span></span>
  -</span> n</span>ame</span>:</span> s</span>ni-admission</span></span>
    w</span>hitelist</span>:</span> true</span></span>
    m</span>atchers</span>:</span></span>
    -</span> 1.1.1.1</span></span></code></pre>
其中 admissions.matchers</code> 中的 ip 表示允许哪些 ip 使用该服务，可以防止被滥用。</p>
参考</h2>

gost github</a></li>
gost 文档</a></li>
</ul>


Linux 窗口管理器 Tmux 使用教程
2024-05-05T19:57:00+08:00
1. 安装</h2>
1.1. ubuntu/debian</h3>
sudo</span> apt-get</span> install</span> tmux</span></span></code></pre>1.2. centos/redhat/fedora</h3>
sudo</span> yum</span> install</span> tmux</span></span></code></pre>1.3. alpine</h3>
sudo</span> apk</span> add</span> tmux</span></span></code></pre>1.4. mac</h3>
brew</span> install</span> tmux</span></span></code></pre>2. 启动和退出</h2>
2.1. 启动</h3>
tmux</span></span></code></pre>
执行 tmux</code> 即可启动一个会话。</p>
2.2. 退出</h3>
exit</span></span></code></pre>3. 前缀键</h2>
tmux 的快捷键都是以 ctrl+b</code> 为前缀的，也就是说，你需要先按下 ctrl+b</code> 然后再按下其他键。</p>
举例来说，在任意一个 tmux</code> 会话中，按下 ctrl+b</code> 然后再按下 ?</code> 就会显示帮助文档，再按下 esc</code> 或者 q</code> 就可以退出帮助文档。</p>

点击查看 tmux 帮助文档返回的快捷键</summary>
C-b C-b     Send the prefix
C-b C-o     Rotate through the panes
C-b C-z     Suspend the current client
C-b Space   Select next layout           选择下一个布局(平铺、左右、上下等)
C-b !       Break pane to a new window
C-b "       Split window vertically      划分上下两个窗格
C-b #       List all paste buffers
C-b $       Rename current session       重命名当前会话
C-b %       Split window horizontally    划分左右两个窗格
C-b &       Kill current window
C-b '       Prompt for window index to select
C-b (       Switch to previous client
C-b )       Switch to next client
C-b ,       Rename current window
C-b -       Delete the most recent paste buffer
C-b .       Move the current window
C-b /       Describe key binding
C-b 0       Select window 0
C-b 1       Select window 1
C-b 2       Select window 2
C-b 3       Select window 3
C-b 4       Select window 4
C-b 5       Select window 5
C-b 6       Select window 6
C-b 7       Select window 7
C-b 8       Select window 8
C-b 9       Select window 9
C-b :       Prompt for a command
C-b ;       Move to the previously active pane   切换到最近使用的窗格
C-b =       Choose a paste buffer from a list
C-b ?       List key bindings
C-b C       Customize options
C-b D       Choose a client from a list
C-b E       Spread panes out evenly
C-b L       Switch to the last client
C-b M       Clear the marked pane
C-b [       Enter copy mode
C-b ]       Paste the most recent paste buffer
C-b c       Create a new window
C-b d       Detach the current client
C-b f       Search for a pane
C-b i       Display window information
C-b l       Select the previously current window
C-b m       Toggle the marked pane
C-b n       Select the next window
C-b o       Select the next pane        选择下一个窗格
C-b p       Select the previous window
C-b q       Display pane numbers
C-b r       Redraw the current client
C-b s       Choose a session from a list
C-b t       Show a clock
C-b w       Choose a window from a list
C-b x       Kill the active pane
C-b z       Zoom the active pane
C-b {       Swap the active pane with the pane above
C-b }       Swap the active pane with the pane below
C-b ~       Show messages
C-b DC      Reset so the visible part of the window follows the cursor
C-b PPage   Enter copy mode and scroll up
C-b Up      Select the pane above the active pane            选择上面的窗格
C-b Down    Select the pane below the active pane            选择下面的窗格
C-b Left    Select the pane to the left of the active pane   选择左边的窗格
C-b Right   Select the pane to the right of the active pane  选择右边的窗格
C-b M-1     Set the even-horizontal layout
C-b M-2     Set the even-vertical layout
C-b M-3     Set the main-horizontal layout
C-b M-4     Set the main-vertical layout
C-b M-5     Select the tiled layout
C-b M-n     Select the next window with an alert
C-b M-o     Rotate through the panes in reverse
C-b M-p     Select the previous window with an alert
C-b M-Up    Resize the pane up by 5
C-b M-Down  Resize the pane down by 5
C-b M-Left  Resize the pane left by 5
C-b M-Right Resize the pane right by 5
C-b C-Up    Resize the pane up
C-b C-Down  Resize the pane down
C-b C-Left  Resize the pane left
C-b C-Right Resize the pane right
C-b S-Up    Move the visible part of the window up
C-b S-Down  Move the visible part of the window down
C-b S-Left  Move the visible part of the window left
C-b S-Right Move the visible part of the window right
</pre>
</details>
4. 会话管理 session</h2>
4.1. 新建会话</h3>
直接输入 tmux</code> 创建的会话会以数字命名(从 0 开始递增)，如果想要给会话命名，可以使用 -s</code> 参数。</p>
tmux</span> new</span> -</span>s</span> <</span>session-nam</span>e</span>></span></span></code></pre>4.2. 分离会话</h3>

分离会话就是将当前会话从终端中分离出来，这样就可以在后台运行会话。</p>
</blockquote>
在 tmux</code> 会话中</strong>，按下 ctrl+b d</code> 或 tmux detach</code> 就可以分离当前会话。</p>
4.3. 会话列表</h3>
tmux</span> ls</span></span></code></pre>
这个命令可以列出所有的会话，包含会话名称，创建时间，是否是当前所在会话。</p>
4.4. 连接会话</h3>
使用 tmux attach</code> 命令可以连接到一个已经存在的会话。</p>
#</span> 连接到最近的会话</span></span>
tmux</span> attach</span></span>
</span>
#</span> 连接到指定名称的会话</span></span>
tmux</span> attach</span> -</span>t</span> <</span>session-nam</span>e</span>></span></span>
</span>
#</span> 也可以用缩写</span></span>
tmux</span> a</span> -</span>t</span> <</span>session-nam</span>e</span>></span></span></code></pre>4.5. 杀死会话</h3>
快捷键</th> 命令</th> 说明</th></tr></thead>

ctrl+b &</code></td> tmux kill-server</code></td> 杀死所有会话</td></tr>
</tbody></table>
使用 tmux kill-session</code> 可以杀死某个会话。</p>
#</span> 杀死最近使用的会话</span></span>
tmux</span> kill-session</span></span>
</span>
#</span> 杀死指定名称的会话</span></span>
tmux</span> kill-session</span> -</span>t</span> <</span>session-nam</span>e</span>></span></span></code></pre>4.6. 切换会话</h3>
在 tmux</code> 任意会话中才可以切换会话。</strong></p>
快捷键</th> 命令</th> 说明</th></tr></thead>

ctrl+b s</code></td> tmux choose-session</code></td> 弹出会话列表，可以选择要切换的会话</td></tr>
ctrl+b (</code></td> </td> 切换到上一个会话</td></tr>
ctrl+b )</code></td> </td> 切换到下一个会话</td></tr>
ctrl+b L</code></td> </td> 切换到最近使用的会话</td></tr>
</td> tmux switch-client -t <session-name></code></td> 切换到指定名称的会话</td></tr>
</tbody></table>
4.7. 重命名会话</h3>
使用 tmux rename-session</code> 可以重命名会话。</p>
tmux</span> rename-session</span> -</span>t</span> <</span>old-session-nam</span>e</span>></span> <</span>new-session-nam</span>e</span>></span></span></code></pre>

也可以在会话中按下 ctrl+b $</code> 来重命名会话。</p>
</blockquote>
5. 窗格管理 pane</h2>
5.1. 分割窗格</h3>
在 tmux</code> 会话中</strong>，可以将当前所在窗口分割成多个窗格。</p>
快捷键</th> 命令</th> 说明</th></tr></thead>

ctrl+b %</code></td> tmux split-window -h</code></td> 水平分割</td></tr>
ctrl+b "</code></td> tmux split-window -v</code></td> 垂直分割</td></tr>
</tbody></table>
5.2. 切换窗格/移动光标</h3>
快捷键</th> 命令</th> </th> 说明</th></tr></thead>

ctrl+b 方向键</code></td> tmux select-pane -U/D/L/R</code></td> </td> 切换到指定方向的窗格</td></tr>
ctrl+b o</code></td> </td> </td> 切换到下一个窗格</td></tr>
ctrl+b ;</code></td> tmux last-pane</code></td> </td> 切换到最近使用的窗格</td></tr>
ctrl+b q</code></td> tmux display-panes</code></td> </td> 显示窗格编号</td></tr>
</td> tmux select-pane -t <pane-number></code></td> </td> 切换到指定编号的窗格</td></tr>
</tbody></table>
5.3. 交换窗格位置</h3>
快捷键</th> 命令</th> 说明</th></tr></thead>

ctrl+b {</code></td> tmux swap-pane -U</code></td> 与上一个窗格交换位置</td></tr>
ctrl+b }</code></td> tmux swap-pane -D</code></td> 与下一个窗格交换位置</td></tr>
ctrl+b space</code></td> tmux select-layout <layout-name></code></td> 切换窗格布局(平铺、左右、上下等)</td></tr>
ctrl+b ;</code></td> </td> 与最近使用的窗格交换位置</td></tr>
ctrl+b ctrl+o</code></td> </td> 所有窗格向前移动，第一个窗格会移动到最后</td></tr>
ctrl+b alt+o</code></td> </td> 所有窗格向后移动，最后一个窗格会移动到第一个</td></tr>
</tbody></table>
5.4. 关闭窗格</h3>
快捷键</th> 命令</th> 说明</th></tr></thead>

ctrl+b x</code></td> tmux kill-pane</code>   或 exit</code></td> 关闭当前窗格</td></tr>
</td> tmux kill-pane -t <pane-number></code></td> 关闭指定编号的窗格</td></tr>
</td> tmux kill-pane -a</code></td> 关闭所有窗格，将当前窗格作为默认窗格</td></tr>
</tbody></table>
5.5. 窗格调整大小</h3>
快捷键</th> 命令</th> 说明</th></tr></thead>

ctrl+b z</code></td> tmux resize-pane -Z</code></td> 将当前窗格全屏，再次按下恢复</td></tr>
ctrl+b ctrl+方向键</code></td> tmux resize-pane -U/D/L/R <size></code></td> 调整窗格大小</td></tr>
</tbody></table>
6. 窗口管理 window</h2>
6.1. 新建窗口</h3>
在 tmux</code> 会话中</strong>，可以新建一个窗口，这个窗口还隶属于当前会话，但不同窗口之间是独立的，可以有不同的布局。</p>
用 ctrl+b c</code> 快捷键或命令 tmux new-window</code> 来新建一个窗口，新建的窗口会以数字命名(从 0 开始递增)，如果想要给窗口命名，可以使用 -n</code> 参数，如 tmux new-window -n <window-name></code>。</p>
6.2. 重命名窗口</h3>
在 tmux</code> 会话中</strong>，按下 ctrl+b ,</code> 快捷键或命令 tmux rename-window <new-name></code> 来重命名窗口。</p>
6.3. 切换窗口</h3>
快捷键</th> 命令</th> 说明</th></tr></thead>

ctrl+b w</code></td> tmux choose-window</code></td> 弹出窗口列表，可以选择要切换的窗口</td></tr>
ctrl+b p</code></td> tmux previous-window</code></td> 切换到上一个窗口</td></tr>
ctrl+b n</code></td> tmux next-window</code></td> 切换到下一个窗口</td></tr>
ctrl+b l</code></td> tmux last-window</code></td> 切换到最近使用的窗口</td></tr>
ctrl+b <window-number></code></td> tmux select-window -t <window-number></code></td> 切换到指定编号的窗口</td></tr>
</tbody></table>
7. 其他命令</h2>
#</span> 列出所有快捷键，及其对应的 Tmux 命令</span></span>
tmux</span> list-keys</span></span>
</span>
#</span> 列出所有 Tmux 命令及其参数</span></span>
tmux</span> list-commands</span></span>
</span>
#</span> 列出当前所有 Tmux 会话的信息</span></span>
tmux</span> info</span></span></code></pre>8. 状态栏</h2>
8.1. 状态栏内容</h3>
tmux</code> 的状态栏默认是在底部的，可以显示当前窗口名称，窗口列表(编号，名称，是否是全屏模式，是否是当前窗格)，如：</p>
[ffmpeg] 0:a*Z 1:z-                "debian" 15:53 06-5月-24</span></span></code></pre>
其中：</p>

ffmpeg</code> 是当前窗口名称；</li>
0:a*Z</code> 是窗口列表，0</code> 是当前窗口编号，a</code> 是窗口名称，*</code> 表示当前窗口，Z</code> 表示窗口是全屏模式；</li>
1:z-</code> 是第二个窗口，1</code> 是窗口编号，z</code> 是窗口名称，-</code> 表示窗口不是全屏模式；</li>
"debian" 15:53 06-5月-24</code> 是状态栏右侧的内容，debian</code> 是主机名，15:53</code> 是当前时间，06-5月-24</code> 是当前日期。</li>
</ul>
8.2. 设置状态栏右侧内容</h3>
可以通过 set-option</code> 命令来设置状态栏的内容。</p>
#</span> 设置状态栏内容</span></span>
tmux</span> set-option</span> -</span>g</span> status-right</span> "</span>debian %H:%M %d-%b-%y</span>"</span></span></code></pre>
可以使用以下变量：</p>

%H</code> 当前小时</li>
%M</code> 当前分钟</li>
%d</code> 当前日期</li>
%b</code> 当前月份</li>
%y</code> 当前年份</li>
%S</code> 当前秒钟</li>
%p</code> AM/PM</li>
%I</code> 当前小时(12小时制)</li>
%k</code> 当前小时(24小时制)</li>
%l</code> 当前分钟</li>
%a</code> 当前星期几</li>
%A</code> 当前星期几(全称)</li>
%u</code> 当前星期几(数字)</li>
%U</code> 当前年的第几周</li>
%j</code> 当前年的第几天</li>
%w</code> 当前天</li>
%s</code> 当前 Unix 时间戳</li>
</ul>
可以通过 set-option</code> 命令来设置状态栏的颜色。</p>
8.3. 设置状态栏颜色</h3>
#</span> 设置状态栏颜色</span></span>
tmux</span> set-option</span> -</span>g</span> status-style</span> fg=black,bg=green</span></span></code></pre>8.4. 设置状态栏位置</h3>
tmux</span> set-option</span> -</span>g</span> status-position</span> <</span>top</span>|</span>bottom</span>></span></span></code></pre>


Percona XtraDB Cluster 集群搭建
2024-04-22T19:36:00+08:00
简介</h2>
PXC</code> 的全称是 Percona XtraDB Cluster</code>，是基于 Galera</code> 的 MySQL</code> 高可用解决方案，由于是基于 Galera</code>，所以 PXC</code> 也具有 Galera</code> 的特性。</p>
PXC 集群特点：</p>

多主集群，即每个节点都可以读写数据</li>
同步复制，事务在所有节点要么都提交，要么都不提交</li>
同步强一致性，受益于同步复制</strong>，所有节点的数据都是强一致的，不会像 MySQL 自带的 replication</code> 那样存在数据不一致的情况。</li>
集群中的节点数量可以动态增加或减少，但建议节点数为奇数，如 3、5、7 等，这样可以避免脑裂。</li>
因为是同步强一致性，根据木桶原理，集群的性能取决于最慢的节点，所以也不建议节点数过多，因为会带来同步压力。</li>
binlog_format 必须为 ROW</code>。</li>
</ul>

本文不建议跳着看，因为前面的配置会相对简单一些，是为了让大家先对 PXC 有一个大致的了解，避免刚开始就看到复杂的配置而放弃。但简单的配置会有一些坑，后面会增加配置一一解决。</p>
</blockquote>
集群搭建 (单机多节点)</h2>
创建网络</h3>
为了方便集群内部通信，我们需要创建一个 docker 网络，这样集群内部的容器就可以通过容器名互相访问了。</p>
docker</span> network</span> create</span> pxc_net</span></span></code></pre>创建 node1</h3>
mkdir</span> -</span>p</span> ./node1/{data,conf.d,cluster.conf.d}</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node1</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node1</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>p</span> 9000:3306</span> \</span></span>
    -</span>v</span> ./node1/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node1/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node1/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    percona/percona-xtradb-cluster:5.7</span></span>
docker</span> logs</span> -</span>f</span> node1</span></span></code></pre>

第一行创建了一个目录，用于存放 node1</code> 的数据、配置文件等，其中 data</code> 目录用于存放 MySQL</code> 数据，conf.d</code> 目录用于存放 MySQL</code> 配置文件，cluster.conf.d</code> 目录用于存放 PXC</code> 集群相关配置文件。</li>
第二行将目录的所有者改为 1001:1001</code>，这是因为 PXC</code> 的容器内部的 MySQL</code> 进程是以 1001</code> 用户运行的，如果不改，会导致容器内部无法写入数据。</li>
第三行创建了一个容器，其中：

-name</code> 用于指定容器名，这里是 node1</code>。</li>
-net</code> 用于指定容器使用的网络，我们设置为了 pxc_net</code>。</li>
-p</code> 用于指定容器对外暴露的端口，这里是将容器的 3306</code> 端口映射到主机的 9000</code> 端口，这样我们就可以通过主机的 9000</code> 端口访问容器内部的 MySQL</code> 服务了。</li>
-v</code> 用于挂载目录，避免容器重建后数据丢失。</li>
-e</code> 用于设置环境变量，这里设置了时区，MySQL</code> 的 root</code> 用户密码和集群名称。</li>
percona/percona-xtradb-cluster:5.7</code> 是 PXC</code> 的镜像名称和版本。这里先使用 5.7 版本，因为 8.0 版本的 PXC</code> 配置要多一些步骤，后面会介绍。</li>
</ul>
</li>
第四行查看容器日志，如果容器启动成功，会输出 [Note] InnoDB: Buffer pool(s) load completed at xxx</code>，按 Ctrl + C</code> 退出日志查看。</li>
</ul>
创建 node2</h3>
待 node1</code> 启动成功，并尝试通过工具连接 MySQL</code> 服务成功后，我们再创建 node2</code>，这很重要，如果 node1</code> 还未完全启动，node2</code> 将无法加入集群。</p>
mkdir</span> -</span>p</span> ./node2/{data,conf.d,cluster.conf.d}</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node2</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node2</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>p</span> 9001:3306</span> \</span></span>
    -</span>v</span> ./node2/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node2/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node2/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> CLUSTER_JOIN=node1</span> \</span></span>
    percona/percona-xtradb-cluster:5.7</span></span>
docker</span> logs</span> -</span>f</span> node2</span></span></code></pre>
这里和创建 node1</code> 的命令基本一致，做了以下修改：</p>

修改目录、容器名从 node1</code> 改为 node2</code>。</li>
修改端口从 9000</code> 改为 9001</code>。</li>
新增一个环境变量 CLUSTER_JOIN</code>，用于指定加入哪个节点的集群，这里我们指定为 node1</code>，这样 node2</code> 就会加入 node1</code> 的集群了。（两者的 CLUSTER_NAME</code> 要一致）</li>
</ul>
其他的保持不变。</p>
创建 node3</h3>
PXC</code> 建议集群节点数为奇数，所以我们再创建一个 node3</code>。（是为了避免发生脑裂，如偶数个节点 node1 node2 node3 node4，如果出现一种情况 node1 和 node2 通信正常，node3 和 node4 通信正常，其他节点之间互相通信不正常，这样就会导致 node1 和 node2 形成一个集群，node3 和 node4 形成一个集群，大家都以为是一个集群，但实际上是两个集群，这就是脑裂。）</p>
mkdir</span> -</span>p</span> ./node3/{data,conf.d,cluster.conf.d}</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node3</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node3</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>p</span> 9002:3306</span> \</span></span>
    -</span>v</span> ./node3/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node3/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node3/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> CLUSTER_JOIN=node1</span> \</span></span>
    percona/percona-xtradb-cluster:5.7</span></span>
docker</span> logs</span> -</span>f</span> node3</span></span></code></pre>
这里和创建 node2</code> 的命令基本一致，做了以下修改：</p>

修改目录、容器名从 node2</code> 改为 node3</code>。</li>
修改端口从 9001</code> 改为 9002</code>。</li>
</ul>
环境变量中 CLUSTER_JOIN</code> 这里也指定的 node1</code>，但也可以指定 node2</code>，因为 node2</code> 已经加入了 node1</code> 的集群 (前提 node2</code> 已经启动成功，而不是也正在加入集群中。)</p>
验证集群</h3>
接下来你可以在集群中任意一个节点上建库、建表、插入数据，然后在其他节点上查看，你会发现数据是同步的。</p>
还可以通过以下命令查看集群状态：</p>
mysql</span>></span> show</span> status</span> like</span> '</span>wsrep_cluster_%</span>'</span>;</span></span>
+--------------------------+--------------------------------------+</span></span>
|</span> Variable_name</span>            |</span> Value</span>                                |</span></span>
+--------------------------+--------------------------------------+</span></span>
|</span> wsrep_cluster_weight</span>     |</span> 3</span>                                    |</span></span>
|</span> wsrep_cluster_conf_id</span>    |</span> 3</span>                                    |</span></span>
|</span> wsrep_cluster_size</span>       |</span> 3</span>                                    |</span></span>
|</span> wsrep_cluster_state_uuid</span> |</span> acf9cb67-bfe4-11ee-8173-d6bb71ba1416</span> |</span></span>
|</span> wsrep_cluster_status</span>     |</span> Primary</span>                              |</span></span>
+--------------------------+--------------------------------------+</span></span>
5</span> rows</span> in</span> set</span> (0.00</span> sec</span>)</span></span></code></pre>
其中 wsrep_cluster_size</code> 表示集群中节点的数量，其他的可以参考 官方文档</a>。</p>
通过以下命令查看所处集群名称，当前节点 join 入集群时的节点：</p>
mysql</span>></span> show</span> variables</span> like</span> '</span>wsrep_cluster_%</span>'</span>;</span></span>
+-----------------------+---------------+</span></span>
|</span> Variable_name</span>         |</span> Value</span>         |</span></span>
+-----------------------+---------------+</span></span>
|</span> wsrep_cluster_address</span> |</span> gcomm://node1</span> |</span></span>
|</span> wsrep_cluster_name</span>    |</span> pxc-cluster1</span>  |</span></span>
+-----------------------+---------------+</span></span>
2</span> rows</span> in</span> set</span> (0.00</span> sec</span>)</span></span></code></pre>
注意这里的 wsrep_cluster_address</code> 其实就是我们在 docker 启动时设置的环境变量 CLUSTER_JOIN</code>，node1</code> 作为第一个节点启动的，所以没有配置 CLUSTER_JOIN</code>，那么这里会显示 gcomm://</code>。</p>
这个值表示启动时从哪个地址连接到集群，如不指定端口，默认是 4567</code>，可以写多个地址，用逗号分隔，如 gcomm://node1,node2,node3</code>，这样就可以从这三个节点的 4567</code> 端口连接到集群。</p>
关闭集群节点</h3>
在 PXC</code> 中，节点停止时会给其他节点发送通知，最后一个节点停止时，会将配置文件 /var/lib/mysql/grastate.dat</code> 中的 safe_to_bootstrap</code> 设置为 1</code>，表示可以将该节点作为主节点安全启动（准确的说是 引导节点</code>）</strong>。</p>
因为最后一个退出的节点，会包含更完整的数据，所以我们的所有节点都停止后，应先启动最后一个退出的节点</strong>，然后再启动其他节点。如果你弄错了不小心将 safe_to_bootstrap=0</code> 的节点作为第一个启动了也没关系，PXC</code> 可以检测到这种情况，启动时报错：</p>
[</span>ERROR</span>]</span> WSREP: It may not be safe to bootstrap the cluster from this node. It was not the last one to leave the cluster and may not contain all the updates. To force cluster bootstrap with this node, edit the grastate.dat file manually and set safe_to_bootstrap to 1 </span>.</span></span></code></pre>
注意我们前面强调的是全部停止的情况下启动第一个节点，如果集群中有节点正在运行，且要启动的节点 wsrep_cluster_address</code> 中包含了正在运行的节点，那么他的 safe_to_bootstrap=0</code> 也没事，因为他不会作为主节点(引导节点)，而是会从正在运行的节点同步数据，这样也是安全的。</p>
如果节点是异常退出的，没来得及将 safe_to_bootstrap</code> 设置为 1</code>，或者 safe_to_bootstrap=1</code> 的节点数据丢了，你只能手动将你认为数据最全节点的 safe_to_bootstrap</code> 设置为 1</code>，然后启动他，再启动其他节点会从他同步数据。</p>
那么 safe_to_bootstrap</code> 和 wsrep_cluster_address</code> 的关系是什么呢？我们可以这样理解：</p>

如果 safe_to_bootstrap=0</code>，表示他不是最后一个退出的节点，那么他的 wsrep_cluster_address</code> 中必须包含其他节点的信息</strong>，因为他需要从其他节点同步数据，如果不包含其他节点的信息，或包含的节点他无法连接上，将无法启动成功。</li>
如果 safe_to_bootstrap=1</code>，表示他是最后一个退出的节点，会作为主节点(引导节点)启动，那么他不需要从其他节点同步数据，启动时也就不会读取 wsrep_cluster_address</code> 的值（即使配置了）。</li>
</ul>
坑 1：节点重启后无法加入集群</h3>
你可能会在网上看到其他文章中写到 PXC</code> 中不区分主从节点，只要有两个或以上个节点，就都是主节点</strong>，然后你看到上一节 关闭节点</strong>，既然不分主从节点，如果所有节点退出时，最后一个节点先启动，如果有正在运行的节点，其他节点可以随意启停，实际上不是这样的，或者说在我们现在的配置下不是这样的，你可能会遇到报错，无法重启节点。</p>
回顾下前面，我们创建 node1 没有指定 CLUSTER_JOIN</code>，node2 和 node3 的时指定了 CLUSTER_JOIN=node1</code>，可以在各个节点上执行: show variables like 'wsrep_cluster_%';</code> 查看到：</p>

node1: wsrep_cluster_address=gcomm://</code></li>
node2: wsrep_cluster_address=gcomm://node1</code></li>
node3: wsrep_cluster_address=gcomm://node1</code></li>
</ul>
场景 1：node1 在运行时，重启 node2 或 node3</strong>：可以正常重启，因为他们的 wsrep_cluster_address</code> 中指向的是 node1</code>，node1</code> 还在运行中，所以他们可以正常重启。
场景 2：node1 停止，node2 和 node3 保持运行</strong>：这时 node2</code> 和 node3</code> 之间其实是可以正常通信的，即使他们的 wsrep_cluster_address</code> 中指向的 node1</code> 已经停止了，因为他们的缓存中是包含所有节点的信息的，但如果这时 node2 或 node3 重启，当前节点缓存中数据丢失，根据上面的参数，他们启动时会从 node1</code> 的 4567</code> 端口连接到集群，但 node1</code> 已经停止了，这时就会因为连接不到 node1</code> 导致无法加入集群而启动失败。
场景 3：node1 重启，node2 和 node3 保持运行</strong>：同理，node2</code> 和 node3</code> 之间是可以正常通信的，但 node1</code> 无法重启成功，因为不是最后一个退出集群的，safe_to_bootstrap</code> 为 0</code> 表示他不是作为主节点(引导节点)启动，也就是需要 join 到 wsrep_cluster_address</code> 里配置的节点，但 node1</code> 这个参数不包含其他节点，无法连接到集群，启动失败。
场景 4：node2 和 node3 先停止，最后停止 node1</strong>：这时 node1</code> 的 safe_to_bootstrap</code> 会被设置为 1</code>，表示可以作为主节点启动，虽然他 wsrep_cluster_address</code> 中不包含其他节点的信息，但是他此时是作为主节点启动的，也就是说他不需要连接到集群，所以他可以正常启动，然后再启动 node2</code> 和 node3</code>，这样整个集群就恢复了。</p>
所以在当前的配置中，我们无法随意的启动节点，因为 node1</code> 的 wsrep_cluster_address</code> 为空，但我们最开始初始化集群时他作为第一个节点本就不应配置也不知道其他节点，而且 docker 容器的 -e 配置的环境变量无法修改，无法再给他加上 CLUSTER_JOIN</code>。</p>
这很不方便，但幸运的是有解决办法，还记得我们最开始创建容器时挂载的目录吗？</p>
-v</span> ./node1/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span></span></code></pre>
我们可以在 ./node1/cluster.conf.d/</code> 目录下创建一个 cluster.cnf</code> 文件，内容如下：</p>
[</span>mysqld</span>]</span></span>
wsrep_cluster_address</span>=</span>g</span>c</span>o</span>m</span>m</span>:</span>/</span>/</span>n</span>o</span>d</span>e</span>1</span>,</span>n</span>o</span>d</span>e</span>2</span>,</span>n</span>o</span>d</span>e</span>3</span></span></code></pre>
这里可以不包含当前节点自身，不过加上也不影响，PXC</code> 不会自己咬自己尾巴（不会从当前节点作为来源同步数据）。</p>
同理，我们也可以在 ./node2/cluster.conf.d/</code> 和 ./node3/cluster.conf.d/</code> 目录下创建一个 cluster.cnf</code> 文件，配置上所有节点的信息，这样我们就可以随意启动节点了。</p>
节点自动发现</h3>
上面的配置虽然解决了节点重启后无法加入集群的问题，但是如果我们要扩容或缩容集群，还是需要手动修改所有节点的配置文件，如果你像我一样是懒人</strong>，那么可以按照以下步骤配置节点自动发现:</p>
目前 PXC</code> 只支持 etcd</code> 作为自动发现的后端，所以我们需要先安装 etcd</code>，这里我们使用 docker</code> 安装 etcd</code>。</p>
docker</span> run</span> -</span>d</span> -</span>-name</span> pxc-etcd</span> \</span></span>
  -</span>-net=pxc_net</span> \</span></span>
  -</span>e</span> ETCD_ENABLE_V2=</span>true</span> \</span></span>
  -</span>e</span> ETCD_ROOT_PASSWORD=</span>'</span>j99*v#3xu%GP4@Kv#!</span>'</span> \</span></span>
  bitnami/etcd:latest</span></span></code></pre>
这里我们使用 bitnami/etcd:latest</code> 镜像创建一个名为 pxc-etcd</code> 的容器，--net=pxc_net</code> 表示使用我们之前创建的 pxc 网络，这样他们才能互相通信，ETCD_ENABLE_V2=true</code> 表示启用 etcd</code> 的 v2</code> 版本的 API（pxc 用的是 v2 的 api），ETCD_ROOT_PASSWORD</code> 配置了 root 用户的密码，但实际上我们不会用到，这里配置是因为该容器要求必须配置，不然无法启动。（这里我们没有使用 -p 参数对外暴露端口，因为不需要，只要 pxc_net</code> 这个网络内各个容器可以互相访问即可）</p>
然后就不需要配置 cluster.cnf</code> 了，我们只需要在启动容器时增加个环境变量 DISCOVERY_SERVICE</code>，指定 etcd</code> 的地址即可，如：-e DISCOVERY_SERVICE=pxc-etcd:2379</code>，这样 PXC 节点启动时会自动将自身注册到 etcd</code> 中，并获取集群其他节点地址，然后加入集群。</p>
修改后各个节点的启动命令如下：</p>
node1:</p>
mkdir</span> -</span>p</span> ./node1/{data,conf.d,cluster.conf.d}</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node1</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node1</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>p</span> 9000:3306</span> \</span></span>
    -</span>v</span> ./node1/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node1/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node1/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> DISCOVERY_SERVICE=pxc-etcd:2379</span> \</span></span>
    percona/percona-xtradb-cluster:5.7</span></span>
docker</span> logs</span> -</span>f</span> node1</span></span></code></pre>
node2:</p>
mkdir</span> -</span>p</span> ./node2/{data,conf.d,cluster.conf.d}</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node2</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node2</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>p</span> 9001:3306</span> \</span></span>
    -</span>v</span> ./node2/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node2/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node2/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> DISCOVERY_SERVICE=pxc-etcd:2379</span> \</span></span>
    percona/percona-xtradb-cluster:5.7</span></span>
docker</span> logs</span> -</span>f</span> node2</span></span></code></pre>
node3:</p>
mkdir</span> -</span>p</span> ./node3/{data,conf.d,cluster.conf.d}</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node3</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node3</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>p</span> 9002:3306</span> \</span></span>
    -</span>v</span> ./node3/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node3/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node3/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8112424SPEsU124#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> DISCOVERY_SERVICE=pxc-etcd:2379</span> \</span></span>
    percona/percona-xtradb-cluster:5.7</span></span>
docker</span> logs</span> -</span>f</span> node3</span></span></code></pre>
可以通过以下命令查看 etcd</code> 中集群的信息：</p>
CONTAINER_NAME</span>=</span>"</span>pxc-etcd</span>"</span></span>
CLUSTER_NAME</span>=</span>"</span>pxc-cluster1</span>"</span></span>
PXC_ETCD_PID</span>=</span>$(</span>docker</span> inspect</span> -</span>f</span> "</span>{{.State.Pid}}</span>"</span> $</span>CONTAINER_NAME</span>)</span></span>
nsenter</span> -</span>t</span> $</span>PXC_ETCD_PID</span> -</span>n</span> curl</span> http://127.0.0.1:2379/v2/keys/pxc-cluster/</span>$</span>CLUSTER_NAME</span>?recursive=</span>true</span></span></code></pre>
简化为一行是：</p>
CONTAINER_NAME</span>=</span>"</span>pxc-etcd</span>"</span> &&</span> CLUSTER_NAME</span>=</span>"</span>pxc-cluster1</span>"</span> &&</span> nsenter</span> -</span>t</span> $(</span>docker</span> inspect</span> -</span>f</span> "</span>{{.State.Pid}}</span>"</span> $</span>CONTAINER_NAME</span>)</span> -</span>n</span> curl</span> http://127.0.0.1:2379/v2/keys/pxc-cluster/</span>$</span>CLUSTER_NAME</span>?recursive=</span>true</span></span></code></pre>坑 2：节点自动发现的 IP 逐渐增多</h3>
虽然我们现在配置了集群自动发现，但是你查看 etcd 或者节点的 wsrep_cluster_address</code> 可能会发现，每次重启节点后，集群中的节点 IP 都会增加，这是因为现在我们的 docker 容器没有指定 IP，所以每次重启后，节点都会将自身 IP　添加到集群中，导致 etcd 中的 IP 逐渐增多。</p>
解决办法是给容器指定 IP，即增加 --ip</code> 参数，但配置这个参数需要在 docker network 创建时指定 IP 范围，所以我们需要先删除之前创建的 pxc_net</code> 网络和依赖该网络的容器，然后重新创建一个指定 IP 范围的网络。</p>
docker</span> rm</span> -</span>f</span> node1</span> node2</span> node3</span> pxc-etcd</span>  #</span> 删除容器</span></span>
rm</span> -</span>rf</span> ./node1</span> ./node2</span> ./node3</span>           #</span> 删除目录</span></span>
docker</span> network</span> rm</span> pxc_net</span>                #</span> 删除网络</span></span>
docker</span> network</span> create</span> -</span>-subnet=172.10.0.0/16</span> pxc_net</span> #</span> 创建网络, 指定 IP 范围</span></span></code></pre>
etcd</code> 可以不指定 IP，仍然是之前的命令不变：</p>
docker</span> run</span> -</span>d</span> -</span>-name</span> pxc-etcd</span> -</span>-net=pxc_net</span> -</span>e</span> ETCD_ENABLE_V2=</span>true</span> -</span>e</span> ETCD_ROOT_PASSWORD=</span>'</span>j99*v#3xu%GP4@Kv#!</span>'</span> bitnami/etcd:latest</span></span></code></pre>
但是启动 pxc 节点容器时增加 --ip</code> 参数，如：</p>
node1:</p>
mkdir</span> -</span>p</span> ./node1/{data,conf.d,cluster.conf.d}</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node1</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node1</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>-ip=172.10.0.101</span> \</span></span>
    -</span>p</span> 9000:3306</span> \</span></span>
    -</span>v</span> ./node1/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node1/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node1/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> DISCOVERY_SERVICE=pxc-etcd:2379</span> \</span></span>
    percona/percona-xtradb-cluster:5.7</span></span>
docker</span> logs</span> -</span>f</span> node1</span></span></code></pre>
node2:</p>
mkdir</span> -</span>p</span> ./node2/{data,conf.d,cluster.conf.d}</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node2</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node2</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>-ip=172.10.0.102</span> \</span></span>
    -</span>p</span> 9001:3306</span> \</span></span>
    -</span>v</span> ./node2/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node2/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node2/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> DISCOVERY_SERVICE=pxc-etcd:2379</span> \</span></span>
    percona/percona-xtradb-cluster:5.7</span></span>
docker</span> logs</span> -</span>f</span> node2</span></span></code></pre>
node3:</p>
mkdir</span> -</span>p</span> ./node3/{data,conf.d,cluster.conf.d}</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node3</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node3</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>-ip=172.10.0.103</span> \</span></span>
    -</span>p</span> 9002:3306</span> \</span></span>
    -</span>v</span> ./node3/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node3/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node3/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> DISCOVERY_SERVICE=pxc-etcd:2379</span> \</span></span>
    percona/percona-xtradb-cluster:5.7</span></span>
docker</span> logs</span> -</span>f</span> node3</span></span></code></pre>坑 3：etcd 中的节点信息不会自动清理</h3>
虽然现在我们的集群可以自动发现，但是不会自动清理 etcd 中的节点信息，所以如果我们删除了某个节点，etcd 中的节点信息不会自动删除。这可能会带来问题，比如我们使用 172.10.0.100</code> 创建了容器第一个节点，然后我们后悔了，想删掉这个节点，然后使用 172.10.0.200</code> 作为第一个节点，但是这时 etcd 中已经有了 172.10.0.100</code> 的节点信息，这是会尝试加入到这个 ip 所在的集群中，但是显然是不可能加入成功的，这时就会启动失败报错。</p>
官方也给了我们解决办法，就是自己删除 etcd 中的节点信息，官方说明地址为: Percona XtraDB Cluster docker image</a>，内容为：</p>
Currently,</span> there</span> is</span> no</span> automatic</span> cleanup</span> for</span> the</span> discovery</span> service</span> registry.</span> You</span> can</span> remove</span> all</span> entries</span> using</span> curl</span> http://</span>$</span>ETCD_HOST</span>/v2/keys/pxc-cluster/</span>$</span>CLUSTER_NAME</span>?recursive=</span>true</span> -</span>XDELETE.</span></span></code></pre>
按照官方的提示我们可以使用以下命令删除 etcd 中的节点信息：</p>
CONTAINER_NAME</span>=</span>"</span>pxc-etcd</span>"</span></span>
CLUSTER_NAME</span>=</span>"</span>pxc-cluster1</span>"</span></span>
PXC_ETCD_PID</span>=</span>$(</span>docker</span> inspect</span> -</span>f</span> "</span>{{.State.Pid}}</span>"</span> $</span>CONTAINER_NAME</span>)</span></span>
nsenter</span> -</span>t</span> $</span>PXC_ETCD_PID</span> -</span>n</span> curl</span> -</span>XDELETE</span> http://127.0.0.1:2379/v2/keys/pxc-cluster/</span>$</span>CLUSTER_NAME</span>?recursive=</span>true</span></span></code></pre>
简化为一行是：</p>
CONTAINER_NAME</span>=</span>"</span>pxc-etcd</span>"</span> &&</span> CLUSTER_NAME</span>=</span>"</span>pxc-cluster1</span>"</span> &&</span> nsenter</span> -</span>t</span> $(</span>docker</span> inspect</span> -</span>f</span> "</span>{{.State.Pid}}</span>"</span> $</span>CONTAINER_NAME</span>)</span> -</span>n</span> curl</span> -</span>XDELETE</span> http://127.0.0.1:2379/v2/keys/pxc-cluster/</span>$</span>CLUSTER_NAME</span>?recursive=</span>true</span></span></code></pre>
如果不想清空所有节点信息，可以使用以下命令删除指定 IP 节点信息：</p>
CONTAINER_NAME</span>=</span>"</span>pxc-etcd</span>"</span></span>
CLUSTER_NAME</span>=</span>"</span>pxc-cluster1</span>"</span></span>
NODE_IP</span>=</span>"</span>172.10.0.101</span>"</span></span>
PXC_ETCD_PID</span>=</span>$(</span>docker</span> inspect</span> -</span>f</span> "</span>{{.State.Pid}}</span>"</span> $</span>CONTAINER_NAME</span>)</span></span>
nsenter</span> -</span>t</span> $</span>PXC_ETCD_PID</span> -</span>n</span> curl</span> -</span>XDELETE</span> http://127.0.0.1:2379/v2/keys/pxc-cluster/</span>$</span>CLUSTER_NAME</span>/</span>$</span>NODE_IP</span>?dir=</span>true</span></span></code></pre>
简化为一行是：</p>
CONTAINER_NAME</span>=</span>"</span>pxc-etcd</span>"</span> &&</span> CLUSTER_NAME</span>=</span>"</span>pxc-cluster1</span>"</span> &&</span> NODE_IP</span>=</span>"</span>172.10.0.101</span>"</span> &&</span> nsenter</span> -</span>t</span> $(</span>docker</span> inspect</span> -</span>f</span> "</span>{{.State.Pid}}</span>"</span> $</span>CONTAINER_NAME</span>)</span> -</span>n</span> curl</span> -</span>XDELETE</span> http://127.0.0.1:2379/v2/keys/pxc-cluster/</span>$</span>CLUSTER_NAME</span>/</span>$</span>NODE_IP</span>?dir=</span>true</span></span></code></pre>集群搭建 (多机多节点)</h2>
前面我们是在一台机器上创建了多个节点，如果我们想在多台机器上创建多个节点就要先解决跨机器之间容器的通信问题。</p>

如有两台机器 machine1 和 machine2，都创建了 docker 网络 docker network create pxc_net，然后在 machine1 上创建了容器 node1，machine2 上创建了容器 node2，按照我们现在的配置 node1 和 node2 是无法通信的，因为他们之间没有任何关联，在这里只是恰好同名而已。</p>
</blockquote>
Docker Swarn Overlay Network 实现跨机器容器通信</h3>
我们可以通过 docker 的 overlay</code> 网络来解决这个问题，使用 overlay</code> 网络需要在 docker swarm</code> 模式下，将 machine1 和 machine2 加入到同一个 swarm</code> 中，然后创建一个 overlay</code> 网络，这样 machine1 和 machine2 上的容器就可以互相通信了。</p>
首先在其中一个机器上初始化 swarm</code>：</p>
docker</span> swarm</span> init</span> -</span>-advertise-addr</span> 10.0.0.246</span></span></code></pre>

-listen-addr</code>：表示 Docker Swarm 监听的网络接口</code>，默认是 0.0.0.0:2377</code>。</li>
-advertise-addr</code>：广播地址，也就是允许其他节点通过哪个网络接口</code>加入该 swarm 集群，主要用于机器上有多个网卡的情况，如果只有一个网卡，可以不指定，会使用 -listen-addr</code> 的值。但如果有多个网卡，就必须指定一个地址，且需保证这个地址在 listen-addr</code> 监听的网卡/IP + 端口上。</li>
-data-path-addr</code>：数据域地址，服务器之间的流量通过哪个网络接口</code>发送，也可以使用此参数将容器的数据流量和集群之间的管理流量分开，非必填，默认使用 -advertise-addr</code> 中的 网络接口</code>，端口使用 4789</code>。</li>
</ul>
上面三个选项说的 网络接口</code> 可以是 IP</code> 也可以是网卡名，如 eth0</code>。都可以不写端口，--listen-addr</code> 和--advertise-addr</code> 默认是 2377</code>，--data-path-addr</code> 默认是 4789</code>。</p>
执行完会返回一个命令:</p>
Swarm</span> initialized:</span> current</span> node</span> (weize2oucyzb9rcbmebx4amxz</span>) is now a manager.</span></span>
</span>
To</span> add</span> a</span> worker</span> to</span> this</span> swarm,</span> run</span> the</span> following</span> command:</span></span>
</span>
    docker</span> swarm</span> join</span> -</span>-token</span> SWMTKN-1-02cdwgs8mhu5mm9c20z4y1gzaou4de4n8gtkxi1afmq4ozogqs-38g6tm7oe2v9g1mepwrhj4qab</span> 10.0.0.246:2377</span></span>
</span>
To</span> add</span> a</span> manager</span> to</span> this</span> swarm,</span> run</span> '</span>docker swarm join-token manager</span>'</span> and</span> follow</span> the</span> instructions.</span></span></code></pre>
可以在其他机器上执行这个 docker swarm join</code> 命令，将其他机器以 worker 身份加入到该 swarm 集群中，如果你忘记了，可以通过以下命令查看：</p>

docker swarm join-token manager</code>： 查询以 manager 节点身份到当前 swarm 用的命令</li>
docker swarm join-token worker</code>： 查询以 worker 节点身份到当前 swarm 用的命令</li>
</ul>

这些 swarm、worker、manager 等概念可以参考 Docker Swarm 官方文档，但注意不要陷进太多细节中，先按照我的提示说明操作跑起来再去了解这些细节也不迟。</p>
</blockquote>
执行上面提示的命令，将其他机器加入到 swarm 集群:</p>
~</span>   docker swarm join --token SWMTKN-1-02cdwgs8mhu5mm9c20z4y1gzaou4de4n8gtkxi1afmq4ozogqs-38g6tm7oe2v9g1mepwrhj4qab 10.0.0.246:2377</span></span>
This</span> node</span> joined</span> a</span> swarm</span> as</span> a</span> worker.</span></span></code></pre>
然后在 manager</code> 节点上执行 docker node ls</code> 可以查看到当前 swarm 集群中的节点信息(带 * 的表示当前节点)：</p>
~</span>   docker node ls</span></span>
ID</span>                            HOSTNAME</span>                 STATUS</span>    AVAILABILITY</span>   MANAGER</span> STATUS</span>   ENGINE</span> VERSION</span></span>
weize2oucyzb9rcbmebx4amxz</span> *</span>   vm1</span>                      Ready</span>     Active</span>         Leader</span>           25.0.0</span></span>
331o8d403cl0t8c7kjtd5c8qx</span>     vm2</span>                      Ready</span>     Active</span>                          25.0.0</span></span></code></pre>
然后我们就可以在 manager</code> 节点创建一个 overlay</code> 网络了：</p>
docker</span> network</span> create</span> -</span>-driver</span> overlay</span> -</span>-subnet=172.10.0.0/16</span> -</span>-attachable</span> pxc_net_overlay</span></span></code></pre>
相较于之前创建的 pxc_net</code> 网络，这里多了一个 --driver overlay</code> 参数，表示创建一个 overlay</code> 网络，overlay</code> 网络是 swarm</code> 模式下的网络，可以跨机器通信，但他默认限制了只有通过 docker swarm 创建的容器才能加入到该网络中，所以我们需要在创建容器时增加 --attachable</code> 参数，表示允许通过 docker run</code> 命令将容器加入到该网络中。</p>
然后在新建 PXC</code> 节点容器时，使用 --net=pxc_net_overlay</code> 指定使用 pxc_net_overlay</code> 网络，这样就可以跨机器通信了，步骤和之前在单机多节点一样，这里不再赘述。</p>
PXC 8.0 流量加密</h2>
PXC 8.0 有个比较大的区别是默认开启了 pxc-encrypt-cluster-traffic=ON</code></strong></a>，这表示默认使用加密方式进行流量传输，需要配置下证书或者关闭这个选项。</p>
流量加密</h3>
1. 需要先创建证书，如：</strong></p>
mkdir</span> -</span>m</span> 777</span> -</span>p</span> ./cert</span></span>
docker</span> run</span> -</span>-name</span> pxc-cert</span> -</span>-rm</span> -</span>v</span> ./cert/:/cert/</span> percona/percona-xtradb-cluster:8.0</span> mysql_ssl_rsa_setup</span> -</span>d</span> /cert/</span></span></code></pre>
这样会生成证书在 ./cert/</code> 目录下：</p>
-rw-------</span> 1</span> 1001</span> 1001</span> 1679</span>  4月23日</span> 20:56</span> ca-key.pem</span></span>
-rw-r--r--</span> 1</span> 1001</span> 1001</span> 1115</span>  4月23日</span> 20:56</span> ca.pem</span></span>
-rw-r--r--</span> 1</span> 1001</span> 1001</span> 1115</span>  4月23日</span> 20:56</span> client-cert.pem</span></span>
-rw-------</span> 1</span> 1001</span> 1001</span> 1675</span>  4月23日</span> 20:56</span> client-key.pem</span></span>
-rw-------</span> 1</span> 1001</span> 1001</span> 1675</span>  4月23日</span> 20:56</span> private_key.pem</span></span>
-rw-r--r--</span> 1</span> 1001</span> 1001</span>  451</span>  4月23日</span> 20:56</span> public_key.pem</span></span>
-rw-r--r--</span> 1</span> 1001</span> 1001</span> 1115</span>  4月23日</span> 20:56</span> server-cert.pem</span></span>
-rw-------</span> 1</span> 1001</span> 1001</span> 1679</span>  4月23日</span> 20:56</span> server-key.pem</span></span></code></pre>
2. 创建一个配置文件 ssl.cnf</code>，内容如下：</strong></p>
[</span>mysqld</span>]</span></span>
ssl-ca</span> =</span> /cert/ca.pem</span></span>
ssl-cert</span> =</span> /cert/server-cert.pem</span></span>
ssl-key</span> =</span> /cert/server-key.pem</span></span>
</span>
[</span>client</span>]</span></span>
ssl-ca</span> =</span> /cert/ca.pem</span></span>
ssl-cert</span> =</span> /cert/client-cert.pem</span></span>
ssl-key</span> =</span> /cert/client-key.pem</span></span>
</span>
[</span>sst</span>]</span></span>
encrypt</span> =</span> 4</span></span>
ssl-ca</span> =</span> /cert/ca.pem</span></span>
ssl-cert</span> =</span> /cert/server-cert.pem</span></span>
ssl-key</span> =</span> /cert/server-key.pem</span></span></code></pre>

将配置文件和证书放到节点目录下，然后启动时挂载到容器中：</li>
</ol>
mkdir</span> -</span>p</span> ./node1/{data,conf.d,cluster.conf.d,cert}</span> #</span> 这里多了一个 cert 目录</span></span>
cp</span> ./cert/</span>*</span> ./node1/cert/</span>                          #</span> 假设第一步生成的证书在 ./cert/ 目录下，复制到节点的 cert 目录下</span></span>
cp</span> ./ssl.cnf</span> ./node1/conf.d/ssl.cnf</span>                #</span> 将配置文件复制到节点的 conf.d 目录下</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node1</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node1</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>-ip=172.10.0.101</span> \</span></span>
    -</span>p</span> 9000:3306</span> \</span></span>
    -</span>v</span> ./node1/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node1/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node1/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>v</span> ./node1/cert/:/cert/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> DISCOVERY_SERVICE=pxc-etcd:2379</span> \</span></span>
    percona/percona-xtradb-cluster:8.0</span></span>
docker</span> logs</span> -</span>f</span> node1</span></span></code></pre>

再启动其他节点，如 node2 和 node3，同样需要将证书和配置文件放到节点目录下，然后启动时挂载到容器中。</li>
</ol>

注意：集群内的节点需使用同一份证书，不能每个节点单独生成证书。</p>
</blockquote>
node2:</p>
mkdir</span> -</span>p</span> ./node2/{data,conf.d,cluster.conf.d,cert}</span> #</span> 这里多了一个 cert 目录</span></span>
cp</span> ./cert/</span>*</span> ./node2/cert/</span>                          #</span> 假设第一步生成的证书在 ./cert/ 目录下，复制到节点的 cert 目录下</span></span>
cp</span> ./ssl.cnf</span> ./node2/conf.d/ssl.cnf</span>                #</span> 将配置文件复制到节点的 conf.d 目录下</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node2</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node2</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>-ip=172.10.0.102</span> \</span></span>
    -</span>p</span> 9001:3306</span> \</span></span>
    -</span>v</span> ./node2/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node2/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node2/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>v</span> ./node2/cert/:/cert/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> DISCOVERY_SERVICE=pxc-etcd:2379</span> \</span></span>
    percona/percona-xtradb-cluster:8.0</span></span>
docker</span> logs</span> -</span>f</span> node2</span></span></code></pre>
node3:</p>
mkdir</span> -</span>p</span> ./node3/{data,conf.d,cluster.conf.d,cert}</span> #</span> 这里多了一个 cert 目录</span></span>
cp</span> ./cert/</span>*</span> ./node3/cert/</span>                          #</span> 假设第一步生成的证书在 ./cert/ 目录下，复制到节点的 cert 目录下</span></span>
cp</span> ./ssl.cnf</span> ./node3/conf.d/ssl.cnf</span>                #</span> 将配置文件复制到节点的 conf.d 目录下</span></span>
chown</span> -</span>R</span> 1001:1001</span> ./node3</span></span>
docker</span> run</span> -</span>d</span> -</span>-name=node3</span> \</span></span>
    -</span>-net=pxc_net</span> \</span></span>
    -</span>-ip=172.10.0.103</span> \</span></span>
    -</span>p</span> 9002:3306</span> \</span></span>
    -</span>v</span> ./node3/cluster.conf.d/:/etc/percona-xtradb-cluster.conf.d</span> \</span></span>
    -</span>v</span> ./node3/data/:/var/lib/mysql/</span> \</span></span>
    -</span>v</span> ./node3/conf.d/:/etc/mysql/conf.d/</span> \</span></span>
    -</span>v</span> ./node3/cert/:/cert/</span> \</span></span>
    -</span>e</span> MYSQL_ROOT_PASSWORD=</span>'</span>8e7T8SPEsU#iDq*fgt</span>'</span> \</span></span>
    -</span>e</span> TZ=Asia/Shanghai</span> \</span></span>
    -</span>e</span> CLUSTER_NAME=pxc-cluster1</span> \</span></span>
    -</span>e</span> DISCOVERY_SERVICE=pxc-etcd:2379</span> \</span></span>
    percona/percona-xtradb-cluster:8.0</span></span>
docker</span> logs</span> -</span>f</span> node3</span></span></code></pre>

可以通过命令查看流量加密是否开启：</li>
</ol>
mysql</span>></span> show variables </span>like</span> '</span>pxc_encrypt_cluster_traffic</span>'</span>;</span></span>
+</span>--</span>---------------------------+-------+</span></span>
| Variable_name               | </span>Value</span> |</span></span>
+</span>--</span>---------------------------+-------+</span></span>
| pxc_encrypt_cluster_traffic | </span>ON</span>    |</span></span>
+</span>--</span>---------------------------+-------+</span></span>
1</span> row</span> in</span> set</span> (</span>0</span>.</span>00</span> sec)</span></span></code></pre>关闭流量加密</h3>
关闭流量加密需要在配置文件中添加 pxc-encrypt-cluster-traffic=OFF</code>，如：</p>
[</span>mysqld</span>]</span></span>
pxc-encrypt-cluster-traffic</span>     =</span> OFF</span></span></code></pre>

注意：关闭流量加密可能会导致数据泄露，不建议在生产环境中关闭流量加密。且如果关闭所有节点都需要关闭，否则会导致节点之间无法通信。</p>
</blockquote>
PXC 集群原理</h2>
PXC 中重要端口</h3>

3306</code>: 数据库对外服务的端口号</li>
4444</code>: 请求 SST(State Snapshot Transfer 全量同步)，在新节点加入时起做用来同步所有数据。</li>
4567</code>: 组成员之间沟通的端口</li>
4568</code>: 传输 IST(Incremental State Transfer 增量同步)，节点下线，重启加入时同步缺失的部分数据。</li>
</ul>
PXC 中集群的状态</h3>
可通过命令查看集群状态:</p>
show </span>status</span> like</span> '</span>wsrep_cluster_status</span>'</span>;</span></span></code></pre>PXC 中集群节点的状态</h3>
可通过命令查看节点状态:</p>
show </span>status</span> like</span> '</span>wsrep_local_state_comment</span>'</span>;</span></span></code></pre>

open</code>：节点启动成功，尝试连接到集群。</li>
primary</code>：节点已在集群中，在新节点加入集群时，选取 donor 进行数据同步时会产生式的状态。</li>
joiner</code>：节点处于等待接收同步数据文件的状态。</li>
joined</code>：节点已完成了数据同步，尝试保持和集群中其它节点进度一致。</li>
synced</code>：节点正常提供服务的状态，表示已经同步完成并和集群进度保持一致。</li>
donor</code>：节点处于为新加入节点提供全量数据时的状态。</li>
</ul>
如何选择 donor 节点</h3>
官方提供了一篇博客来解释如何选择 donor 节点：Understanding how an IST donor is selected</a></p>
简单总结下：</p>

所有节点在其 gcache</code> 中保留一些写入集合作为缓存。</li>
当一个节点需要重新加入集群时，它需要与集群状态进行重新同步。</li>
重新加入的节点将检查当前集群的最新状态，确定自己需要的写入集合范围。</li>
节点开始寻找潜在的 DONOR，如果一个节点的范围包含所需的写入集合范围，则该节点可以作为DONOR。</li>
如果没有找到合适的DONOR节点，重启的节点将采用全量状态传输（SST）来与集群重新同步。</li>
</ol>
还有一篇个人的博客可以参考下: Percona XtraDB Cluster 5.6 寻找合适的 IST 捐赠者</a></p>

docker compose 2.21.0 以上版本可能存在无法自动发现 swarm overlay 网络的问题，需要安装旧版本，查看当前源所有版本命令 sudo apt list -a docker-compose-plugin</code>，安装指定版本 sudo apt install docker-compose-plugin=2.21.0-1~debian.12~bookworm -y</code></p>
</blockquote>
参考</h2>

Percona XtraDB Cluster 官方文档 5.7</a></li>
Percona XtraDB Cluster 官方文档 8.0</a></li>
PXC 集群使用 - 个人博客</a></li>
mysql pxc集群 原理</a></li>
Understanding how an IST donor is selected</a></li>
Percona XtraDB Cluster 5.6 寻找合适的 IST 捐赠者</a></li>
</ul>


Linux 三剑客之 awk 命令
2024-04-18T19:24:00+08:00
今天来简单说下 linux 三剑客之一 awk</code>, 概念这里不再赘述，直接看示例：</p>
如果熟悉，只是来看下总结，可点击这里</a>.</p>
语法格式：</p>
awk</span> [options</span>] </span>'</span>script</span>'</span> var</span>=</span>v</span>a</span>l</span>u</span>e</span> file(s</span>)</span></span></code></pre>测试文件</h2>
先创建两个测试文件：</p>
class1.txt</code>:</p>
zhaoyun</span> 85</span> 87</span></span>
guanyu</span> 87</span> 88</span></span>
liubei</span> 90</span> 86</span></span></code></pre>
class2.txt</code>:</p>
caocao</span> 92</span> 87</span> 90</span></span>
guojia</span> 99</span> 96</span> 92</span></span></code></pre>1. 打印内容的第一列</h2>
打印文件的第一列，使用 awk</code> 的 print</code> 函数，$1</code> 表示第一列</p>
$</span> awk</span> '</span>{print $1}</span>'</span> class1.txt</span></span>
zhaoyun</span> 85</span></span></code></pre>2. 打印多列</h2>
比如我们想打印文件的第一列和第三列，可以这样写：</p>
$</span> awk</span> '</span>{print $1, $3}</span>'</span> class1.txt</span></span>
zhaoyun</span> 87</span></span>
guanyu</span> 88</span></span>
liubei</span> 86</span></span></code></pre>3. 打印首列和末列</h2>

首列可以使用 $1</code> 表示</li>
末列可以使用 $NF</code> 表示，NF 表示目前的记录被分割的字段的数目，NF 可以理解为 Number of Field</em>。</li>
</ul>
$</span> awk</span> '</span>{print $1,$NF}</span>'</span> class1.txt</span></span>
zhaoyun</span> 87</span></span>
guanyu</span> 88</span></span>
liubei</span> 86</span></span></code></pre>4. 打印倒数第 N 列</h2>
如果我们想打印倒数第二列，可以这样写：</p>
$</span> awk</span> '</span>{print $(NF-1)}</span>'</span> class1.txt</span></span>
85</span></span>
87</span></span>
90</span></span></code></pre>5. 打印行号</h2>
打印行号，使用 NR</code> 变量，如：</p>
$</span> awk</span> '</span>{print NR, $0}</span>'</span> class1.txt</span></span>
1</span> zhaoyun</span> 85</span> 87</span></span>
2</span> guanyu</span> 87</span> 88</span></span>
3</span> liubei</span> 90</span> 86</span></span></code></pre>

NR</code> Number of Records</em> 表示行号，注意前面没有 $</code> 符号, 如果加了 $NR</code> 表示第 NR</code> 列。</li>
$0</code> 表示整行内容。</li>
</ul>
如果我们想要在行号后加个点呢，可以这样写：</p>
$</span> awk</span> '</span>{print NR".", $0}</span>'</span> class1.txt</span></span>
1.</span> zhaoyun</span> 85</span> 87</span></span>
2.</span> guanyu</span> 87</span> 88</span></span>
3.</span> liubei</span> 90</span> 86</span></span></code></pre>6. 指定分隔符</h2>
awk 默认是以空格分隔，如果是其他分隔符，可以使用 -F</code> 参数指定，如以逗号分隔(先手动修改下之前的 class1.txt 为逗号分割)：</p>
awk</span> -</span>F,</span> '</span>{print $1}</span>'</span> class1.txt</span></span>
awk</span> -</span>F</span> ,</span> '</span>{print $1}</span>'</span> class1.txt</span></span>
awk</span> -</span>F</span> '</span>,</span>'</span> '</span>{print $1}</span>'</span> class1.txt</span></span></code></pre>
上面三种写法都行, 还能用指定内置变量 FS</code> 来指定分隔符，如：</p>
awk</span> -</span>v</span> FS=,</span> '</span>{print $1}</span>'</span> class1.txt</span></span></code></pre>7. 分别指定输入和输出分隔符</h2>
前面我们指定的分隔符是输入分隔符，输出默认还是空格，如果我们想指定输出分隔符，可以指定内置变量 OFS</code>，如：</p>
awk</span> -</span>v</span> FS=,</span> -</span>v</span> OFS=-</span> '</span>{print $1, $2}</span>'</span> class1.txt</span></span></code></pre>
这样输入分隔符是 ,</code> 输出分隔符是 -</code></p>
8. 多文件行号独立</h2>
对于多个文件，如果直接使用之前的 NR</code> 变量，每个文件的行号是连续的，如：</p>
$</span> awk</span> '</span>{print NR, $0}</span>'</span> class1.txt</span> class2.txt</span></span>
1</span> zhaoyun</span> 85</span> 87</span>                                                        </span></span>
2</span> guanyu</span> 87</span> 88</span>                                                         </span></span>
3</span> liubei</span> 90</span> 86</span>                                                         </span></span>
4</span> caocao</span> 92</span> 87</span> 90</span>                                                      </span></span>
5</span> guojia</span> 99</span> 96</span> 92</span></span></code></pre>
想要独立行号，可以使用 FNR</code> 变量，如：</p>
$</span> awk</span> '</span>{print FNR, $0}</span>'</span> class1.txt</span> class2.txt</span></span>
1</span> zhaoyun</span> 85</span> 87</span>                                                                                                   </span></span>
2</span> guanyu</span> 87</span> 88</span>                                                                                                    </span></span>
3</span> liubei</span> 90</span> 86</span>                                                                                                    </span></span>
1</span> caocao</span> 92</span> 87</span> 90</span></span>
2</span> guojia</span> 99</span> 96</span> 92</span></span></code></pre>9. 输出文件名</h2>
如果在上面那个的基础上，想要输出文件名，可以使用内置变量 FILENAME</code>，如：</p>
$</span> awk</span> '</span>{print FILENAME, FNR, $0}</span>'</span> class1.txt</span> class2.txt</span></span>
class1.txt</span> 1</span> zhaoyun</span> 85</span> 87</span>                                                                                                  </span></span>
class1.txt</span> 2</span> guanyu</span> 87</span> 88</span>                                                                                                   </span></span>
class1.txt</span> 3</span> liubei</span> 90</span> 86</span>                                                                                                   </span></span>
class2.txt</span> 1</span> caocao</span> 92</span> 87</span> 90</span>                                                                                                </span></span>
class2.txt</span> 2</span> guojia</span> 99</span> 96</span> 92</span> </span></span></code></pre>10. 前置后置操作</h2>
还是刚才那个例子，如果我们想在内容前后输出点内容，那么可以使用 BEGIN</code> 和 END</code> 操作符，如：</p>
$</span> awk</span> '</span>BEGIN{print "start"} {print FNR, $1, $2, $3} END{print "end"}</span>'</span> class1.txt</span> class2.txt</span></span>
start</span>          </span></span>
1</span> zhaoyun</span> 85</span> 87</span></span>
2</span> guanyu</span> 87</span> 88</span> </span></span>
3</span> liubei</span> 90</span> 86</span></span>
1</span> caocao</span> 92</span> 87</span></span>
2</span> guojia</span> 99</span> 96</span></span>
end</span></span></code></pre>
比如用 NR</code> 组合 End</code> 就可以统计一个文件的行数：</p>
$</span> awk</span> '</span>END {print NR}</span>'</span> class1.txt</span></span>
3</span></span></code></pre>11. 文件级的前置后置操作</h2>
如果想要在每个文件开始读取和读取结束时执行一些操作，可以使用 BEGINFILE</code> 和 ENDFILE</code> 操作符，如用来统计每个文件的行数：</p>
$</span> awk</span> '</span>BEGINFILE{print "文件:", FILENAME} ENDFILE{print "行数:", FNR}</span>'</span> class1.txt</span> class2.txt</span></span>
文件:</span> class1.txt</span></span>
行数:</span> 3</span></span>
文件:</span> class2.txt</span></span>
行数:</span> 2</span></span></code></pre>

BEGINFILE</code> 和 ENDFILE</code> 操作符是 gawk 特有的，其他版本可能不支持。</p>
</blockquote>
12. 接收外部变量</h2>
如果我们想要在 awk</code> 脚本中接收外部变量，比如变量声明输出分隔符，可以使用 -v</code> 参数，如：</p>
$</span> var1=</span>"</span>_</span>"</span></span>
$</span> awk</span> -</span>v</span> OFS=</span>$</span>var1</span> '</span>{print $1, $2, $3}</span>'</span> class1.txt</span></span>
zhaoyun_85_87</span></span>
guanyu_87_88</span></span>
liubei_90_86</span></span></code></pre>13. 判断条件</h2>
如果我们想要在 awk</code> 中加入判断条件，可以使用 if</code> 语句，如只输出第 2-3 行：</p>
awk</span> '</span>{if (NR == 2 || NR == 3) print $0}</span>'</span> class1.txt</span></span></code></pre>总结</h2>
参数</h3>

-F</code>: 指定分隔符, 默认是空格, 也可以使用内置变量 FS</code> 来指定分隔符, 如 -v FS=,</code></li>
</ul>
变量</h3>

$0</code>: 表示整行内容</li>
$1</code>: 第一列</li>
NR</code>：Number of Records, 表示行号</li>
$NR</code>: 前面加上了 $</code> 符号，表示第 NR</code> 行</li>
NF</code>: Number of Fields, 表示目前的记录被分割的字段的数目</li>
$NF</code>: 前面加上了 $</code> 符号，表示最后一列</li>
FNR</code>: File Number of Records, 表示当前文件的行号, 多文件时行号独立</li>
FILENAME</code>: 当前输入文件的名称</li>
FS</code>: Field Separator, 输入分隔符</li>
OFS</code>: Output Field Separator, 输出分隔符</li>
</ul>


Percona Monitoring and Management (PMM) 安装与配置
2024-04-15T19:41:00+08:00
PMM 全称是 Percona Monitoring and Management，是一个开源的数据库监控工具，支持 MySQL、MariaDB、MongoDB、PostgreSQL 等数据库，提供了丰富的监控指标、图表、报警等功能。</p>
官方文档：https://docs.percona.com/percona-monitoring-and-management/index.html</p>
PMM 中分为 PMM Server 和 PMM Client 两部分，PMM Server 用于存储监控数据并提供页面展示，PMM Client 用于采集监控数据。</p>
1. 安装 pmm-server</h2>
v</span>ersion</span>:</span> '</span>3</span>'</span></span>
s</span>ervices</span>:</span></span>
  p</span>mm-server</span>:</span></span>
    i</span>mage</span>:</span> p</span>ercona/pmm-server:2</span></span>
    c</span>ontainer_name</span>:</span> p</span>mm-server</span></span>
    h</span>ostname</span>:</span> p</span>mm-server</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    v</span>olumes</span>:</span></span>
      -</span> .</span>/srv:/srv</span></span>
    e</span>nvironment</span>:</span></span>
      -</span> G</span>F_SMTP_ENABLED=true</span></span>
      -</span> G</span>F_SMTP_HOST=smtp.qq.com:465</span></span>
      -</span> G</span>F_SMTP_USER=example@qq.com</span></span>
      -</span> G</span>F_SMTP_PASSWORD=password</span></span>
      -</span> G</span>F_SMTP_SKIP_VERIFY=false</span></span>
      -</span> G</span>F_SMTP_FROM_ADDRESS=example@qq.com</span></span>
      -</span> G</span>F_SMTP_FROM_NAME=Percona Alerting</span></span>
    p</span>orts</span>:</span></span>
      -</span> 8</span>0:80</span></span>
      -</span> 4</span>43:443</span></span></code></pre>
安装完成后，访问 https://<pmm_server_ip>/</code>，输入用户名 admin</code> 和密码 admin</code> 登录。登录后会提示修改密码，修改完成后即可进入监控页面。如果你想使用脚本自动修改密码，可以使用以下命令：</p>
docker</span> exec</span> -</span>t</span> pmm-server</span> change-admin-password</span> <</span>new_passwor</span>d</span>></span></span></code></pre>
其中 <new_password></code> 为你要修改的新密码，pmm-server 为你的容器名称。</p>

安装时还可配置是否禁止自动检测更新，数据保留时间，日志级别，Grafana 参数等，详细可参考 https://docs.percona.com/percona-monitoring-and-management/setting-up/server/docker.html#environment-variables</p>
</blockquote>
2. 创建 API 密钥</h2>
访问后点击左侧导航 -> Configuration</code> -> API Keys</code> 或直接访问 https://<pmm_server_ip>/graph/org/apikeys 可进入 API 密钥配置页面，这样可以使你修改 PMM Server 登录账号密码时无需再去修改 PMM Client 上的配置。</p>
创建一个 Admin 权限的密钥，名称和过期时间自己根据情况填写，然后复制生成的 Key</p>
详细可参考：https://docs.percona.com/percona-monitoring-and-management/details/api.html#authenticate</p>

注意，目前 PMM 不支持 Service Account 认证方式</a>，注意不要将 API Keys 迁移到 Service Account.</p>
</blockquote>
3. 安装 pmm-client</h2>
v</span>ersion</span>:</span> '</span>3</span>'</span></span>
s</span>ervices</span>:</span></span>
  p</span>mm-client</span>:</span></span>
    i</span>mage</span>:</span> p</span>ercona/pmm-client:2</span></span>
    c</span>ontainer_name</span>:</span> p</span>mm-client</span></span>
    h</span>ostname</span>:</span> p</span>mm-client</span>                                  #</span> 如果你需要部署多个 pmm-client，推荐这里修改为更具辨识度的名字</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    e</span>nvironment</span>:</span></span>
      -</span> P</span>MM_AGENT_SERVER_ADDRESS={{pmm_server_ip:port}}</span>   #</span> 注意这里要替换为 pmm_server 的地址</span></span>
      -</span> P</span>MM_AGENT_SERVER_USERNAME=api_key</span>                 #</span> 如果使用 api key 则这里写 api_key, 如果使用 service account 则这里写 account name</span></span>
      -</span> P</span>MM_AGENT_SERVER_PASSWORD=eyJrIjoiaEo4VklQR01qNFIxOTJnRkhkMHZFZjhIVE42Sm1lYjkiLCJuIjoidG9rZW4iLCJpZCI6MX0=</span>  #</span> 这里写生成的 key</span></span>
      -</span> P</span>MM_AGENT_SERVER_INSECURE_TLS=1</span>                   #</span> 跳过 PMM 服务器 TLS 证书验证。</span></span>
      -</span> P</span>MM_AGENT_SETUP=1</span></span>
      -</span> P</span>MM_AGENT_CONFIG_FILE=config/pmm-agent.yaml</span></span>
    v</span>olumes</span>:</span></span>
      -</span> .</span>/srv:/srv</span></span>
    n</span>etworks</span>:</span></span>
      p</span>xc_net_overlay</span>:</span>                                    #</span> 这里推荐先将 pmm-client 加入到 mysql 容器所在网络, 方便一会使用</span></span>
        </span></span>
n</span>etworks</span>:</span></span>
  p</span>xc_net_overlay</span>:</span></span>
    n</span>ame</span>:</span> p</span>xc_net_overlay</span></span>
    e</span>xternal</span>:</span> true</span></span>
    d</span>river</span>:</span> o</span>verlay</span></span></code></pre>
文档</a>中有许多 pmm-admin 开头的命令，由于我们的 pmm-client</code> 是安装在 docker 容器中的所以需要加个前缀 docker exec pmm-client</code>。</p>
如查看 pmm-client</code> 运行状态：docker exec pmm-client pmm-admin status</code></p>
4. pmm-server 验证 pmm-client 添加是否成功</h2>
添加 pmm-client</code> 后可以在页面上点击左侧导航 -> Configuration</code> -> Inventory</code> -> Nodes</code> 或直接访问 https://<pmm_server_ip>/graph/inventory/nodes 可以看到添加的 pmm-client</code>。</p>
5. 向 pmm-client 注册 MySQL 服务</h2>
添加专有用户</h3>
在你要被监控的 MySQL 服务上创建一个专用的用户：</p>
CREATE</span> USER</span> '</span>pmm</span>'</span>@</span>'</span>127.0.0.1</span>'</span> IDENTIFIED</span> BY</span> '</span>pass</span>'</span> WITH</span> MAX_USER_CONNECTIONS</span> 10</span>;</span></span>
GRANT</span> SELECT,</span> PROCESS,</span> REPLICATION</span> CLIENT,</span> RELOAD,</span> BACKUP_ADMIN</span> ON</span> *</span>.</span>*</span> TO</span> '</span>pmm</span>'</span>@</span>'</span>127.0.0.1</span>'</span>;</span></span></code></pre>
上面的命令是创建一个名为 pmm</code> 的用户，密码为 pass</code>，授予允许 127.0.0.1</code> 这个 ip 访问。不过由于我们使用 docker，需要将允许访问的 ip 修改为 pmm-client 容器访问 MySQL 时 pmm-client 的 ip，如果确认网络环境安全，也可使用 % 授予所有 ip。</p>
向 PMM 服务端注册 MySQL 服务</h3>
使用 perfschema</code> 监控模式，在 pmm-client</code> 上执行：</p>
docker</span> exec</span> pmm-client</span> pmm-admin</span> add</span> mysql</span> -</span>-username=pmm</span> -</span>-password=</span>'</span>pass</span>'</span> -</span>-query-source=perfschema</span> <</span>mysql_server_nam</span>e</span>></span> <</span>mysql_ip:mysql_por</span>t</span>></span></span></code></pre>
使用 slowlog</code> 监控模式，在 pmm-client</code> 上执行：</p>
docker</span> exec</span> pmm-client</span> pmm-admin</span> add</span> mysql</span> -</span>-username=pmm</span> -</span>-password=</span>'</span>pass</span>'</span> -</span>-query-source=slowlog</span> -</span>-size-slow-logs=-1GiB</span> <</span>mysql_server_nam</span>e</span>></span> <</span>mysql_ip:mysql_por</span>t</span>></span></span></code></pre>
关于两种模式的区别和更详细的参数可参考：https://docs.percona.com/percona-monitoring-and-management/setting-up/client/mysql.html</p>
添加成功后会提示：</p>
MySQL</span> Service</span> added.</span></span>
Service</span> ID</span>  :</span> /service_id/89eb3bb2-5d06-44ac-b404-dee9054a47d6</span></span>
Service</span> name:</span> mysql_server_name</span></span>
</span>
Table</span> statistics</span> collection</span> enabled</span> (the</span> limit</span> is</span> 1000,</span> the</span> actual</span> table</span> count</span> is</span> 349</span>).</span></span></code></pre>
然后就能在 pmm-server</code> 仪表盘中点击左侧 MySQL 的 logo 看到监控的数据了，或者直接访问 https://<pmm_server_ip>/graph/d/mysql-instance-overview/mysql-instances-overview</p>
6. 其他相关命令</h2>
6.1 查看 pmm-client 版本</h3>
docker</span> exec</span> pmm-client</span> pmm-admin</span> version</span></span></code></pre>6.2 查看 pmm-client 状态</h3>
docker</span> exec</span> pmm-client</span> pmm-admin</span> status</span></span></code></pre>6.3 查看当前 pmm-client 监控的服务</h3>
docker</span> exec</span> pmm-client</span> pmm-admin</span> inventory</span> list</span> services</span></span></code></pre>6.4 查看当前 pmm-client 监控的 MySQL 服务</h3>
docker</span> exec</span> pmm-client</span> pmm-admin</span> inventory</span> list</span> services</span> -</span>-service-type=mysql</span></span></code></pre>6.5 从 pmm-client 中删除服务</h3>
docker</span> exec</span> pmm-client</span> pmm-admin</span> remove</span> <</span>service-typ</span>e</span>></span> <</span>service-nam</span>e</span>></span></span></code></pre>6.6 从 pmm-server 中删除当前 pmm-client</h3>
docker</span> exec</span> pmm-client</span> pmm-admin</span> unregister</span></span></code></pre>

这需要确保没有任何服务在监控中，或者增加 --force</code> 参数强制删除所有服务。</p>
</blockquote>
7. pmm-server 报警</h2>
这里介绍下如何配置 SMTP 来发送 Email 邮件，发件配置需要在 pmm-server 启动时增加环境变量来配置发信源，如：</p>
v</span>ersion</span>:</span> '</span>3</span>'</span></span>
s</span>ervices</span>:</span></span>
  p</span>mm-server</span>:</span></span>
    i</span>mage</span>:</span> p</span>ercona/pmm-server:2</span></span>
    c</span>ontainer_name</span>:</span> p</span>mm-server</span></span>
    h</span>ostname</span>:</span> p</span>mm-server</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    v</span>olumes</span>:</span></span>
      -</span> .</span>/srv:/srv</span></span>
    e</span>nvironment</span>:</span></span>
      -</span> G</span>F_SMTP_ENABLED=true</span></span>
      -</span> G</span>F_SMTP_HOST=smtp.qq.com:465</span></span>
      -</span> G</span>F_SMTP_USER=example@qq.com</span></span>
      -</span> G</span>F_SMTP_PASSWORD=password</span></span>
      -</span> G</span>F_SMTP_SKIP_VERIFY=false</span></span>
      -</span> G</span>F_SMTP_FROM_ADDRESS=example@qq.com</span></span>
      -</span> G</span>F_SMTP_FROM_NAME=Percona Alerting</span></span>
    p</span>orts</span>:</span></span>
      -</span> 8</span>0:80</span></span>
      -</span> 4</span>43:443</span></span></code></pre>
以下是上述每个环境变量的描述：</p>

GF_SMTP_ENABLED</code>：是否启用 Grafana 的 SMTP 电子邮件通知。</li>
GF_SMTP_HOST</code>：SMTP 服务器的主机地址和端口。</li>
GF_SMTP_USER</code>：SMTP 用户名。</li>
GF_SMTP_PASSWORD</code>: SMTP 密码</li>
GF_SMTP_SKIP_VERIFY</code>：如果为 true，则验证 SMTP 服务器的 SSL。</li>
GF_SMTP_FROM_ADDRESS</code>：发送电子邮件时使用的电子邮件地址。</li>
GF_SMTP_FROM_NAME</code>：发送电子邮件时使用的名称。</li>
</ul>
邮件接收人可以在左侧导航 -> Alerting</code> -> Contact points</code> 中使用 grafana-default-email</code> 或新建一个 Email</code> 类型的 contact point</code>。</p>
更多的报警配置详见：https://docs.percona.com/percona-monitoring-and-management/get-started/alerting.html#configure-email-smtp-server-settings</p>
8. pmm-server 备份</h2>
pmm-server</code> 还可以在页面上使用手动或计划任务的方式将数据库备份到 S3/本地存储，不过可惜的是需要 MySQL Server 和 PMM-Client 直接运行在宿主机上，不能是 Docker 容器中（因为备份使用的是 Xtrabackup</a>，它需要直接读取 MySQL 数据目录，即 /var/lib/mysql</code>）。
详细先决条件见：https://docs.percona.com/percona-monitoring-and-management/get-started/backup/mysql_prerequisites.html</p>


使用 Nginx Stream 模块来实现 sniproxy
2024-04-09T20:24:00+08:00
之前写过一篇使用 sniproxy</a> 这个软件来实现免证书代理 https 网站用来做到对某些资源加速访问的作用，不过现在这个项目已经不更新</a>了，不过好在 nginx 通过 stream 模块也能支持同样的功能，这里来介绍下使用方式。</p>
nginx 启用相应模块</h2>
我这里的 nginx 使用 docker 方式来部署，其他方式部署的也类似，这里对 nginx 有些要求，需要编译时包含 –with-stream –with-stream_ssl_preread_module –with-stream_ssl_module</code>，可以使用 nginx -V</code> 命令来查看编译时是否包含，我这里使用 nginx:alpine</a> 镜像，已经默认包含了这些模块。</p>
部署 nginx (docker)</h2>
docker</h3>
docker</span> run</span> -</span>d</span> -</span>-name</span> nginx-sniproxy</span> -</span>p</span> 443:443</span> -</span>-restart</span> always</span> -</span>v</span> $(</span>pwd</span>)</span>/nginx.conf:/etc/nginx/nginx.conf</span> nginx:alpine</span></span></code></pre>docker-compose</h3>
v</span>ersion</span>:</span> '</span>3.7</span>'</span></span>
</span>
s</span>ervices</span>:</span></span>
  n</span>ginx-sniproxy</span>:</span></span>
    i</span>mage</span>:</span> n</span>ginx:alpine</span></span>
    c</span>ontainer_name</span>:</span> n</span>ginx-sniproxy</span></span>
    p</span>orts</span>:</span></span>
      -</span> "</span>443:443</span>"</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    v</span>olumes</span>:</span></span>
      -</span> .</span>/nginx.conf:/etc/nginx/nginx.conf</span></span></code></pre>
还需要在当前目录放一个 nginx.conf</code>，这个配置下文会介绍。</p>
配置文件</h2>
代理所有域名</h3>
worker_processes 1;</span></span>
</span>
events {</span></span>
    worker_connections 1024;</span></span>
}</span></span>
</span>
stream {</span></span>
    server {</span></span>
        listen 443;</span></span>
        resolver 1.1.1.1;</span></span>
        ssl_preread on;</span></span>
        proxy_pass $ssl_preread_server_name:443;</span></span>
    }</span></span>
}</span></span></code></pre>

这个配置表示允许代理所有域名，也允许任何 IP 访问，这是不安全的，可能被别人白嫖</code>你的服务。</p>
</blockquote>
代理指定域名</h3>
worker_processes 1;</span></span>
</span>
events {</span></span>
    worker_connections 1024;</span></span>
}</span></span>
</span>
stream {</span></span>
    map $ssl_preread_server_name $filtered_sni_name {</span></span>
        ~^(.*fast\.com)$ $ssl_preread_server_name;</span></span>
        default "127.255.255.255";  </span></span>
    }</span></span>
</span>
    server {</span></span>
        resolver 1.1.1.1;</span></span>
        listen 443;</span></span>
        proxy_pass $filtered_sni_name:443;  # 由于这里上面没有指定端口，这里要指定为 443</span></span>
        ssl_preread on;</span></span>
    }</span></span>
}</span></span></code></pre>
这里增加了一组 map，根据规则过滤 $ssl_preread_server_name</code>（也就是请求的 SNI），上面的配置表示允许 fast.com 这个域名使用，然后指向 $ssl_preread_server_name</code>，如果没有匹配到任何规则，则默认为一个本地回环地址，用于访问了未被允许的域名时，返回空。</p>

如果希望和 https 服务共存，可以让 https 使用一个其他端口，如 1443，然后 defualt 改为 127.0.0.1:1443。</p>
</blockquote>
限制只允许指定 ip 使用</h3>
还可以限制指定 ip 使用该服务，在 server</code> 代码块中增加：</p>
server {</span></span>
    resolver 1.1.1.1;</span></span>
    listen 443;</span></span>
    proxy_pass $filtered_sni_name:443;  # 由于这里上面没有指定端口，这里要指定为 443</span></span>
    ssl_preread on;</span></span>
</span>
    deny   192.168.1.2;</span></span>
    allow  192.168.1.1/24;</span></span>
    deny   all;</span></span>
}</span></span></code></pre>
规则从上到下执行，如果有 deny 匹配，则后面所有的 allow 都将无效，上面这个配置的意思是只允许 192.168.1.1/24 这个网段访问，但不包含 192.168.1.2 这个 ip。</p>
扩展-负载均衡</h3>
worker_processes 1;</span></span>
</span>
events {</span></span>
    worker_connections 1024;</span></span>
}</span></span>
</span>
stream {</span></span>
    map $ssl_preread_server_name $filtered_sni_name {</span></span>
        fast.com backend_example;</span></span>
    }</span></span>
</span>
    upstream backend_example {</span></span>
        server fast1.com:443;</span></span>
        server fast2.com:443;</span></span>
    }</span></span>
</span>
    server {</span></span>
        resolver 1.1.1.1;</span></span>
        listen 443;</span></span>
        proxy_pass $filtered_sni_name;</span></span>
        ssl_preread on;</span></span>
    }</span></span>
}</span></span></code></pre>
map 的 value 中不止可以写根据 $ssl_preread_server_name</code> 获取到的 SNI，还可以指定一个 upstream</code>，里面可以写多个地址，进行负载均衡。</p>
还可以指定负载均衡策略：</p>

最少连接负载均衡</li>
</ol>
upstream myapp1 {</span></span>
    least_conn;</span></span>
    server srv1.example.com;</span></span>
    server srv2.example.com;</span></span>
    server srv3.example.com;</span></span>
}</span></span></code></pre>

会话持久化(hash)</li>
</ol>
upstream myapp1 {</span></span>
    ip_hash;</span></span>
    server srv1.example.com;</span></span>
    server srv2.example.com;</span></span>
    server srv3.example.com;</span></span>
}</span></span></code></pre>

指定权重</li>
</ol>
upstream myapp1 {</span></span>
    server srv1.example.com weight=3;</span></span>
    server srv2.example.com;</span></span>
    server srv3.example.com;</span></span>
}</span></span></code></pre>


从 JDK 源码中学习设计模式
2024-02-29T19:28:00+08:00
一、创建型模式</h1>

这类模式提供创建对象的机制， 能够提升已有代码的灵活性和可复用性。</p>
</blockquote>
1. 工厂模式 Factory Pattern</h2>

用来创建对象的设计模式，可以屏蔽对象的创建过程，只需要传入参数即可获取对象。</p>
</blockquote>
JDK Calendar</h3>
import</span> java</span>.</span>util</span>.</span>Calendar</span>;</span></span>
import</span> java</span>.</span>util</span>.</span>Locale</span>;</span></span>
import</span> java</span>.</span>util</span>.</span>TimeZone</span>;</span></span>
</span>
Calendar</span> calendar1</span> =</span> Calendar</span>.</span>getInstance</span>(</span>)</span>;</span></span>
Calendar</span> calendar2</span> =</span> Calendar</span>.</span>getInstance</span>(</span>TimeZone</span>.</span>getTimeZone</span>(</span>"</span>GMT+8</span>"</span>)</span>)</span>;</span></span>
Calendar</span> calendar3</span> =</span> Calendar</span>.</span>getInstance</span>(</span>TimeZone</span>.</span>getTimeZone</span>(</span>"</span>GMT+8</span>"</span>)</span>,</span> Locale</span>.</span>CHINA</span>)</span>;</span></span></code></pre>
可以根据不同的参数来获取不同的 Calendar 子类，如 GregorianCalendar</code>，JapaneseImperialCalendar</code>，BuddhistCalendar</code></p>
2. 构造/建造者模式  Builder Pattern</h2>

用来创建对象的设计模式，可以通过链式调用来设置属性。</p>
</blockquote>
JDK Calendar</h3>
import</span> java</span>.</span>util</span>.</span>Calendar</span>;</span></span>
import</span> java</span>.</span>util</span>.</span>Locale</span>;</span></span>
import</span> java</span>.</span>util</span>.</span>TimeZone</span>;</span></span>
</span>
Calendar</span> calendar</span> =</span> new</span> Calendar</span>.</span>Builder</span>(</span>)</span></span>
        .</span>setTimeZone</span>(</span>TimeZone</span>.</span>getTimeZone</span>(</span>"</span>GMT+8</span>"</span>)</span>)</span></span>
        .</span>setLocale</span>(</span>Locale</span>.</span>CHINA</span>)</span></span>
        .</span>setDate</span>(</span>2020</span>,</span> 0</span>,</span> 1</span>)</span></span>
        .</span>build</span>(</span>)</span>;</span></span></code></pre>
通过内部类的 Builder 来构建对象，可以通过链式调用来设置属性。</p>
3. 单例模式 Singleton Pattern</h2>

保证一个类仅有一个实例，并提供一个访问它的全局访问点。</p>
</blockquote>
常见做法是将构造函数私有化，然后提供一个静态方法来获取实例，在这个方法中判断实例是否已经创建，如果没有则创建，如果有则直接返回。不过还有通过枚举，静态内部类等方式来实现，篇幅问题这里不再展开，可以参考 从JDK中学习设计模式——单例模式</a></p>
JDK Runtime</h3>
Runtime</span> runtime</span> =</span> Runtime</span>.</span>getRuntime</span>(</span>)</span>;</span></span></code></pre>
看下 Runtime</code> 的源码：</p>
public</span> class</span> Runtime</span> {</span></span>
    private</span> static</span> final</span> Runtime</span> currentRuntime</span> =</span> new</span> Runtime</span>(</span>)</span>;</span></span>
</span>
    public</span> static</span> Runtime</span> getRuntime</span>(</span>)</span> {</span></span>
        return</span> currentRuntime</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>4. 原型模式 Prototype Pattern</h2>

使你能够复制已有对象，而又无需使代码依赖它们所属的类。</p>
</blockquote>
你可能对上面的 "无需使代码依赖它们所属的类" 感到困惑，其实他是指，复制对象时，无需手动创建一个属于相同类的对象，再遍历原始对象的所有成员变量依次设置到新对象中。</p>
JDK Cloneable</h3>
JDK 中的 java.lang.Cloneable</code> 接口就是原型模式的一种实现，通过实现这个接口，然后重写 clone</code> 方法来实现原型模式。</p>
public</span> class</span> User</span> implements</span> Cloneable</span> {</span></span>
</span>
    private</span> final</span> String</span> name</span>;</span></span>
</span>
    private</span> final</span> int</span> age</span>;</span></span>
</span>
    public</span> User</span>(</span>String</span> name</span>,</span> int</span> age</span>)</span> {</span></span>
        this</span>.</span>name</span> =</span> name</span>;</span></span>
        this</span>.</span>age</span> =</span> age</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    protected</span> Object</span> clone</span>(</span>)</span> throws</span> CloneNotSupportedException</span> {</span></span>
        return</span> super</span>.</span>clone</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> String</span> toString</span>(</span>)</span> {</span></span>
        return</span> "</span>User{</span>"</span> +</span></span>
                "</span>name='</span>"</span> +</span> name </span>+</span> '</span>\'</span>'</span> +</span></span>
                "</span>, age=</span>"</span> +</span> age </span>+</span></span>
                '</span>}</span>'</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
测试方法</p>
public</span> class</span> PrototypePatternDemo</span> {</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws</span> CloneNotSupportedException</span> {</span></span>
        User</span> user</span> =</span> new</span> User</span>(</span>"</span>张三</span>"</span>,</span> 18</span>)</span>;</span></span>
        User</span> userClone</span> =</span> (</span>User</span>)</span> user</span>.</span>clone</span>(</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>user</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>userClone</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>user </span>==</span> userClone</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
结果输出</p>
User{name='张三', age=18}</span></span>
User{name='张三', age=18}</span></span>
false</span></span></code></pre>
从结果可以看出，user</code> 和 userClone</code> 是两个不同的对象，但是他们的属性是一样的，这就是原型模式的作用。当然你也可以在 clone</code> 方法中手动设置属性，这样就可以实现深拷贝。</p>

二、结构型模式</h1>
1. 装饰器模式 Decorator Pattern</h2>

在不改变原有类</strong>的情况下扩展其功能，使用组合代替继承的方式来实现。</p>
</blockquote>
JDK Collections.unmodifiableList</h3>
import</span> java</span>.</span>util</span>.</span>ArrayList</span>;</span></span>
import</span> java</span>.</span>util</span>.</span>Collections</span>;</span></span>
import</span> java</span>.</span>util</span>.</span>List</span>;</span></span>
</span>
List</span><</span>String</span>></span> list</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
List</span><</span>String</span>></span> unmodifiableList</span> =</span> Collections</span>.</span>unmodifiableList</span>(</span>list</span>)</span>;</span></span></code></pre>
对原 List 进行装饰，使其不可修改。原理是底层会创建一个 UnmodifiableList</code> 对象，将原 List 传入，调用所以获取型方法时，会调用原 List 的方法，但是修改方法会抛出异常避免修改。</p>
JDK InputStream</h3>
import</span> java</span>.</span>io</span>.</span>BufferedInputStream</span>;</span></span>
import</span> java</span>.</span>io</span>.</span>FileInputStream</span>;</span></span>
import</span> java</span>.</span>io</span>.</span>InputStream</span>;</span></span>
</span>
InputStream</span> inputStream</span> =</span> new</span> FileInputStream</span>(</span>"</span>file.txt</span>"</span>)</span>;</span></span>
InputStream</span> bufferedInputStream</span> =</span> new</span> BufferedInputStream</span>(</span>inputStream</span>)</span>;</span></span></code></pre>
这里对原 FileInputStream</code> 进行装饰，使其具有缓冲功能。同理也可以自己创建具有加密，限流，监控等功能的装饰器。</p>
2. 适配器模式 Adapter Pattern</h2>

当一个类不能直接被使用时，可以通过适配器来转换为另一个类。</p>
</blockquote>
JDK FutureTask</h3>
FutureTask</code> 构造函数一：传入 Callable</code></p>
public</span> FutureTask</span>(</span>Callable</span><</span>V</span>></span> callable</span>)</span> {</span></span>
    if</span> (</span>callable </span>==</span> null</span>)</span></span>
        throw</span> new</span> NullPointerException</span>(</span>)</span>;</span></span>
    this</span>.</span>callable</span> =</span> callable</span>;</span></span>
    this</span>.</span>state</span> =</span> NEW</span>;</span>       //</span> ensure visibility of callable</span></span>
}</span></span></code></pre>
FutureTask</code> 构造函数二：传入 Runnable</code></p>
public</span> FutureTask</span>(</span>Runnable</span> runnable</span>,</span> V</span> result</span>)</span> {</span> //</span> 因为 `FutureTask` 有个 `get` 方法，用来获取结果，但 Runnable 的 run 方法没有返回值，所以需要手动指定一个。</span></span>
    this</span>.</span>callable</span> =</span> Executors</span>.</span>callable</span>(</span>runnable</span>,</span> result</span>)</span>;</span></span>
    this</span>.</span>state</span> =</span> NEW</span>;</span>       //</span> ensure visibility of callable</span></span>
}</span></span></code></pre>
主要看这里的 Executors.callable</code> 返回了一个 Callable</code> 类的实例：</p>
public</span> static</span> <</span>T</span>></span> Callable</span><</span>T</span>></span> callable</span>(</span>Runnable</span> task</span>,</span> T</span> result</span>)</span> {</span></span>
    if</span> (</span>task </span>==</span> null</span>)</span></span>
        throw</span> new</span> NullPointerException</span>(</span>)</span>;</span></span>
    //</span> 这里返回的是一个实现了 Callable 的适配器</span></span>
    return</span> new</span> RunnableAdapter</span><</span>T</span>></span>(</span>task</span>,</span> result</span>)</span>;</span></span>
}</span></span></code></pre>
再来看看 RunnableAdapter</code>:</p>
//</span> 实现了 Callable</span></span>
static</span> final</span> class</span> RunnableAdapter</span><</span>T</span>></span> implements</span> Callable</span><</span>T</span>></span> {</span></span>
    final</span> Runnable</span> task</span>;</span></span>
    final</span> T</span> result</span>;</span></span>
    //</span> 传入 Runnable 接口的实现类和返回值</span></span>
    RunnableAdapter</span>(</span>Runnable</span> task</span>,</span> T</span> result</span>)</span> {</span></span>
        this</span>.</span>task</span> =</span> task</span>;</span></span>
        this</span>.</span>result</span> =</span> result</span>;</span></span>
    }</span></span>
    public</span> T</span> call</span>(</span>)</span> {</span></span>
        //</span> 在 call 方法中调用 Runnable 的 run 方法，变相实现了 Runnable 转 Callable 的过程.</span></span>
        task</span>.</span>run</span>(</span>)</span>;</span></span>
        return</span> result</span>;</span></span>
    }</span></span>
}</span></span></code></pre>3. 外观模式/门面模式 Facade Pattern</h2>

创建一个统一的接口，用来屏蔽内部复杂的底层或结构。
这个模式有点笼统，很可能你在开发中已经用到了，但是没有意识到，比如我们使用 Spring MVC 开发的 restful 接口，对外只提供了一个统一的接口，但是内部可能调用了很多服务，数据库，缓存等。</p>
</blockquote>
JDK Executors</h3>
Executors</code> 提供了一系列工厂方法来创建线程池，如 newFixedThreadPool</code>，newCachedThreadPool</code>，newSingleThreadExecutor</code> 等。</p>
public</span> class</span> Executors</span> {</span></span>
    public</span> static</span> ExecutorService</span> newFixedThreadPool</span>(</span>int</span> nThreads</span>)</span> {</span></span>
        return</span> new</span> ThreadPoolExecutor</span>(</span>nThreads</span>,</span> nThreads</span>,</span></span>
                                      0L</span>,</span> TimeUnit</span>.</span>MILLISECONDS</span>,</span></span>
                                      new</span> LinkedBlockingQueue</span><</span>Runnable</span>></span>(</span>)</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> static</span> ExecutorService</span> newSingleThreadExecutor</span>(</span>)</span> {</span></span>
        return</span> new</span> FinalizableDelegatedExecutorService</span></span>
                (</span>new</span> ThreadPoolExecutor</span>(</span>1</span>,</span> 1</span>,</span></span>
                        0L</span>,</span> TimeUnit</span>.</span>MILLISECONDS</span>,</span></span>
                        new</span> LinkedBlockingQueue</span><</span>Runnable</span>></span>(</span>)</span>)</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
Executors</code> 内部其实根据不同的参数创建了不同的线程池，对外提供了统一的接口。其实这个类也算一个工厂模式(静态工厂方法模式)。</p>
4. 代理模式 Proxy Pattern</h2>

为对象创建一个代理，你可以操作代理而不是源对象，代理可以对源对象进行访问，并且可以提供额外的功能，如在访问源对象前后进行一些操作。</p>
</blockquote>
JDK Proxy</h3>
java.lang.reflect.Proxy</code> 提供了创建动态代理的方法，可以根据传入的接口和处理器来创建代理对象。</p>
JDK 动态代理是基于接口的，所以你需要为被代理对象创建一个接口：</p>
interface</span> Image</span> {</span></span>
    void</span> display</span>(</span>)</span>;</span></span>
}</span></span></code></pre>
然后有一个实现类，也就是我们的被代理者：</p>
class</span> RealImage</span> implements</span> Image</span> {</span></span>
    private</span> final</span> String</span> filename</span>;</span></span>
</span>
    public</span> RealImage</span>(</span>String</span> filename</span>)</span> {</span></span>
        this</span>.</span>filename</span> =</span> filename</span>;</span></span>
    }</span></span>
</span>
    public</span> void</span> display</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>Displaying </span>"</span> +</span> filename</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
再创建一个代理类，实现 InvocationHandler</code> 接口：</p>
class</span> ImageProxy</span> implements</span> InvocationHandler</span> {</span></span>
    private</span> final</span> Image</span> realImage</span>;</span></span>
</span>
    public</span> ImageProxy</span>(</span>Image</span> realImage</span>)</span> {</span></span>
        this</span>.</span>realImage</span> =</span> realImage</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> Object</span> invoke</span>(</span>Object</span> proxy</span>,</span> Method</span> method</span>,</span> Object</span>[</span>]</span> args</span>)</span> throws</span> Throwable</span> {</span></span>
        if</span> (</span>method</span>.</span>getName</span>(</span>)</span>.</span>equals</span>(</span>"</span>display</span>"</span>)</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>Proxying before displaying</span>"</span>)</span>;</span></span>
            realImage</span>.</span>display</span>(</span>)</span>;</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>Proxying after displaying</span>"</span>)</span>;</span></span>
        }</span></span>
        return</span> null</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
然后演示一下：</p>
public</span> class</span> ProxyPatternDemo</span> {</span></span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        Image</span> realImage</span> =</span> new</span> RealImage</span>(</span>"</span>test.jpg</span>"</span>)</span>;</span></span>
        Image</span> proxyImage</span> =</span> (</span>Image</span>)</span> Proxy</span>.</span>newProxyInstance</span>(</span></span>
                realImage</span>.</span>getClass</span>(</span>)</span>.</span>getClassLoader</span>(</span>)</span>,</span></span>
                realImage</span>.</span>getClass</span>(</span>)</span>.</span>getInterfaces</span>(</span>)</span>,</span></span>
                new</span> ImageProxy</span>(</span>realImage</span>)</span></span>
        )</span>;</span></span>
</span>
        proxyImage</span>.</span>display</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
上面我们先创建了一个 RealImage</code> 对象，然后通过 Proxy.newProxyInstance</code> 方法创建了一个代理对象，这个代理对象实现了 Image</code> 接口，然后调用代理对象的 display</code> 方法，实际上是调用了 ImageProxy</code> 的 invoke</code> 方法，然后在这个方法中调用了 RealImage</code> 的 display</code> 方法。</p>
5. 桥接模式 Bridge Pattern</h2>

将抽象部分与它的实现部分分离，使它们都可以独立的变化。</p>
</blockquote>
这个模式很抽象，不易理解，其实本质上是为了解决多维度的变化，比如一个类有多个维度的变化，如颜色，形状等，如果使用继承的方式来实现，会导致类的爆炸式增长，所以可以使用桥接模式来解决。</p>
JDK JDBC</h3>
这个有人说是桥接模式，但我自己感觉又不太像，有点生搬硬套的感觉，这里也有个博主写了一篇文章大家可以参考下 JDBC和桥接模式</a></p>
Spring JdbcTemplate</h3>
Spring 的 JdbcTemplate</code> 就是一个很好的例子，他将 DataSource</code> 这个接口和 JdbcOperations</code> 这个接口分离开来，DataSource</code> 是用来获取数据库连接的，JdbcOperations</code> 是用来执行 SQL 语句的。</p>
import</span> javax</span>.</span>sql</span>.</span>DataSource</span>;</span></span>
</span>
public</span> class</span> JdbcTemplate</span> extends</span> JdbcAccessor</span> implements</span> JdbcOperations</span> {</span></span>
    public</span> JdbcTemplate</span>(</span>DataSource</span> dataSource</span>)</span> {</span></span>
        setDataSource</span>(</span>dataSource</span>)</span>;</span></span>
        afterPropertiesSet</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
如果不这样做，那么每个数据库都需要实现一套 DataSource</code> 和 JdbcOperations</code>，如有 MySQL，Oracle，PostgreSQL，就需要这样：</p>
- DataSource</span></span>
  - MySQLDataSource</span></span>
  - OracleDataSource</span></span>
  - PostgreSQLDataSource</span></span></code></pre>
首先每个数据库都需要实现 DataSource</code> 接口，然后每个数据源都需要实现 JdbcOperations</code> 接口：</p>
- DataSource</span></span>
  - MySQLDataSource implements JdbcOperations</span></span>
  - OracleDataSource implements JdbcOperations</span></span>
  - PostgreSQLDataSource implements JdbcOperations</span></span></code></pre>
这样会有很多重复的代码，而且如果有新的数据库，还需要新增一套 DataSource</code> 和 JdbcOperations</code>。</p>
但是现在有了 JdbcTemplate</code>，只需要实现 DataSource</code> 接口，传递给 JDBCTemplate</code>，然后在 JdbcTemplate</code> 中实现 JdbcOperations</code> 接口，这样增加新的数据库时，只需要实现 DataSource</code> 接口即可。</p>
这就对应了 将抽象部分与它的实现部分分离，使它们都可以独立的变化。</code>，现在 DataSource 和 JdbcOperations 都可以独立的变化，功能也是分离的，由 JdbcTemplate</code> 来桥接。</p>
6. 组合模式 Composite Pattern</h2>

将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。</p>
</blockquote>
JDK FileSystem</h3>
java.nio.file</code> 包下的文件系统就是一个很好的例子，它将文件和目录都抽象成了 Path</code> 对象，然后可以通过 Files</code> 类来操作这些对象。</p>
import</span> java</span>.</span>nio</span>.</span>file</span>.</span>Files</span>;</span></span>
import</span> java</span>.</span>nio</span>.</span>file</span>.</span>Path</span>;</span></span>
import</span> java</span>.</span>nio</span>.</span>file</span>.</span>Paths</span>;</span></span>
</span>
public</span> class</span> FileSystemDemo</span> {</span></span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        Path</span> path</span> =</span> Paths</span>.</span>get</span>(</span>"</span>file.txt</span>"</span>)</span>;</span></span>
        Files</span>.</span>exists</span>(</span>path</span>)</span>;</span></span>
        Files</span>.</span>isDirectory</span>(</span>path</span>)</span>;</span></span>
        Files</span>.</span>isRegularFile</span>(</span>path</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>JDK File</h3>
java.io.File</code> 也是类似的，它将文件和目录都抽象成了 File</code> 对象，然后可以通过 File</code> 类来操作这些对象。</p>
import</span> java</span>.</span>io</span>.</span>File</span>;</span></span>
</span>
public</span> class</span> FileDemo</span> {</span></span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        File</span> file</span> =</span> new</span> File</span>(</span>"</span>file.txt</span>"</span>)</span>;</span></span>
        file</span>.</span>exists</span>(</span>)</span>;</span></span>
        file</span>.</span>isDirectory</span>(</span>)</span>;</span></span>
        file</span>.</span>isFile</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>

其实就是对于有共性的两种不同类型的事物，抽象成一个接口，而不是创建两个类，在成员变量中可以存放自己所属的类型，这样就可以实现对于两种不同类型的事物的统一处理。</p>
</blockquote>
7. 享元模式 Flyweight Pattern</h2>

主要为了减少对象的创建，以用来减少内存占用和提高性能，在不影响程序的情况下可以共享对象来减少对象的创建。</p>
</blockquote>
JDK Integer</h3>
JDK 的 Integer 类缓存了 -128 到 127 之间的整数，因为这些整数在程序中使用的频率比较高，所以缓存起来可以减少对象的创建。</p>
public</span> final</span> class</span> Integer</span> extends</span> Number</span> implements</span> Comparable</span><</span>Integer</span>></span> {</span></span>
    public</span> static</span> Integer</span> valueOf</span>(</span>int</span> i</span>)</span> {</span></span>
        if</span> (</span>i </span>>=</span> IntegerCache</span>.</span>low</span> &&</span> i </span><=</span> IntegerCache</span>.</span>high</span>)</span></span>
            return</span> IntegerCache</span>.</span>cache</span>[</span>i </span>+</span> (</span>-</span>IntegerCache</span>.</span>low</span>)</span>]</span>;</span></span>
        return</span> new</span> Integer</span>(</span>i</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
IntegerCache 类是 Integer 的一个静态内部类，会在 Integer 类加载的时候初始化：</p>
public</span> final</span> class</span> Integer</span> extends</span> Number</span> implements</span> Comparable</span><</span>Integer</span>></span> {</span></span>
    private</span> static</span> class</span> IntegerCache</span> {</span></span>
        static</span> final</span> int</span> low</span> =</span> -</span>128</span>;</span></span>
        static</span> final</span> int</span> high</span>;</span></span>
        static</span> final</span> Integer</span> cache</span>[</span>]</span>;</span></span>
</span>
        static</span> {</span></span>
            //</span> high value may be configured by property</span></span>
            int</span> h</span> =</span> 127</span>;</span></span>
            String</span> integerCacheHighPropValue</span> =</span></span>
                    sun</span>.</span>misc</span>.</span>VM</span>.</span>getSavedProperty</span>(</span>"</span>java.lang.Integer.IntegerCache.high</span>"</span>)</span>;</span></span>
            if</span> (</span>integerCacheHighPropValue </span>!=</span> null</span>)</span> {</span></span>
                try</span> {</span></span>
                    int</span> i</span> =</span> parseInt</span>(</span>integerCacheHighPropValue</span>)</span>;</span></span>
                    i </span>=</span> Math</span>.</span>max</span>(</span>i</span>,</span> 127</span>)</span>;</span></span>
                    //</span> Maximum array size is Integer.MAX_VALUE</span></span>
                    h </span>=</span> Math</span>.</span>min</span>(</span>i</span>,</span> Integer</span>.</span>MAX_VALUE</span> -</span> (</span>-</span>low</span>)</span> -</span> 1</span>)</span>;</span></span>
                }</span> catch</span> (</span>NumberFormatException</span> nfe</span>)</span> {</span></span>
                    //</span> If the property cannot be parsed into an int, ignore it.</span></span>
                }</span></span>
            }</span></span>
            high </span>=</span> h</span>;</span></span>
</span>
            cache </span>=</span> new</span> Integer</span>[</span>(</span>high </span>-</span> low</span>)</span> +</span> 1</span>]</span>;</span></span>
            int</span> j</span> =</span> low</span>;</span></span>
            for</span> (</span>int</span> k</span> =</span> 0</span>;</span> k </span><</span> cache</span>.</span>length</span>;</span> k</span>++</span>)</span></span>
                cache</span>[</span>k</span>]</span> =</span> new</span> Integer</span>(</span>j</span>++</span>)</span>;</span></span>
</span>
            //</span> range [-128, 127] must be interned (JLS7 5.1.7)</span></span>
            assert</span> IntegerCache</span>.</span>high</span> >=</span> 127</span>;</span></span>
        }</span></span>
</span>
        private</span> IntegerCache</span>(</span>)</span> {</span></span>
        }</span></span>
    }</span></span>
}</span></span></code></pre>

还有池化技术：线程池</code>，连接池</code> 等，这些都是享元模式的应用，它们都是为了减少对象的创建，提高性能。</p>
</blockquote>

三、行为模式</h1>
1. 模板模式 Template Pattern  / 模板方法模式 Template Method Pattern</h2>

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。其实就是父类定义一些抽象方法，子类实现这些方法。</p>
</blockquote>
JDK Comparable</h3>
public</span> interface</span> Comparable</span><</span>T</span>></span> {</span></span>
    int</span> compareTo</span>(</span>T</span> o</span>)</span>;</span></span>
}</span></span></code></pre>
Comparable</code> 接口中只有一个抽象方法 compareTo</code>，这个方法的具体实现是由子类来实现的。如 Integer，String 等类都实现了这个接口，以 Integer 为例：</p>
public</span> final</span> class</span> Integer</span> extends</span> Number</span> implements</span> Comparable</span><</span>Integer</span>></span> {</span></span>
    public</span> int</span> compareTo</span>(</span>Integer</span> anotherInteger</span>)</span> {</span></span>
        return</span> compare</span>(</span>this</span>.</span>value</span>,</span> anotherInteger</span>.</span>value</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>2. 观察者模式 Observer Pattern / 发布订阅模式 Publish-Subscribe Pattern</h2>

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。有时也叫做发布-订阅模式。</p>
</blockquote>
JDK Observer & Observable</h3>
JDK 中已经提供了 Observer</code> 和 Observable</code> 接口，分别表示观察者和被观察者。</p>
首先被观察者需要实现 Observable</code> 接口：</p>
import</span> java</span>.</span>util</span>.</span>Observable</span>;</span></span>
</span>
class</span> User</span> extends</span> Observable</span> {</span></span>
</span>
    private</span> String</span> name</span>;</span></span>
</span>
    public</span> void</span> setName</span>(</span>String</span> name</span>)</span> {</span></span>
        this</span>.</span>name</span> =</span> name</span>;</span></span>
        super</span>.</span>setChanged</span>(</span>)</span>;</span>           //</span> 调用 Observable 提供的方法，标记状态已经改变</span></span>
        super</span>.</span>notifyObservers</span>(</span>name</span>)</span>;</span>  //</span> 调用 Observable 提供的方法，通知所有观察者</span></span>
    }</span></span>
    </span></span>
}</span></span></code></pre>
然后观察者需要实现 Observer</code> 接口：</p>
</span>
import</span> java</span>.</span>util</span>.</span>Observer</span>;</span></span>
</span>
class</span> UserObserver</span> implements</span> Observer</span> {</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> update</span>(</span>Observable</span> observable</span>,</span> Object</span> arg</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>观察到用户的名字已经改变为 {}, {}</span>"</span>,</span> observable</span>,</span> arg</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
最后在需要的地方进行注册和通知：</p>
public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
    User</span> user</span> =</span> new</span> User</span>(</span>)</span>;</span></span>
    UserObserver</span> userObserver</span> =</span> new</span> UserObserver</span>(</span>)</span>;</span></span>
    user</span>.</span>addObserver</span>(</span>userObserver</span>)</span>;</span></span>
    user</span>.</span>setName</span>(</span>"</span>张三</span>"</span>)</span>;</span></span>
}</span></span></code></pre>3. 策略模式 Strategy Pattern</h2>

定义一系列算法/策略的接口，每个策略都实现这个接口，这样可以很方便的替换算法/策略。</p>
</blockquote>
JDK Comparator</h3>
jdk 中的 java.util.Comparator</code> 接口就是一种排序策略接口，你可以根据不同的需求实现不同的排序策略，然后调用 Collections.sort</code> 方法时可以传入 Comparator</code> 接口的实现类。</p>
先来看看 Comparator</code> 接口的源码：</p>
@</span>FunctionalInterface</span></span>
public</span> interface</span> Comparator</span><</span>T</span>></span> {</span></span>
    int</span> compare</span>(</span>T</span> o1</span>,</span> T</span> o2</span>)</span>;</span></span>
}</span></span></code></pre>
这个接口只有一个抽象方法 compare</code>，传入两个参数，返回一个整数，表示两个对象的大小关系。</p>
4. 责任链模式 Chain of Responsibility Pattern</h2>

定义一个处理链，每个处理器都可以处理请求，或交给下一个处理器处理。</p>
</blockquote>
JDK Filter</h3>
javax.servlet.Filter</code> 就是一种责任链模式，它的 doFilter</code> 方法中可以调用下一个 Filter</code> 的 doFilter</code> 方法，也可以决定是否调用下一个 Filter</code> 的 doFilter</code> 方法。</p>
public</span> interface</span> Filter</span> {</span></span>
    void</span> doFilter</span>(</span>ServletRequest</span> request</span>,</span> ServletResponse</span> response</span>,</span> FilterChain</span> chain</span>)</span> throws</span> IOException</span>,</span> ServletException</span>;</span></span>
}</span></span></code></pre>
FilterChain</code> 接口：</p>
public</span> interface</span> FilterChain</span> {</span></span>
    void</span> doFilter</span>(</span>ServletRequest</span> request</span>,</span> ServletResponse</span> response</span>)</span> throws</span> IOException</span>,</span> ServletException</span>;</span></span>
}</span></span></code></pre>
这样可以定义多个 Filter</code>，使用 FilterChain 来组织成一个责任链并控制调用的顺序，每个 Filter</code> 都可以决定是否调用下一个 Filter</code>。</p>

责任链模式在开发中很常用，且有很多变种或增强的版本，如跳链，更加灵活的控制是否调用下一个处理器等。
但是在实际开发中，需要注意责任链模式的性能问题，因为责任链模式的处理是递归的，如果责任链过长，可能会导致栈溢出。
责任链的顺序可以通过给责任链增加注解，增加方法，配置文件等方式来实现，这样可以更加灵活的控制责任链的顺序。</p>
</blockquote>
5. 状态模式 State Pattern</h2>

允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。</p>
</blockquote>
这里在 JDK 中没有找到合适的例子，我来用一个示例来说明一下:</p>
现在有一个播放器，有 初始化 INITIALIZED</code>，待播放 PREPARED</code>，播放 PLAYING</code>，暂停 PAUSED</code> 四种状态，按钮有 播放</strong> 和 暂停</strong>，当播放器处于不同的状态时，对应的按钮的行为也是不同的。</p>

当播放器处于 INITIALIZED</code> 状态时，所有按钮都是不可用的，如果点击则提示 "正在初始化，请稍后..."</li>
当播放器处于 PREPARED</code> 状态时，播放</strong> 按钮可用，暂停</strong> 按钮不可用，如果点击 播放</strong> 按钮，则播放器进入 PLAYING</code> 状态，如果点击 暂停</strong> 按钮，则提示 "播放器还没有开始播放"</li>
当播放器处于 PLAYING</code> 状态时，播放</strong> 按钮不可用，暂停</strong> 按钮可用，如果点击 播放</strong> 按钮，则提示 "播放器正在播放中"，如果点击 暂停</strong> 按钮，则播放器进入 PAUSED</code> 状态</li>
当播放器处于 PAUSED</code> 状态时，播放</strong> 按钮可用，暂停</strong> 按钮不可用，如果点击 播放</strong> 按钮，则播放器进入 PLAYING</code> 状态，如果点击 暂停</strong> 按钮，则提示 "播放器已经暂停"</li>
</ul>
先来使用普通的 if-else 来实现：</p>
public</span> class</span> VideoPlayer</span> {</span></span>
</span>
    private</span> String</span> state</span> =</span> INITIALIZED</span>;</span></span>
</span>
    public</span> static</span> final</span> String</span> INITIALIZED</span> =</span> "</span>INITIALIZED</span>"</span>;</span></span>
    public</span> static</span> final</span> String</span> PREPARED</span> =</span> "</span>PREPARED</span>"</span>;</span></span>
    public</span> static</span> final</span> String</span> PLAYING</span> =</span> "</span>PLAYING</span>"</span>;</span></span>
    public</span> static</span> final</span> String</span> PAUSED</span> =</span> "</span>PAUSED</span>"</span>;</span></span>
</span>
    public</span> void</span> init</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>开始初始化</span>"</span>)</span>;</span></span>
        state </span>=</span> INITIALIZED</span>;</span></span>
</span>
        //</span> 假如初始化需要一秒钟</span></span>
        try</span> {</span></span>
            Thread</span>.</span>sleep</span>(</span>1000</span>)</span>;</span></span>
        }</span> catch</span> (</span>InterruptedException</span> e</span>)</span> {</span></span>
            throw</span> new</span> RuntimeException</span>(</span>e</span>)</span>;</span></span>
        }</span></span>
</span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>初始化完成</span>"</span>)</span>;</span></span>
        state </span>=</span> PREPARED</span>;</span></span>
    }</span></span>
</span>
    public</span> void</span> play</span>(</span>)</span> {</span></span>
        if</span> (</span>Objects</span>.</span>equals</span>(</span>state</span>,</span> PREPARED</span>)</span> ||</span> Objects</span>.</span>equals</span>(</span>state</span>,</span> PAUSED</span>)</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>播放</span>"</span>)</span>;</span></span>
            state </span>=</span> PLAYING</span>;</span></span>
        }</span> else</span> if</span> (</span>Objects</span>.</span>equals</span>(</span>state</span>,</span> INITIALIZED</span>)</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>正在初始化，请稍后...</span>"</span>)</span>;</span></span>
        }</span> else</span> if</span> (</span>Objects</span>.</span>equals</span>(</span>state</span>,</span> PLAYING</span>)</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>播放器正在播放中</span>"</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
    public</span> void</span> pause</span>(</span>)</span> {</span></span>
        if</span> (</span>Objects</span>.</span>equals</span>(</span>state</span>,</span> PLAYING</span>)</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>暂停</span>"</span>)</span>;</span></span>
            state </span>=</span> PAUSED</span>;</span></span>
        }</span> else</span> if</span> (</span>Objects</span>.</span>equals</span>(</span>state</span>,</span> INITIALIZED</span>)</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>正在初始化，请稍后...</span>"</span>)</span>;</span></span>
        }</span> else</span> if</span> (</span>Objects</span>.</span>equals</span>(</span>state</span>,</span> PREPARED</span>)</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>播放器还没有开始播放</span>"</span>)</span>;</span></span>
        }</span> else</span> if</span> (</span>Objects</span>.</span>equals</span>(</span>state</span>,</span> PAUSED</span>)</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>播放器已经暂停</span>"</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
测试类：</p>
public</span> class</span> VideoPlayerTest</span> {</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        VideoPlayer</span> videoPlayer</span> =</span> new</span> VideoPlayer</span>(</span>)</span>;</span></span>
        videoPlayer</span>.</span>play</span>(</span>)</span>;</span>     //</span> Should print "正在初始化，请稍后..."</span></span>
        videoPlayer</span>.</span>pause</span>(</span>)</span>;</span>    //</span> Should print "正在初始化，请稍后..."</span></span>
        videoPlayer</span>.</span>init</span>(</span>)</span>;</span>     //</span> Should print "开始初始化" and then "初始化完成"</span></span>
</span>
        videoPlayer</span>.</span>pause</span>(</span>)</span>;</span>    //</span> Should print "播放器还没有开始播放"</span></span>
        videoPlayer</span>.</span>play</span>(</span>)</span>;</span>     //</span> Should print "播放"</span></span>
        videoPlayer</span>.</span>play</span>(</span>)</span>;</span>     //</span> Should print "播放器正在播放中"</span></span>
        videoPlayer</span>.</span>pause</span>(</span>)</span>;</span>    //</span> Should print "暂停"</span></span>
        videoPlayer</span>.</span>pause</span>(</span>)</span>;</span>    //</span> Should print "播放器已经暂停"</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
看着晕么(我写的都晕)，这么多判断，代码冗长，而且容易出错，这时候就可以使用状态模式来解决这个问题。</p>
首先需要抽象出状态类：</p>
public</span> abstract</span> class</span> State</span> {</span></span>
</span>
    protected</span> Context</span> context</span>;</span></span>
</span>
    public</span> void</span> setContext</span>(</span>Context</span> context</span>)</span>{</span></span>
        this</span>.</span>context</span> =</span> context</span>;</span></span>
    }</span></span>
</span>
    public</span> abstract</span> void</span> play</span>(</span>)</span>;</span></span>
</span>
    public</span> abstract</span> void</span> pause</span>(</span>)</span>;</span></span>
</span>
}</span></span></code></pre>
然后每个状态都需要实现这个抽象类：</p>
public</span> class</span> PrearedState</span> extends</span> State</span> {</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> play</span>(</span>)</span> {</span></span>
        context</span>.</span>setState</span>(</span>Context</span>.</span>playingState</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>播放</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> pause</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>播放器还没有开始播放</span>"</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>public</span> class</span> InitializedState</span> extends</span> State</span> {</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> play</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>正在初始化，请稍后...</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> pause</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>正在初始化，请稍后...</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>public</span> class</span> PlayingState</span> extends</span> State</span> {</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> play</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>播放器正在播放中</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> pause</span>(</span>)</span> {</span></span>
        context</span>.</span>setState</span>(</span>Context</span>.</span>pausedState</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>暂停</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>public</span> class</span> PausedState</span> extends</span> State</span> {</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> play</span>(</span>)</span> {</span></span>
        context</span>.</span>setState</span>(</span>Context</span>.</span>playingState</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>播放</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> pause</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>播放器已经暂停</span>"</span>)</span>;</span></span>
    }</span></span>
    </span></span>
}</span></span></code></pre>
然后有个上下文对象，来存储当前的状态：</p>
public</span> class</span> Context</span> {</span></span>
</span>
    private</span> State</span> state</span>;</span></span>
</span>
    public</span> final</span> static</span> InitializedState</span> initializedState</span> =</span> new</span> InitializedState</span>(</span>)</span>;</span></span>
    public</span> final</span> static</span> PausedState</span> pausedState</span> =</span> new</span> PausedState</span>(</span>)</span>;</span></span>
    public</span> final</span> static</span> PlayingState</span> playingState</span> =</span> new</span> PlayingState</span>(</span>)</span>;</span></span>
    public</span> final</span> static</span> PrearedState</span> prearedState</span> =</span> new</span> PrearedState</span>(</span>)</span>;</span></span>
</span>
    public</span> void</span> setState</span>(</span>State</span> state</span>)</span> {</span></span>
        this</span>.</span>state</span> =</span> state</span>;</span></span>
        this</span>.</span>state</span>.</span>setContext</span>(</span>this</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> State</span> getState</span>(</span>)</span> {</span></span>
        return</span> state</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
然后播放器中有个上下文对象，再根据当前状态类调用对应的方法。</p>
public</span> class</span> VideoPlayer</span> {</span></span>
</span>
    private</span> Context</span> context</span> =</span> new</span> Context</span>(</span>)</span>;</span></span>
</span>
    public</span> VideoPlayer</span>(</span>)</span> {</span></span>
        context</span>.</span>setState</span>(</span>Context</span>.</span>initializedState</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> void</span> init</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>开始初始化</span>"</span>)</span>;</span></span>
</span>
        //</span> 假如初始化需要一秒钟</span></span>
        try</span> {</span></span>
            Thread</span>.</span>sleep</span>(</span>1000</span>)</span>;</span></span>
        }</span> catch</span> (</span>InterruptedException</span> e</span>)</span> {</span></span>
            throw</span> new</span> RuntimeException</span>(</span>e</span>)</span>;</span></span>
        }</span></span>
</span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>初始化完成</span>"</span>)</span>;</span></span>
        context</span>.</span>setState</span>(</span>Context</span>.</span>prearedState</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> void</span> play</span>(</span>)</span> {</span></span>
        this</span>.</span>context</span>.</span>getState</span>(</span>)</span>.</span>play</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> void</span> pause</span>(</span>)</span> {</span></span>
        this</span>.</span>context</span>.</span>getState</span>(</span>)</span>.</span>pause</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
测试类不变：</p>
public</span> class</span> VideoPlayerTest</span> {</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        VideoPlayer</span> videoPlayer</span> =</span> new</span> VideoPlayer</span>(</span>)</span>;</span></span>
        videoPlayer</span>.</span>play</span>(</span>)</span>;</span>     //</span> Should print "正在初始化，请稍后..."</span></span>
        videoPlayer</span>.</span>pause</span>(</span>)</span>;</span>    //</span> Should print "正在初始化，请稍后..."</span></span>
        videoPlayer</span>.</span>init</span>(</span>)</span>;</span>     //</span> Should print "开始初始化" and then "初始化完成"</span></span>
</span>
        videoPlayer</span>.</span>pause</span>(</span>)</span>;</span>    //</span> Should print "播放器还没有开始播放"</span></span>
        videoPlayer</span>.</span>play</span>(</span>)</span>;</span>     //</span> Should print "播放"</span></span>
        videoPlayer</span>.</span>play</span>(</span>)</span>;</span>     //</span> Should print "播放器正在播放中"</span></span>
        videoPlayer</span>.</span>pause</span>(</span>)</span>;</span>    //</span> Should print "暂停"</span></span>
        videoPlayer</span>.</span>pause</span>(</span>)</span>;</span>    //</span> Should print "播放器已经暂停"</span></span>
    }</span></span>
</span>
}</span></span></code></pre>6. 命令模式 Command Pattern</h2>
这里在 JDK 中没有找到合适的例子，我来用一个示例来说明一下:</p>
先看下命令模式的 UML 图：</p>
</p>
命令模式主要是为了解耦请求的发送者和接收者，请求的发送者不需要知道接收者是谁，只需要知道命令是什么，然后发送给调用者，调用者再调用命令的 execute</code> 方法，然后命令再调用接收者的方法。</p>
比如我们有一个开关，一个台灯，开关不一定只能控制台灯，还可以控制其他的设备。在这里开关是命令的发送者，台灯是命令的接收者，开关不需要知道台灯是谁，只需要知道命令是什么，台灯也不需要知道开关是谁，只需要执行开关操作。</p>
首先定义一个命令接口：</p>
public</span> interface</span> Command</span> {</span></span>
    void</span> execute</span>(</span>)</span>;</span></span>
}</span></span></code></pre>
然后定义一个接收者 (Receiver)：</p>
public</span> class</span> Light</span> {</span></span>
</span>
    public</span> void</span> on</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>台灯打开</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> void</span> off</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>台灯关闭</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
然后定义一个开关命令的实现类 (ConcreteCommand)：</p>
public</span> class</span> LightOnCommand</span> implements</span> Command</span> {</span></span>
</span>
    private</span> final</span> Light</span> light</span>;</span></span>
</span>
    public</span> LightOnCommand</span>(</span>Light</span> light</span>)</span> {</span></span>
        this</span>.</span>light</span> =</span> light</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> execute</span>(</span>)</span> {</span></span>
        light</span>.</span>on</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>public</span> class</span> LightOffCommand</span> implements</span> Command</span> {</span></span>
</span>
    private</span> final</span> Light</span> light</span>;</span></span>
</span>
    public</span> LightOffCommand</span>(</span>Light</span> light</span>)</span> {</span></span>
        this</span>.</span>light</span> =</span> light</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> execute</span>(</span>)</span> {</span></span>
        light</span>.</span>off</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
然后定义一个开关 (Invoker)：</p>
public</span> class</span> Switch</span> {</span></span>
</span>
    private</span> Command</span> command</span>;</span></span>
</span>
    public</span> void</span> setCommand</span>(</span>Command</span> command</span>)</span> {</span></span>
        this</span>.</span>command</span> =</span> command</span>;</span></span>
    }</span></span>
</span>
    public</span> void</span> execute</span>(</span>)</span> {</span></span>
        command</span>.</span>execute</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
测试类 (Client)：</p>
public</span> class</span> CommandPatternDemo</span> {</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        Light</span> light</span> =</span> new</span> Light</span>(</span>)</span>;</span></span>
        Command</span> lightOnCommand</span> =</span> new</span> LightOnCommand</span>(</span>light</span>)</span>;</span></span>
        Command</span> lightOffCommand</span> =</span> new</span> LightOffCommand</span>(</span>light</span>)</span>;</span></span>
</span>
        Switch</span> s</span> =</span> new</span> Switch</span>(</span>)</span>;</span></span>
</span>
        s</span>.</span>setCommand</span>(</span>lightOnCommand</span>)</span>;</span></span>
        s</span>.</span>execute</span>(</span>)</span>;</span>    //</span> Should print "台灯打开"</span></span>
</span>
        s</span>.</span>setCommand</span>(</span>lightOffCommand</span>)</span>;</span></span>
        s</span>.</span>execute</span>(</span>)</span>;</span>    //</span> Should print "台灯打开"</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
看完了这个示例，你可能会觉得这个示例有点简单，甚至有点多此一举，本来可以直接创建一个台灯对象存储起来，然后直接调用台灯的 on</code> 和 off</code> 方法，为什么要多此一举呢？</p>
public</span> class</span> CommandPatternDemo</span> {</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        Light</span> light</span> =</span> new</span> Light</span>(</span>)</span>;</span></span>
</span>
        light</span>.</span>on</span>(</span>)</span>;</span>    //</span> Should print "台灯打开"</span></span>
        light</span>.</span>off</span>(</span>)</span>;</span>   //</span> Should print "台灯关闭"</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
不过我们再深入想想，如果你有很多地方需要控制台灯，那么你就需要在每个地方都创建一个台灯对象，然后调用台灯的 on</code> 和 off</code> 方法。
但如果我们需要增加个定时关闭的功能，如果直接调用台灯的 off</code> 方法，那么你就需要在每个地方都修改代码增加个定时器来实现。或者需要增加个调用日志，定时开启等功能，同理也需要在每个地方都修改代码。</p>

JDK 中本来想找个 Runnable</code> 来举例，但是发现 Runnable</code> 并不严格符合命令模式，他没有接收者，只有命令和调用者.</p>
</blockquote>

参考: 详解命令模式本质及其在高复杂调用中的实践案例-阿里技术</a></p>
</blockquote>
7. 迭代器模式 Iterator Pattern</h2>

提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示 (列表、栈、数组)。</p>
</blockquote>
JDK Iterator</h3>
java.util.Iterator</code> 就是一个很好的例子，它提供了一种顺序访问集合的方法，而不暴露集合的内部表示。</p>
public</span> interface</span> Iterator</span><</span>E</span>></span> {</span></span>
    </span></span>
    boolean</span> hasNext</span>(</span>)</span>;</span></span>
    </span></span>
    E</span> next</span>(</span>)</span>;</span></span>
}</span></span></code></pre>
Collection</code> 接口就实现了 Iterator</code> 接口，我们平时使用的 ArrayList</code>，LinkedList</code> 等都实现了 Collection</code> 接口，所以我们可以使用 Iterator</code> 来遍历这些集合。</p>
public</span> class</span> IteratorPatternDemo</span> {</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        List</span><</span>String</span>></span> list</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
        list</span>.</span>add</span>(</span>"</span>张三</span>"</span>)</span>;</span></span>
        list</span>.</span>add</span>(</span>"</span>李四</span>"</span>)</span>;</span></span>
        list</span>.</span>add</span>(</span>"</span>王五</span>"</span>)</span>;</span></span>
</span>
        Iterator</span><</span>String</span>></span> iterator</span> =</span> list</span>.</span>iterator</span>(</span>)</span>;</span></span>
        while</span> (</span>iterator</span>.</span>hasNext</span>(</span>)</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>iterator</span>.</span>next</span>(</span>)</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
其实迭代器模式就是把迭代这个操作抽象出来，然后让集合类实现这个接口。不然的话，每个集合类都自己有一个迭代方法的话，可能方法名都不一样，调用时会很麻烦，也会有很多重复的代码。
而且根据需要我们还可以在迭代器中增加一些方法，如 previous</code>，first</code>，last</code> 等方法，这样就可以实现双向迭代。</p>
8. 备忘录模式 Memento Pattern</h2>

允许不暴露对象实现细节的情况下保存和恢复对象之前的状态。</p>
</blockquote>
这个模式在 JDK 中没有找到合适的例子，我来用一个示例来说明一下:</p>
比如我们要保存一个对象的历史状态/快照，可以随时恢复。首先如何给对象创建一个快照呢？可能你会遍历对象的成员变量并将其复制到一个新的对象中，但对象中有些成员变量可能是 private 的，你无法直接访问到它们。而且当你想恢复到某个状态时，就要修改原始对象的成员变量为快照时的状态，这样也会碰到私有成员变量的问题。如果设置成 public 的话，又会暴露对象的实现细节，无法保证对象的封装性。</p>
所以备忘录模式其实就是为了解决这个两个问题，解决的方式也很简单：首先原始对象，也就是需要保存快照的对象称之为原发器 (Originator) 对象，创建快照和恢复快照的方法都放到这个对象中，这样其他对象就不用从该对象内部复制成员变量了，他可以自己读取自己的状态并保存到一个快照对象中。</p>
public</span> class</span> Originator</span> {</span></span>
</span>
    private</span> String</span> state</span>;</span></span>
    </span></span>
    public</span> void</span> setState</span>(</span>String</span> state</span>)</span> {</span></span>
        this</span>.</span>state</span> =</span> state</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> String</span> getState</span>(</span>)</span> {</span></span>
        return</span> state</span>;</span></span>
    }</span></span>
</span>
    //</span> 生成一个快照对象（里面包含了当前对象需要记录的状态）</span></span>
    public</span> Memento</span> save</span>(</span>)</span> {</span></span>
        return</span> new</span> Memento</span>(</span>state</span>)</span>;</span></span>
    }</span></span>
</span>
    //</span> 从快照对象中恢复状态</span></span>
    public</span> void</span> restore</span>(</span>Memento</span> memento</span>)</span> {</span></span>
        state </span>=</span> memento</span>.</span>getState</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
其中 Memento</code> 就是备忘录对象，它保存了原发器对象的状态，但是不暴露原发器对象的实现细节。</p>
public</span> class</span> Memento</span> {</span></span>
</span>
    private</span> final</span> String</span> state</span>;</span></span>
</span>
    public</span> Memento</span>(</span>String</span> state</span>)</span> {</span></span>
        this</span>.</span>state</span> =</span> state</span>;</span></span>
    }</span></span>
</span>
    public</span> String</span> getState</span>(</span>)</span> {</span></span>
        return</span> state</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
这些 Mememto</code> 还需要保存到一个容器中，这里称之为管理者 (Caretaker) 对象，它保存了备忘录对象，但是不会修改备忘录对象。</p>
public</span> class</span> Caretaker</span> {</span></span>
</span>
    private</span> final</span> List</span><</span>Memento</span>></span> mementos</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
</span>
    public</span> void</span> add</span>(</span>Memento</span> memento</span>)</span> {</span></span>
        mementos</span>.</span>add</span>(</span>memento</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> Memento</span> get</span>(</span>int</span> index</span>)</span> {</span></span>
        return</span> mementos</span>.</span>get</span>(</span>index</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
测试类：</p>
public</span> class</span> MementoPatternDemo</span> {</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        Originator</span> originator</span> =</span> new</span> Originator</span>(</span>)</span>;</span></span>
        Caretaker</span> caretaker</span> =</span> new</span> Caretaker</span>(</span>)</span>;</span></span>
</span>
        originator</span>.</span>setState</span>(</span>"</span>State #1</span>"</span>)</span>;</span></span>
        caretaker</span>.</span>add</span>(</span>originator</span>.</span>save</span>(</span>)</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>current State: </span>"</span> +</span> originator</span>.</span>getState</span>(</span>)</span>)</span>;</span></span>
        </span></span>
        originator</span>.</span>setState</span>(</span>"</span>State #2</span>"</span>)</span>;</span></span>
        caretaker</span>.</span>add</span>(</span>originator</span>.</span>save</span>(</span>)</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>current State: </span>"</span> +</span> originator</span>.</span>getState</span>(</span>)</span>)</span>;</span></span>
</span>
        originator</span>.</span>setState</span>(</span>"</span>State #3</span>"</span>)</span>;</span></span>
        caretaker</span>.</span>add</span>(</span>originator</span>.</span>save</span>(</span>)</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>current State: </span>"</span> +</span> originator</span>.</span>getState</span>(</span>)</span>)</span>;</span></span>
 </span></span>
        originator</span>.</span>restore</span>(</span>caretaker</span>.</span>get</span>(</span>0</span>)</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>First saved State: </span>"</span> +</span> originator</span>.</span>getState</span>(</span>)</span>)</span>;</span></span>
        </span></span>
        originator</span>.</span>restore</span>(</span>caretaker</span>.</span>get</span>(</span>1</span>)</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>Second saved State: </span>"</span> +</span> originator</span>.</span>getState</span>(</span>)</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>

这个模式其实核心就是为了不暴露对象实现细节，将一些职责放到了原发器对象中，这样就可以保证对象的封装性。</p>
</blockquote>
9. 访问者模式 Visitor Pattern</h2>

封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新操作。</p>
</blockquote>
10. 中介者模式 Mediator Pattern</h2>

用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示的相互引用，从而使其耦合松散，而且可以独立的改变他们之间的交互。</p>
</blockquote>
Spring ApplicationEvent</h3>
Spring 中 ApplicationEvent</code> 也可以认为是一个中介者，用来封装一系列的对象交互，当一个对象发生变化时，可以发布一个事件，然后其他对象可以监听这个事件，从而实现对象之间的交互。</p>
具体可以参考 Spring 使用事件监听来解耦代码</a>，这里不再赘述。</p>
自实现中介者模式</h3>
如有一个数据同步的功能，有三个数据源，分别是 MySQL，Redis，ES，同步策略如下：</p>

MySQL 数据源发生变化时，需要同步到 Redis 和 ES</li>
Redis 数据源发生变化时，无需同步</li>
ES 数据源发生变化时，需要同步到 MySQL</li>
</ul>
使用中介模式来实现：</p>
首先定义一个数据库抽象类：</p>
public</span> abstract</span> class</span> AbstractDatabase</span> {</span></span>
</span>
    protected</span> AbstractMediator</span> mediator</span>;</span>    //</span> 中介者</span></span>
</span>
    public</span> AbstractDatabase</span>(</span>AbstractMediator</span> mediator</span>)</span> {</span></span>
        this</span>.</span>mediator</span> =</span> mediator</span>;</span></span>
    }</span></span>
</span>
    //</span> 仅添加数据</span></span>
    public</span> abstract</span> void</span> addData</span>(</span>String</span> data</span>)</span>;</span></span>
</span>
    //</span> 添加数据并按策略同步</span></span>
    public</span> abstract</span> void</span> addDataAndSync</span>(</span>String</span> data</span>)</span>;</span></span>
</span>
}</span></span></code></pre>
然后定义三个数据库的实现类：</p>
public</span> class</span> EsDatabase</span> extends</span> AbstractDatabase</span> {</span></span>
</span>
    private</span> final</span> List</span><</span>String</span>></span> dataset</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
</span>
    public</span> EsDatabase</span>(</span>AbstractMediator</span> mediator</span>)</span> {</span></span>
        super</span>(</span>mediator</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> addData</span>(</span>String</span> data</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>ES 添加数据：</span>"</span> +</span> data</span>)</span>;</span></span>
        this</span>.</span>dataset</span>.</span>add</span>(</span>data</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> addDataAndSync</span>(</span>String</span> data</span>)</span> {</span></span>
        addData</span>(</span>data</span>)</span>;</span></span>
        this</span>.</span>mediator</span>.</span>sync</span>(</span>this</span>,</span> data</span>)</span>;</span>    //</span> 数据同步作业交给中介者管理</span></span>
    }</span></span>
</span>
    public</span> void</span> count</span>(</span>)</span> {</span></span>
        int</span> count</span> =</span> this</span>.</span>dataset</span>.</span>size</span>(</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>Elasticsearch 统计，目前有 </span>"</span> +</span> count </span>+</span> "</span> 条数据，数据：</span>"</span> +</span> this</span>.</span>dataset</span>.</span>toString</span>(</span>)</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>public</span> class</span> MysqlDatabase</span> extends</span> AbstractDatabase</span> {</span></span>
    private</span> List</span><</span>String</span>></span> dataset</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
</span>
    public</span> MysqlDatabase</span>(</span>AbstractMediator</span> mediator</span>)</span> {</span></span>
        super</span>(</span>mediator</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> addData</span>(</span>String</span> data</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>Mysql 添加数据：</span>"</span> +</span> data</span>)</span>;</span></span>
        this</span>.</span>dataset</span>.</span>add</span>(</span>data</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> addDataAndSync</span>(</span>String</span> data</span>)</span> {</span></span>
        addData</span>(</span>data</span>)</span>;</span></span>
        this</span>.</span>mediator</span>.</span>sync</span>(</span>this</span>,</span> data</span>)</span>;</span> //</span> 数据同步作业交给中介者管理</span></span>
    }</span></span>
</span>
    public</span> void</span> select</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>Mysql 查询，数据：</span>"</span> +</span> this</span>.</span>dataset</span>.</span>toString</span>(</span>)</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>public</span> class</span> RedisDatabase</span> extends</span> AbstractDatabase</span> {</span></span>
    private</span> List</span><</span>String</span>></span> dataset</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
</span>
    public</span> RedisDatabase</span>(</span>AbstractMediator</span> mediator</span>)</span> {</span></span>
        super</span>(</span>mediator</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> addData</span>(</span>String</span> data</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>Redis 添加数据：</span>"</span> +</span> data</span>)</span>;</span></span>
        this</span>.</span>dataset</span>.</span>add</span>(</span>data</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> addDataAndSync</span>(</span>String</span> data</span>)</span> {</span></span>
        addData</span>(</span>data</span>)</span>;</span></span>
        this</span>.</span>mediator</span>.</span>sync</span>(</span>this</span>,</span> data</span>)</span>;</span>    //</span> 数据同步作业交给中介者管理</span></span>
    }</span></span>
</span>
    public</span> void</span> cache</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>Redis 缓存的数据：</span>"</span> +</span> this</span>.</span>dataset</span>.</span>toString</span>(</span>)</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
然后定义一个中介者接口：</p>
@</span>Data</span></span>
public</span> abstract</span> class</span> AbstractMediator</span> {</span></span>
</span>
    protected</span> MysqlDatabase</span> mysqlDatabase</span>;</span></span>
</span>
    protected</span> RedisDatabase</span> redisDatabase</span>;</span></span>
</span>
    protected</span> EsDatabase</span> esDatabase</span>;</span></span>
</span>
    public</span> abstract</span> void</span> sync</span>(</span>AbstractDatabase</span> sender</span>,</span> String</span> data</span>)</span>;</span></span>
</span>
}</span></span></code></pre>
然后定义一个中介者的实现类：</p>
public</span> class</span> SyncMediator</span> extends</span> AbstractMediator</span> {</span></span>
    @</span>Override</span></span>
    public</span> void</span> sync</span>(</span>AbstractDatabase</span> sender</span>,</span> String</span> data</span>)</span> {</span></span>
        if</span> (</span>sender </span>instanceof</span> MysqlDatabase</span>)</span> {</span></span>
            //</span> mysql 同步到 redis 和 Elasticsearch</span></span>
            this</span>.</span>redisDatabase</span>.</span>addData</span>(</span>data</span>)</span>;</span></span>
            this</span>.</span>esDatabase</span>.</span>addData</span>(</span>data</span>)</span>;</span></span>
        }</span> else</span> if</span> (</span>sender </span>instanceof</span> RedisDatabase</span>)</span> {</span></span>
            //</span> redis 缓存同步，不需要同步到其他数据库</span></span>
        }</span> else</span> if</span> (</span>sender </span>instanceof</span> EsDatabase</span>)</span> {</span></span>
            //</span> Elasticsearch 同步到 Mysql</span></span>
            this</span>.</span>mysqlDatabase</span>.</span>addData</span>(</span>data</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
}</span></span></code></pre>
测试类：</p>
public</span> class</span> Client</span> {</span></span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        AbstractMediator</span> syncMediator</span> =</span> new</span> SyncMediator</span>(</span>)</span>;</span></span>
</span>
        MysqlDatabase</span> mysqlDatabase</span> =</span> new</span> MysqlDatabase</span>(</span>syncMediator</span>)</span>;</span></span>
        RedisDatabase</span> redisDatabase</span> =</span> new</span> RedisDatabase</span>(</span>syncMediator</span>)</span>;</span></span>
        EsDatabase</span> esDatabase</span> =</span> new</span> EsDatabase</span>(</span>syncMediator</span>)</span>;</span></span>
</span>
        syncMediator</span>.</span>setMysqlDatabase</span>(</span>mysqlDatabase</span>)</span>;</span></span>
        syncMediator</span>.</span>setRedisDatabase</span>(</span>redisDatabase</span>)</span>;</span></span>
        syncMediator</span>.</span>setEsDatabase</span>(</span>esDatabase</span>)</span>;</span></span>
</span>
        mysqlDatabase</span>.</span>addDataAndSync</span>(</span>"</span>1</span>"</span>)</span>;</span>  //</span> mysql 添加数据 1，将同步到Redis和ES中</span></span>
        printCurrentData</span>(</span>mysqlDatabase</span>,</span> redisDatabase</span>,</span> esDatabase</span>)</span>;</span></span>
</span>
        redisDatabase</span>.</span>addDataAndSync</span>(</span>"</span>2</span>"</span>)</span>;</span>  //</span> Redis添加数据 2，将不同步到其它数据库</span></span>
        printCurrentData</span>(</span>mysqlDatabase</span>,</span> redisDatabase</span>,</span> esDatabase</span>)</span>;</span></span>
</span>
        esDatabase</span>.</span>addDataAndSync</span>(</span>"</span>3</span>"</span>)</span>;</span>     //</span> ES 添加数据 3，只同步到 Mysql</span></span>
        printCurrentData</span>(</span>mysqlDatabase</span>,</span> redisDatabase</span>,</span> esDatabase</span>)</span>;</span></span>
    }</span></span>
</span>
    private</span> static</span> void</span> printCurrentData</span>(</span>MysqlDatabase</span> mysqlDatabase</span>,</span> RedisDatabase</span> redisDatabase</span>,</span> EsDatabase</span> esDatabase</span>)</span> {</span></span>
        mysqlDatabase</span>.</span>select</span>(</span>)</span>;</span></span>
        redisDatabase</span>.</span>cache</span>(</span>)</span>;</span></span>
        esDatabase</span>.</span>count</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>

从更抽象的层面看，其实就是 N 个组件需要相互调用，但是这样直接调用会导致耦合度过高，调用关系复杂，所以可以使用中介者模式来解决这个问题。
扩展：之前参加某个项目，其中有个组件叫 EBS (Event Bus Service)，各个系统之间的接口不允许互相调用，只能通过 EBS 来调用，这也是一种中介者模式的应用。
但是中介者模式也有缺点，因为所有的交互都集中在了中介者中，中介者会变得很复杂。</p>
</blockquote>
四、参考</h1>

菜鸟教程 - 设计模式</a></li>
Refactoring.Guru 设计模式</a></li>
</ul>


Spring 使用事件监听来解耦代码
2024-02-18T20:41:00+08:00
应用场景</h2>
我就不先放一大堆概念介绍了，先来个示例，一步一步理解。</p>
如有个需求在用户注册成功后给其注册邮箱发送一封邮件</code>，你可能会这样写代码：</p>
public</span> class</span> UserService</span> {</span></span>
</span>
    @</span>Resource</span></span>
    private</span> MailService</span> mailService</span>;</span></span>
</span>
    public</span> void</span> register</span>(</span>User</span> user</span>)</span> {</span></span>
        //</span> 1. 保存用户信息</span></span>
        userRepository</span>.</span>save</span>(</span>user</span>)</span>;</span></span>
        //</span> 2. 发送邮件</span></span>
        mailService</span>.</span>sendMail</span>(</span>user</span>.</span>getEmail</span>(</span>)</span>,</span> "</span>注册成功</span>"</span>,</span> "</span>欢迎注册</span>"</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
但是这样有一些问题，UserService</code> 依赖了 MailService</code>，且如果以后要增加其他的操作，比如发送短信，那么 UserService</code> 就要再次修改，修改为：</p>
public</span> class</span> UserService</span> {</span></span>
</span>
    @</span>Resource</span></span>
    private</span> MailService</span> mailService</span>;</span></span>
    </span></span>
    @</span>Resource</span></span>
    private</span> SmsService</span> smsService</span>;</span></span>
</span>
    public</span> void</span> register</span>(</span>User</span> user</span>)</span> {</span></span>
        //</span> 1. 保存用户信息</span></span>
        userRepository</span>.</span>save</span>(</span>user</span>)</span>;</span></span>
        //</span> 2. 发送邮件</span></span>
        mailService</span>.</span>sendMail</span>(</span>user</span>.</span>getEmail</span>(</span>)</span>,</span> "</span>注册成功</span>"</span>,</span> "</span>欢迎注册</span>"</span>)</span>;</span></span>
        //</span> 3. 发送短信</span></span>
        smsService</span>.</span>sendSms</span>(</span>user</span>.</span>getPhone</span>(</span>)</span>,</span> "</span>注册成功</span>"</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
这样代码就都耦合在一起了，不过我们可以使用 Spring Event</code> 来解耦代码，简单的说就是不再直接调用 MailService</code> 和 SmsService</code>，而是发布一个 用户注册</code> 事件，MailService</code> 和 SmsService</code> 监听这个事件，当事件发生时，执行相应的操作。</p>
首先自定义定义一个事件类 UserRegisterEvent</code> 表示，需要继承 ApplicationEvent</code>：</p>
public</span> class</span> UserRegisterEvent</span> extends</span> ApplicationEvent</span> {</span></span>
</span>
    private</span> final</span> User</span> user</span>;</span></span>
</span>
    public</span> UserRegisterEvent</span>(</span>Object</span> source</span>,</span> User</span> user</span>)</span> {</span></span>
        super</span>(</span>source</span>)</span>;</span></span>
        this</span>.</span>user</span> =</span> user</span>;</span></span>
    }</span></span>
</span>
    public</span> User</span> getUser</span>(</span>)</span> {</span></span>
        return</span> user</span>;</span></span>
    }</span></span>
    </span></span>
}</span></span></code></pre>
我们自定义这个事件中，包含一个 User</code> 对象，用户存储注册的用户信息，其中还有个需要传递个父类 ApplicationEvent</code> 构造函数的 source</code> 参数，这个参数表示事件的来源或事件相关的对象，一会我们会介绍。</p>
然后在 UserService</code> 中使用 ApplicationEventPublisher#publishEvent</code> 来发布一个事件：</p>
public</span> class</span> UserService</span> {</span></span>
</span>
    @</span>Resource</span></span>
    private</span> ApplicationEventPublisher</span> applicationEventPublisher</span>;</span></span>
</span>
    public</span> void</span> register</span>(</span>User</span> user</span>)</span> {</span></span>
        //</span> 1. 保存用户信息</span></span>
        userRepository</span>.</span>save</span>(</span>user</span>)</span>;</span></span>
        //</span> 2. 发布事件</span></span>
        applicationEventPublisher</span>.</span>publishEvent</span>(</span>new</span> UserRegisterEvent</span>(</span>this</span>,</span> user</span>)</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
这里我们将 source</code> 参数传递为 this</code>，表示事件的来源是 UserService</code>。</p>
要接收发生的事件，可以创建一个实现 ApplicationListener</code> 接口的类，并注册为 Spring Bean</code>，如：</p>
@</span>Slf4j</span></span>
@</span>Service</span></span>
public</span> class</span> MailService</span> implements</span> ApplicationListener</span><</span>UserRegisterEvent</span>></span> {</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> onApplicationEvent</span>(</span>UserRegisterEvent</span> event</span>)</span> {</span></span>
        User</span> user</span> =</span> event</span>.</span>getUser</span>(</span>)</span>;</span></span>
        log</span>.</span>info</span>(</span>"</span>MailService: send register mail to {}</span>"</span>,</span> user</span>.</span>getEmail</span>(</span>)</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>@</span>Slf4j</span></span>
@</span>Service</span></span>
public</span> class</span> SmsService</span> implements</span> ApplicationListener</span><</span>UserRegisterEvent</span>></span> {</span></span>
</span>
    @</span>Override</span></span>
    public</span> void</span> onApplicationEvent</span>(</span>UserRegisterEvent</span> event</span>)</span> {</span></span>
        User</span> user</span> =</span> event</span>.</span>getUser</span>(</span>)</span>;</span></span>
        log</span>.</span>info</span>(</span>"</span>SmsService: send register sms to {}</span>"</span>,</span> user</span>.</span>getPhone</span>(</span>)</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
ApplicationListener</code> 的泛型表示了要接收的事件类型。现在调用 UserService#register</code> 方法，其中发布了 UserRegisterEvent</code> 事件，因为 MailService</code> 和 SmsService</code> 监听了这个事件，也会自动执行其 onApplicationEvent</code> 方法中内容。</p>
对于一个事件可以创建任意数量个监听者，但需要注意默认情况下事件监听器会同步接收事件，也就是会阻塞 publishEvent</code> 方法，直到所有事件监听器都执行完毕。这样做有一个好处是当事件发布者需要事务支持时，可以保证所有事件监听器在同一个事务上下文中。</p>
基于注解的事件监听器</h2>
前面我们的事件监听器都是通过实现 ApplicationListener</code> 接口来实现的，但是如果一个类要监听多个事件（如再监听用户登录事件），现有的方法就不太适用了，这时可以改为使用 @EventListener</code> 注解来监听事件。</p>
以 MailService</code> 为例:</p>
import</span> org</span>.</span>springframework</span>.</span>context</span>.</span>event</span>.</span>EventListener</span>;</span></span>
</span>
@</span>Slf4j</span></span>
@</span>Service</span></span>
public</span> class</span> MailService</span> {</span></span>
</span>
    @</span>EventListener</span></span>
    public</span> void</span> onUserRegisterEvent</span>(</span>UserRegisterEvent</span> event</span>)</span> {</span></span>
        User</span> user</span> =</span> event</span>.</span>getUser</span>(</span>)</span>;</span></span>
        log</span>.</span>info</span>(</span>"</span>MailService: send register mail to {}</span>"</span>,</span> user</span>.</span>getEmail</span>(</span>)</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
如果你需要一个方法监听多个事件，或你想要一个不带参数的方法，也可以在注解中指定事件类型，如：</p>
@</span>EventListener</span>(</span>{</span>AEvent</span>.</span>class</span>,</span> BEvent</span>.</span>class</span>}</span>)</span></span>
public</span> void</span> onEvent</span>(</span>)</span> {</span></span>
    //</span> doSomething</span></span>
}</span></span></code></pre>
还可以使用注解中的 condition</code> 属性写 SpEL</code> 表达式来过滤事件，如：</p>
@</span>EventListener</span>(</span>condition</span> =</span> "</span>userRegisterEvent.user.phone.startsWith(</span>\"</span>138</span>\"</span>)</span>"</span>)</span></span>
public</span> void</span> onUserRegisterEvent</span>(</span>UserRegisterEvent</span> userRegisterEvent</span>)</span> {</span></span>
    //</span> doSomething</span></span>
}</span></span></code></pre>
这样我们就可以只处理手机号以 138</code> 开头的用户注册事件。</p>
如果你想要在一个事件结束后触发另一个或多个其他事件，可以修改方法签名，将其返回值改为要发布的事件，如：</p>
@</span>EventListener</span></span>
public</span> UserRegisterAfterEvent</span> onUserRegisterEvent</span>(</span>UserRegisterEvent</span> event</span>)</span> {</span></span>
    //</span> doSomething</span></span>
    return</span> new</span> UserRegisterAfterEvent</span>(</span>this</span>,</span> user</span>)</span>;</span></span>
}</span></span></code></pre>
需要发布多个事件的话，可以通过返回 Collection</code> 或数组来实现。</p>
事件异步监听器</h2>
如果你想要一个特定的监听器以异步的方式处理事件，可以在其方法上增加 @Async</code>，如：</p>
@</span>Async</span></span>
@</span>EventListener</span></span>
public</span> void</span> onUserRegisterEvent</span>(</span>UserRegisterEvent</span> userRegisterEvent</span>)</span> {</span></span>
    //</span> doSomething</span></span>
}</span></span></code></pre>
但是这样有几个限制：</p>

如果一个异步的事件监听器发生异常，他不会被传播给调用者。</li>
异步事件监听器不能通过 return 事件来发布其他事件，但可以通过 ApplicationEventPublisher</code> 手动发布。</li>
如果事件发布者在是事务性的，异步事件监听器不会在同一个事务上下文中执行。</li>
</ul>
事件监听顺序</h2>
如果你有多个监听器监听同一个事件，你可能会想要控制它们的执行顺序，可以使用 @Order</code> 注解，如：</p>
@</span>Order</span>(</span>10</span>)</span></span>
@</span>EventListener</span></span>
public</span> void</span> onUserRegisterEvent</span>(</span>UserRegisterEvent</span> userRegisterEvent</span>)</span> {</span></span>
    //</span> doSomething</span></span>
}</span></span></code></pre>
每个 Spring Bean</code> 默认的 Order</code> 值是 Integer.MAX_VALUE</code>，你可以使用 @Order</code> 注解来指定一个值，值越小，优先级越高。</p>
事务监听的泛型限制</h2>
你可以使用泛型来限制事件监听器只监听特定类型的事件，如有一个 EntityCreatedEvent<T></code>，你想要只监听 EntityCreatedEvent<User></code>，可以使用：</p>
@</span>EventListener</span></span>
public</span> void</span> onUserCreated</span>(</span>EntityCreatedEvent</span><</span>User</span>></span> event</span>)</span> {</span></span>
    //</span> ...</span></span>
}</span></span></code></pre>
不过由于 Java 的泛型擦除，你需要这样创建 class UserCreatedEvent extends EntityCreatedEvent<User> { … }</code>，然后发布事件时使用 UserCreatedEvent</code>，才能被上面的监听器监听到。</p>
但如果每个泛型事件都需要创建一个新的类，这样会显得很麻烦，所以 Spring</code> 提供了一个 ResolvableType</code> 类来解决这个问题，如：</p>
public</span> class</span> EntityCreatedEvent</span><</span>T</span>></span> extends</span> ApplicationEvent</span> implements</span> ResolvableTypeProvider</span> {</span></span>
</span>
    public</span> EntityCreatedEvent</span>(</span>T</span> entity</span>)</span> {</span></span>
        super</span>(</span>entity</span>)</span>;</span></span>
    }</span></span>
</span>
    @</span>Override</span></span>
    public</span> ResolvableType</span> getResolvableType</span>(</span>)</span> {</span></span>
        return</span> ResolvableType</span>.</span>forClassWithGenerics</span>(</span>getClass</span>(</span>)</span>,</span> ResolvableType</span>.</span>forInstance</span>(</span>getSource</span>(</span>)</span>)</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>基于事务不同阶段的事件</h2>
前面的例子中，我们的事件和调用方在同一个事务中执行，但是有时我们想在事务提交后执行一些操作，这时可以使用 @TransactionalEventListener</code> 注解，它相较于 @EventListener</code> 多了一些属性，如：</p>
@</span>Target</span>(</span>{</span>ElementType</span>.</span>METHOD</span>,</span> ElementType</span>.</span>ANNOTATION_TYPE</span>}</span>)</span></span>
@</span>Retention</span>(</span>RetentionPolicy</span>.</span>RUNTIME</span>)</span></span>
@</span>Documented</span></span>
@</span>EventListener</span></span>
public</span> @</span>interface</span> TransactionalEventListener</span> {</span></span>
</span>
	/*</span>*</span></span>
	 * Phase to bind the handling of an event to.</span></span>
	 * <p>The default phase is {@link TransactionPhase#AFTER_COMMIT}.</span></span>
	 * <p>If no transaction is in progress, the event is not processed at</span></span>
	 * all unless {@link #fallbackExecution} has been enabled explicitly.</span></span>
	 */</span></span>
	TransactionPhase</span> phase</span>(</span>)</span> default</span> TransactionPhase</span>.</span>AFTER_COMMIT</span>;</span></span>
</span>
	/*</span>*</span></span>
	 * Whether the event should be handled if no transaction is running.</span></span>
	 */</span></span>
	boolean</span> fallbackExecution</span>(</span>)</span> default</span> false</span>;</span></span>
    </span></span>
    省略其他和 </span>@</span>EventListener</span> 一样的属性</span>.</span>.</span>.</span>.</span>.</span>.</span></span>
}</span></span></code></pre>
先来看看 TransactionPhase</code> 枚举：</p>
public</span> enum</span> TransactionPhase</span> {</span></span>
    //</span> 指定目标方法在事务commit之前执行</span></span>
    BEFORE_COMMIT</span>,</span></span>
    </span></span>
    //</span> 指定目标方法在事务commit之后执行</span></span>
    AFTER_COMMIT</span>,</span></span>
    </span></span>
    //</span> 指定目标方法在事务rollback之后执行</span></span>
    AFTER_ROLLBACK</span>,</span></span>
    </span></span>
    //</span> 指定目标方法在事务完成时执行，这里的完成是指无论事务是成功提交还是事务回滚了</span></span>
    AFTER_COMPLETION</span></span>
}</span></span></code></pre>
我们使用 @EventListener</code> 注解时，效果等同于 BEFORE_COMMIT</code>，也就是执行完所有事件才提交事务。现在我们可以自己控制事件的执行时机了。</p>
但是因为它是基于事务的，所以如果没有事务在运行，事件是不会被处理的，除非你设置了 @TransactionalEventListener</code> 的 fallbackExecution</code> 属性为 true</code>，即表示没有事务在运行，也会执行事件。否则事件将会被丢弃，不会执行。</p>
参考资料</h2>

Spring Docs - Standard and Custom Events</a></li>
Spring解决泛型擦除的思路不错，现在它是我的了。</a></li>
@TransactionalEventListener的使用和实现原理</a></li>
TransactionalEventListener使用场景以及实现原理，最后要躲个大坑</a></li>
</ul>


VIM 常用操作
2023-12-25T21:33:00+08:00
VIM 常用操作</h1>
本文是使用 vimtutor</code> 对 vim</code> 的学习总结，vimtutor</code> 命令是 VIM 自带的一个教程，推荐使用它来学习 VIM，它会带你一步一步学习 VIM 的基本操作。</p>
进入 VIM</h2>
可通过 vi filename</code> 或 vim filename</code> 命令打开文件，如果文件不存在则会新建一个文件。</p>

大部分 Linux 发行版都会默认安装 VIM，且 vi</code> 命令会指向 vim</code> 命令，所以 vi</code> 和 vim</code> 命令是等价的。但为了避免不同发行版的差异，建议使用 vim</code> 命令。</p>
</blockquote>
退出 VIM</h2>

:q</code> 退出 VIM</li>
:q!</code> 强制退出 vim 不保存修改的内容</li>
:w</code> 保存修改，但不退出 VIM。</li>
:wq</code> 保存修改并退出 VIM。</li>
:w filename</code> 将修改保存到 filename 文件中，但不退出 VIM。</li>
:wq! filename</code> 将当前正在编辑的文件保存到 filename 文件中，并退出 VIM，忽略对当前文件的修改。</li>
</ul>
进入编辑模式</h2>
在 VIM 中，可以通过 i</code> 命令进入编辑模式，此时可以对文件进行编辑。</p>

i</code> 在当前光标所在位置进入编辑模式</li>
I</code> 在当前行的第一个字符进入编辑模式</li>
a</code> 在当前光标所在位置的下一个字符进入编辑模式</li>
A</code> 在当前行的最后一个字符进入编辑模式</li>
o</code> 在当前行的下一行插入一个新行，并进入编辑模式</li>
O</code> 在当前行的上一行插入一个新行，并进入编辑模式</li>
</ul>
退出编辑模式</h2>
在 VIM 中，可以通过 ESC</code> 键退出编辑模式。这时是命令模式，可以输入命令。</p>
命令模式</h2>
移动光标</h3>
在 VIM 中，可以通过 h</code> j</code> k</code> l</code> 键移动光标，分别对应左、下、上、右。</p>
删除字符</h3>
字符删除</strong>：</p>

x</code> 删除光标所在位置的字符</li>
X</code> 删除光标所在位置的前一个字符</li>
</ul>
单词删除：</strong></p>

dw</code> 删除光标所在位置到下</strong>一个单词开头的字符，包括空格</strong> (注记：delete word</code>)</li>
db</code> 删除光标所在位置到上</strong>一个单词开头的字符，包括空格</strong> (注记：delete back</code>)</li>
de</code> 删除光标所在位置到下</strong>一个单词结尾的字符 (注记：delete end</code>)</li>
dd</code> 删除光标所在行</li>
d$</code> 删除光标所在位置到行尾的字符</li>
</ul>

删除命令都会将删除的内容存入剪贴板，可以通过下文的粘贴命令将剪贴板的内容粘贴到文件中。</p>
</blockquote>
复制粘贴</h3>

yy</code> 复制光标所在行</li>
yw</code> 复制光标所在位置到下</strong>一个单词开头的字符，包括空格</strong> (注记：yank word</code>)</li>
p</code> 粘贴剪贴板内容到光标所在行的下一行 (注记：paste</code>)</li>
P</code> 粘贴剪贴板内容到光标所在行的上一行</li>
</ul>
还可以使用 v</code> 进入可视模式，然后使用 h</code> j</code> k</code> l</code> 键移动光标，选中一段文本，然后按 y</code> 复制选中的文本，再根据需要使用 p</code> 或 P</code> 粘贴。(有点像鼠标拖拽选中文本，然后复制粘贴)</p>
撤销重做</h3>

u</code> 撤销上一次操作</li>
Ctrl + r</code> 重做被撤销的操作，或者说撤销撤销操作</li>
U</code> 撤销对整行的修改</li>
.</code> 重复上一次修改</li>
</ul>
查找替换</h3>
查找：</strong></p>

/word</code> 查找 word 字符串，按 n</code> 查找下一个，按 N</code> 查找上一个，如果想逆向查找，可以使用 ?word</code> 命令</li>
:set ic</code> 查找时忽略大小写 (ignore case)</li>
:set is</code> 查找时显示匹配的字符串 (ignore case)</li>
:set hls</code> 查找时高亮显示匹配的字符串 (highlight search)</li>
</ul>
查找括号匹配：</strong></p>

%</code> 查找括号匹配，如 ()</code> []</code> {}</code>，光标放在括号上，按 %</code> 可以跳转到匹配的括号上</li>
:set showmatch</code> 设置括号匹配高亮</li>
</ul>
替换：</strong></p>

r</code> 按下 r 后输入一个字符，将光标所在位置的字符替换为输入的字符</li>
R</code> 按下 R 后进入替换模式，每输入一个字符，将光标所在位置的字符替换为输入的字符，并向右移动一个字符。按 ESC</code> 退出替换模式</li>
ce</code> 删除光标所在位置到下</strong>一个单词结尾的字符，并进入编辑模式</li>
c$</code> 删除光标所在位置到行尾的字符，并进入编辑模式</li>
:s/old/new</code> 将当前行第一个 old 替换为 new</li>
:s/old/new/g</code> 将当前行所有 old 替换为 new (其中 g</code> 为 global 的意思)</li>
:%s/old/new/g</code> 将所有行所有 old 替换为 new</li>
:%s/old/new/gc</code> 将所有行所有 old 替换为 new，替换前询问是否替换 (其中 c</code> 为 confirm 的意思)</li>
:n1,n2s/old/new/g</code> 将第 n1 行到第 n2 行所有 old 替换为 new</li>
</ul>
移动光标</h3>

0</code> 移动光标到行首</li>
$</code> 移动光标到行尾</li>
gg</code> 移动光标到文件首</li>
G</code> 移动光标到文件尾</li>
nG</code> 移动光标到第 n 行, 如 10G</code> 移动光标到第 10 行</li>
n+</code> 光标向下</strong>移动 n 行, 如 10+</code> 光标向下移动 10 行</li>
n-</code> 光标向上</strong>移动 n 行, 如 10-</code> 光标向上移动 10 行</li>
n<space></code> 光标向右</strong>移动 n 个字符, 如 10<space></code> 光标向右移动 10 个字符</li>
n<enter></code> 光标向下</strong>移动 n 行, 如 10<enter></code> 光标向下移动 10 行</li>
w</code> 光标向右</strong>移动一个单词，注记：word</code></li>
b</code> 光标向左</strong>移动一个单词，注记：back</code></li>
e</code> 光标向右</strong>移动到单词结尾，注记：end</code></li>
</ul>
文本编辑 - 自由编辑</h3>
可以通过 i</code> 命令进入编辑模式，此时可以对文件进行编辑。</p>
文本编辑 - 添加</h3>
还可以通过 A</code> 命令进入编辑模式，此时光标在当前字符的后面，可以对文件进行编辑。注意，这种模式下，无法进行删除操作。</p>
命令量化</h3>
vim 指令中很多命令都可以量化，如删除字符, 删除行，向某个方向移动光标等，可以量化为删除多少个字符，删除多少行，向某个方向移动多少个字符等。对于这些命令，可以在命令前加上数字，如 10dd</code> 删除 10 行，10w</code> 向右移动 10 个单词，10b</code> 向左移动 10 个单词，10e</code> 向右移动 10 个单词到单词结尾，10+</code> 光标向下移动 10 行，10-</code> 光标向上移动 10 行，10<space></code> 光标向右移动 10 个字符，10<enter></code> 光标向下移动 10 行。</p>
执行外部命令</h3>
可以通过 :!command</code> 执行外部命令，如 :!ls</code> 执行 ls</code> 命令，:!date</code> 执行 date</code> 命令。这样可以在 VIM 中执行外部命令，执行完后会返回 VIM，不会退出 VIM。</p>
状态</h3>

Ctrl + g</code> 显示当前编辑文件的状态，包括文件名，文件状态，总行数，当前行号，光标位置百分比，当前所处列号，如：</li>
</ul>
"</span>/tmp/tutoralicW3</span>"</span> [已修改</span>] 行 300 / 995 --30%-- 列 8-29                                                                                                                                                                  </span></span></code></pre>辅助命令</h3>

:set number</code> 显示行号</li>
</ul>

在选项前增加 no 可以关闭选项，如 :set nonumber</code></p>
</blockquote>


Linux LVM 磁盘管理
2023-12-20T20:11:00+08:00
Linux-LVM 磁盘管理</h1>
1. LVM简介</h2>
LVM(Logical Volume Manager)逻辑卷管理器，是一种磁盘管理技术，它将一个或多个物理磁盘组合成一个逻辑卷，用户可以在逻辑卷上创建文件系统，就像在普通磁盘上创建文件系统一样。LVM的主要优点是可以在不停机的情况下对磁盘进行扩容，缩容，快照等操作。</p>
简单来说，就是 LVM 可以很方便的对硬盘进行扩容，缩容操作。</p>
2. LVM的基本概念</h2>
LVM 有几个重要概念，从上到下依次为：</p>

PV(Physical Volume) 物理卷，可以是硬盘，也可以是分区</strong>。</li>
VG(Volume Group) 卷组，由一个或多个物理卷组成，可以理解为硬盘池。</li>
LV(Logical Volume) 逻辑卷，由卷组分出来的逻辑磁盘，可以理解为虚拟硬盘。最终也是将它挂载到文件系统上。</li>
PE(Physical Extent) 物理区块，物理卷和逻辑卷的最小单位，一般为4M。</li>
LE(Logical Extent) 逻辑区块，逻辑卷的最小单位，一般为4M。</li>
</ul>
PV、VG、LV的关系如下图所示：</p>
</p>
3. LVM的基本操作</h2>
3.1. 创建物理卷 PV</h3>
首先可以使用 fdisk -l</code> 或者 lsblk</code> 查看当前系统的磁盘信息，如下图所示 (lsblk)：</p>

lsblk</code> 是 List block devices</code> 的缩写。</p>
</blockquote>
☁</span>  ~</span>  lsblk</span></span>
NAME</span>   MAJ:MIN</span> RM</span>  SIZE</span> RO</span> TYPE</span> MOUNTPOINTS</span></span>
sda</span>      8:0</span>    0</span>   10G</span>  0</span> disk</span> </span></span>
sdb</span>      8:16</span>   0</span>   40G</span>  0</span> disk</span> </span></span>
├─sdb1</span>   8:17</span>   0</span>   39G</span>  0</span> part</span> /</span></span>
├─sdb2</span>   8:18</span>   0</span>    1K</span>  0</span> part</span> </span></span>
└─sdb5</span>   8:21</span>   0</span>  975M</span>  0</span> part</span> [SWAP</span>]</span></span>
sr0</span>     11:0</span>    1</span>  628M</span>  0</span> rom</span>  </span></span></code></pre>
可以看到当前系统有两块磁盘，sda 和 sdb，sda 为 10G，sdb 为 40G，sda 上没有分区，sdb1 为系统根目录，sdb5 为交换分区。</p>
这里我们使用 sda 创建一个物理卷 PV，使用 pvcreate</code> 命令，如下所示：</p>
☁</span>  ~</span>  sudo</span> pvcreate</span> /dev/sda</span></span>
  Physical</span> volume</span> "</span>/dev/sda</span>"</span> successfully</span> created.</span></span></code></pre>
使用 pvdisplay</code> 命令查看物理卷信息，如下所示：</p>
☁</span>  ~</span>  pvdisplay</span></span>
  "</span>/dev/sda</span>"</span> is</span> a</span> new</span> physical</span> volume</span> of</span> "</span>10.00 GiB</span>"</span></span>
  ---</span> NEW</span> Physical</span> volume</span> -</span>--</span></span>
  PV</span> Name</span>               /dev/sda</span></span>
  VG</span> Name</span>               </span></span>
  PV</span> Size</span>               10.00</span> GiB</span></span>
  Allocatable</span>           NO</span></span>
  PE</span> Size</span>               0</span>   </span></span>
  Total</span> PE</span>              0</span></span>
  Free</span> PE</span>               0</span></span>
  Allocated</span> PE</span>          0</span></span>
  PV</span> UUID</span>               B6J2T7-qV44-6gJq-vMWB-Aev8-xsQP-psPd3u</span></span></code></pre>
可以看到，sda 已经创建为物理卷 PV，但是还没有分配给任何卷组 VG。</p>

除了可直接对设备创建 PV，还可以对分区，也就是说允许一个硬盘创建两个分区，其中一个进行 PV，一个不进行，甚至两个分区可所属不同的 PV。</p>
</blockquote>
3.2. 创建卷组 VG</h3>
使用 vgcreate</code> 命令创建卷组 VG，如下所示：</p>
☁</span>  ~</span>  vgcreate</span> vg1</span> /dev/sda</span></span>
  Volume</span> group</span> "</span>vg1</span>"</span> successfully</span> created</span></span></code></pre>
使用 vgdisplay</code> 命令查看卷组信息，如下所示：</p>
☁</span>  ~</span>  vgdisplay</span>            </span></span>
  ---</span> Volume</span> group</span> -</span>--</span></span>
  VG</span> Name</span>               vg1</span></span>
  System</span> ID</span>             </span></span>
  Format</span>                lvm2</span></span>
  Metadata</span> Areas</span>        1</span></span>
  Metadata</span> Sequence</span> No</span>  1</span></span>
  VG</span> Access</span>             read/write</span></span>
  VG</span> Status</span>             resizable</span></span>
  MAX</span> LV</span>                0</span>             #</span> 最大逻辑卷数量，0 为无限制</span></span>
  Cur</span> LV</span>                0</span>             #</span> 当前逻辑卷数量</span></span>
  Open</span> LV</span>               0</span>             #</span> 当前打开的逻辑卷数量</span></span>
  Max</span> PV</span>                0</span>             #</span> 最大物理卷数量，0 为无限制</span></span>
  Cur</span> PV</span>                1</span>             #</span> 当前物理卷数量</span></span>
  Act</span> PV</span>                1</span>             #</span> 活动物理卷数量</span></span>
  VG</span> Size</span>               <</span>10.00</span> GiB</span>    #</span> 整个 VG 的容量大小</span></span>
  PE</span> Size</span>               4.00</span> MiB</span>      #</span> 每个 PE 的大小</span></span>
  Total</span> PE</span>              2559</span>          #</span> 总共有多少个 PE</span></span>
  Alloc</span> PE</span> /</span> Size</span>       0</span> /</span> 0</span>         #</span> 已经分配的 PE / 大小</span></span>
  Free</span>  PE</span> /</span> Size</span>       2559</span> /</span> <</span>10.00</span> GiB</span> #</span> 剩余可分配的 PE / 大小</span></span>
  VG</span> UUID</span>               PpCCuU-slml-5fF0-YxJe-I6bk-3rS0-3ePNyq</span></span></code></pre>
主要可以看到，卷组 VG 的名称为 vg1，卷组大小为 10G，PE 大小为 4M，总共有 2559 个 PE，当前没有分配给任何逻辑卷 LV。</p>
再通过 pvdisplay</code> 命令查看物理卷信息，如下所示：</p>
☁</span>  ~</span>  pvdisplay</span></span>
  ---</span> Physical</span> volume</span> -</span>--</span></span>
  PV</span> Name</span>               /dev/sda</span></span>
  VG</span> Name</span>               vg1</span></span>
  PV</span> Size</span>               10.00</span> GiB</span> /</span> not</span> usable</span> 4.00</span> MiB</span></span>
  Allocatable</span>           yes</span> </span></span>
  PE</span> Size</span>               4.00</span> MiB</span></span>
  Total</span> PE</span>              2559</span></span>
  Free</span> PE</span>               2559</span></span>
  Allocated</span> PE</span>          0</span></span>
  PV</span> UUID</span>               B6J2T7-qV44-6gJq-vMWB-Aev8-xsQP-psPd3u</span></span></code></pre>
这次可以看到，VG Name 已经显示为 vg1，说明物理卷已经分配给了卷组。</p>
3.3. 创建逻辑卷 LV</h3>
使用 lvcreate</code> 命令创建逻辑卷 LV，如下所示：</p>
☁</span>  ~</span>  lvcreate</span> -</span>L</span> 5G</span> -</span>n</span> lv1</span> vg1</span></span>
  Logical</span> volume</span> "</span>lv1</span>"</span> created.</span></span></code></pre>
其中 -L 为逻辑卷大小，-n 为逻辑卷名称，vg1 为逻辑卷所在的卷组。(也可以使用 -l 参数指定 PE 数量，如 -l 1280)</p>
使用 lvdisplay</code> 命令查看逻辑卷信息，如下所示：</p>
☁</span>  ~</span>  lvdisplay</span></span>
  ---</span> Logical</span> volume</span> -</span>--</span></span>
  LV</span> Path</span>                /dev/vg1/lv1</span></span>
  LV</span> Name</span>                lv1</span></span>
  VG</span> Name</span>                vg1</span></span>
  LV</span> UUID</span>                sy8J15-Tzuw-1J8P-UCqc-0gbF-wdHl-L8Zmfu</span></span>
  LV</span> Write</span> Access</span>        read/write</span></span>
  LV</span> Creation</span> host,</span> time</span> debian,</span> 2023-12-18</span> 10:53:05</span> +0800</span></span>
  LV</span> Status</span>              available</span></span>
  #</span> open                 0</span></span>
  LV</span> Size</span>                5.00</span> GiB</span></span>
  Current</span> LE</span>             1280</span></span>
  Segments</span>               1</span></span>
  Allocation</span>             inherit</span></span>
  Read</span> ahead</span> sectors</span>     auto</span></span>
  -</span> currently</span> set</span> to</span>     256</span></span>
  Block</span> device</span>           254:0</span></span></code></pre>3.4. 创建文件系统</h3>
使用 mkfs.ext4</code> 命令创建文件系统，如下所示：</p>
☁</span>  ~</span>  mkfs.ext4</span> /dev/vg1/lv1</span></span>
mke2fs</span> 1.47.0</span> (5-Feb-2023</span>)</span></span>
Creating</span> filesystem</span> with</span> 1310720</span> 4k</span> blocks</span> and</span> 327680</span> inodes</span></span>
Filesystem</span> UUID:</span> a52d69bd-1b39-41ee-a669-104e6dbec1ae</span></span>
Superblock</span> backups</span> stored</span> on</span> blocks:</span> </span></span>
	32768,</span> 98304,</span> 163840,</span> 229376,</span> 294912,</span> 819200,</span> 884736</span></span>
</span>
Allocating</span> group</span> tables:</span> done</span>                            </span></span>
Writing</span> inode</span> tables:</span> done</span>                            </span></span>
Creating</span> journal</span> (16384</span> blocks</span>): </span>done</span></span>
Writing</span> superblocks</span> and</span> filesystem</span> accounting</span> information:</span> done</span></span></code></pre>3.5. 挂载文件系统</h3>
在挂载文件系统前，需要创建一个挂载点，也就是一个空的目录，我这里使用 /mnt</code> 作为挂载点，然后使用 mount</code> 命令挂载文件系统，如下所示：</p>
mkdir</span> /mnt</span></span>
mount</span> /dev/vg1/lv1</span> /mnt</span></span></code></pre>
然后通过 df -h</code> 命令查看挂载情况，如下所示：</p>
☁</span>  ~</span>  df</span> -</span>h</span> </span></span>
文件系统</span>             大小</span>  已用</span>  可用</span> 已用%</span> 挂载点</span></span>
udev</span>                 3.9G</span>     0</span>  3.9G</span>    0%</span> /dev</span></span>
tmpfs</span>                791M</span>  768K</span>  790M</span>    1%</span> /run</span></span>
/dev/sdb1</span>             39G</span>   14G</span>   23G</span>   38%</span> /</span></span>
tmpfs</span>                3.9G</span>     0</span>  3.9G</span>    0%</span> /dev/shm</span></span>
tmpfs</span>                5.0M</span>     0</span>  5.0M</span>    0%</span> /run/lock</span></span>
tmpfs</span>                791M</span>     0</span>  791M</span>    0%</span> /run/user/0</span></span>
/dev/mapper/vg1-lv1</span>  4.9G</span>   24K</span>  4.6G</span>    1%</span> /mnt</span></span></code></pre>
可以看到，逻辑卷已经挂载到了 /mnt</code> 目录下。然后再通过 lsblk</code> 命令查看磁盘信息，如下所示：</p>
☁</span>  ~</span>  lsblk</span></span>
NAME</span>      MAJ:MIN</span> RM</span>  SIZE</span> RO</span> TYPE</span> MOUNTPOINTS</span></span>
sda</span>         8:0</span>    0</span>   10G</span>  0</span> disk</span> </span></span>
└─vg1-lv1</span> 254:0</span>    0</span>    5G</span>  0</span> lvm</span>  /mnt</span></span>
sdb</span>         8:16</span>   0</span>   40G</span>  0</span> disk</span> </span></span>
├─sdb1</span>      8:17</span>   0</span>   39G</span>  0</span> part</span> /</span></span>
├─sdb2</span>      8:18</span>   0</span>    1K</span>  0</span> part</span> </span></span>
└─sdb5</span>      8:21</span>   0</span>  975M</span>  0</span> part</span> [SWAP</span>]</span></span>
sr0</span>        11:0</span>    1</span>  628M</span>  0</span> rom</span>  </span></span></code></pre>
如果现在是临时挂载，重启后会失效，如果要永久挂载，需要修改 /etc/fstab</code> 文件，添加如下内容：</p>
/dev/vg1/lv1</span> /mnt</span> ext4</span> defaults</span> 0</span> 0</span></span></code></pre>3.6. 扩容逻辑卷 LV</h3>
我们的 /dev/sda</code> 磁盘大小为 10G，但是我们只使用了 5G，还有 5G 的空间没有使用，这时候我们就可以对逻辑卷进行扩容，使用 lvextend</code> 命令扩容逻辑卷，如下所示：</p>
☁</span>  ~</span>  lvextend</span> -</span>r</span> -</span>L</span> +1G</span> /dev/vg1/lv1</span> </span></span>
  Size</span> of</span> logical</span> volume</span> vg1/lv1</span> changed</span> from</span> 5.00</span> GiB</span> (1280</span> extents</span>) to 6.00 GiB (</span>1536</span> extents</span>).</span></span>
  Logical</span> volume</span> vg1/lv1</span> successfully</span> resized.</span></span></code></pre>
其中 -r</code> 为自动缩容文件系统，不需要手动执行 resize2fs</code>, -L +1G</code> 为扩容 1G</code>，如果要扩容到 10G</code>，可以使用 -L 10G</code>。</p>
然后再通过 df -h</code> 命令查看挂载情况，如下所示：</p>
☁</span>  ~</span>  df</span> -</span>h</span></span>
文件系统</span>             大小</span>  已用</span>  可用</span> 已用%</span> 挂载点</span></span>
udev</span>                 3.9G</span>     0</span>  3.9G</span>    0%</span> /dev</span></span>
tmpfs</span>                791M</span>  768K</span>  790M</span>    1%</span> /run</span></span>
/dev/sdb1</span>             39G</span>   14G</span>   23G</span>   38%</span> /</span></span>
tmpfs</span>                3.9G</span>     0</span>  3.9G</span>    0%</span> /dev/shm</span></span>
tmpfs</span>                5.0M</span>     0</span>  5.0M</span>    0%</span> /run/lock</span></span>
tmpfs</span>                791M</span>     0</span>  791M</span>    0%</span> /run/user/0</span></span>
/dev/mapper/vg1-lv1</span>  5.9G</span>   24K</span>  5.6G</span>    1%</span> /mnt</span></span></code></pre>3.7. 缩容逻辑卷 LV</h3>
缩容要复杂一些，步骤如下：</p>

卸载文件系统：umount /mnt</code></li>
检查文件系统：e2fsck -f /dev/vg1/lv1</code>, -f</code> 为强制进行检查</li>
缩小逻辑卷至 5G：lvreduce -r -L 5G /dev/vg1/lv1</code>，其中 -r</code> 为自动缩容文件系统，不需要手动执行 resize2fs</code>。如果想要缩小到可用空间的最小值，可以使用 -l -1</code> 参数，如 lvreduce -r -l -1 /dev/vg1/lv1</code>。</li>
再次检查文件系统：e2fsck -f /dev/vg1/lv1</code></li>
挂载文件系统：mount /dev/vg1/lv1 /mnt</code></li>
检查文件系统大小：df -h</code></li>
</ol>

其中使用 lvreduce</code> 命令缩容逻辑卷时，有以下两种方式：</p>

-L -1G</code> 缩容 1G，如原来为 6G，缩容后为 5G</li>
-L 1G</code> 缩容至 1G，如原来为 6G，缩容后为 1G</li>
</ul>
</blockquote>
如果想要缩容至可用空间的最小值</strong>，可以先通过 resize2fs -P /dev/vg1/lv1</code> 查看预估的最小值，如：</p>
☁</span>  ~</span>  resize2fs</span> -</span>P</span> /dev/vg1/lv1</span>                  </span></span>
</span>
resize2fs</span> 1.47.0</span> (5-Feb-2023</span>)</span></span>
Estimated</span> minimum</span> size</span> of</span> the</span> filesystem:</span> 573865</span></span></code></pre>
这里返回的 573865 的单位是块 (block)，查看每个块的大小可通过命令：tune2fs -l /dev/vg1/lv1 | grep "Block size"</code>，如:</p>
~</span>   tune2fs -l /dev/vg1/lv1 </span>|</span> grep</span> "</span>Block size</span>"</span></span>
Block</span> size:</span>               4096</span></span></code></pre>
这里返回的 4096 的单位是字节，通过计算 $573865 * 4096 = 2350551040 / 1024 / 1024 / 1024$ 可得约 2.18912G</code>。为了安全，向上取整，可缩容为 2.19G</code> 或 2.2G</code>。</p>
3.8. 扩容卷组 VG</h3>
如我们现在的空间不够了，新加了一块 10G 的硬盘, 通过 lsblk</code> 命令查看到新加的硬盘为 /dev/sdc</code>。</p>
然后我们先将 /dev/sdc</code> 创建为物理卷 PV，然后将这个物理卷添加到先前创建的卷组 vg1 中（也可以创建一个新的卷组），如下所示：</p>
pvcreate</span> /dev/sdc</span></span>
vgextend</span> vg1</span> /dev/sdc</span></span></code></pre>
这样现在 vg1 的大小就变成了 20G。</p>
3.9. 缩容卷组 VG</h3>
如我们觉得硬盘/分区有太多空闲，想去掉一块硬盘/分区，或者想更换硬盘（去掉旧的 PV 再添加新的 PV），可以进行缩容，但为了保证数据不丢失，需要先让卷组中有足够的空间来把要删除的 PV 中的数据迁移出去，然后再移除 PV。</p>
如我们想要从 vg1</code> 中移除 /dev/sda</code>，步骤如下：</p>

检查卷组是否有足够的剩余空间可用于迁移数据，如果没有则需要减少分配给 LV 的空间或者扩容当前 VG。</li>
执行 pvmove vg1 /dev/sda</code> 来从 vg1 上移除 /dev/sda</code>。如果未进行第一步的话，这里会提示 Physical volume "/dev/sda" still in use</code></li>
根据需要选择是否执行 pvremove /dev/sda</code> 将它从 PV 中移除（如果不再使用，则需要执行这一步）</li>
使用 vgdisplay</code> 检查 vg 大小是否变化</li>
</ol>
3.10 删除 LV VG PV</h3>
删除 LV：</p>
lvremove</span> /dev/vg1/lv1</span></span></code></pre>
删除 VG：</p>
vgremove</span> vg1</span></span></code></pre>
删除 PV：</p>
pvremove</span> /dev/sda</span></span></code></pre>4. LVM 快照</h2>
4.1 简介</h3>
LVM 快照是一种特殊的逻辑卷，它是对原始逻辑卷的一个快照，刚创建快照时，其实快照卷中并没有存储原始逻辑卷的数据，只有当原始逻辑卷的数据发生变化时，才会复制原始逻辑卷被修改的原数据到快照中，这样原始逻辑卷被修改，但对应的快照卷记录了修改前的数据，这样就可以通过快照卷恢复到修改前的状态。
还需要注意的是快照卷的大小，建议快照卷的大小和原始逻辑卷的大小一样，如果快照卷的大小小于原始逻辑卷的大小，当原始逻辑卷的数据发生变化较多的时，可能没有空间来存储原始逻辑卷的原数据。大于原始逻辑卷的大小也是没有意义的，因为快照卷只记录原始逻辑卷的原数据，肯定永远都不会超过原始逻辑卷的大小。</p>
4.2 创建快照</h3>
创建快照的命令为：</p>
lvcreate</span> -</span>s</span> [-L</span> <</span>siz</span>e</span>></span>]</span> -</span>n</span> SNAP_VOLUME</span> [</span> -</span>p</span>|</span>--permission</span> rw</span>|</span>r</span> ]</span> SOURCE_VOLUME_PATH</span></span></code></pre>
其中 -s</code> 表示为快照卷，-L</code> 表示快照卷的大小，-n</code> 表示快照卷的名称，-p</code> 表示快照卷的权限，r</code> 表示只读，rw</code> 表示读写，SOURCE_VOLUME_PATH</code> 表示原始逻辑卷的路径。</p>
如：</p>
lvcreate</span> -</span>s</span> -</span>L</span> 5G</span> -</span>n</span> lv1_snap</span> -</span>p</span> r</span> /dev/vg1/lv1</span></span></code></pre>
下面是一个示例：</p>
☁</span>  ~</span>  lvcreate</span> -</span>L</span> 5g</span> -</span>n</span> lv1</span> vg1</span>                      </span></span>
WARNING:</span> ext4</span> signature</span> detected</span> on</span> /dev/vg1/lv1</span> at</span> offset</span> 1080.</span> Wipe</span> it?</span> [y/n</span>]: y</span></span>
  Wiping</span> ext4</span> signature</span> on</span> /dev/vg1/lv1.</span></span>
  Logical</span> volume</span> "</span>lv1</span>"</span> created.</span></span>
☁</span>  ~</span>  mkfs.ext4</span> /dev/vg1/lv1</span>       </span></span>
mke2fs</span> 1.47.0</span> (5-Feb-2023</span>)</span></span>
Creating</span> filesystem</span> with</span> 1310720</span> 4k</span> blocks</span> and</span> 327680</span> inodes</span></span>
Filesystem</span> UUID:</span> 8a413a29-644e-40dc-906a-dee174d81202</span></span>
Superblock</span> backups</span> stored</span> on</span> blocks:</span> </span></span>
	32768,</span> 98304,</span> 163840,</span> 229376,</span> 294912,</span> 819200,</span> 884736</span></span>
</span>
Allocating</span> group</span> tables:</span> done</span>                            </span></span>
Writing</span> inode</span> tables:</span> done</span>                            </span></span>
Creating</span> journal</span> (16384</span> blocks</span>): </span>done</span></span>
Writing</span> superblocks</span> and</span> filesystem</span> accounting</span> information:</span> done</span> </span></span>
</span>
☁</span>  ~</span>  mount</span> /dev/vg1/lv1</span> /mnt</span>      </span></span>
☁</span>  ~</span>  echo</span> "</span>test</span>"</span> ></span> /mnt/1.txt</span>                     </span></span>
☁</span>  ~</span>  lvcreate</span> -</span>L</span> 5G</span> -</span>n</span> lv1_snap</span> -</span>p</span> r</span> -</span>s</span> /dev/vg1/lv1</span></span>
  Logical</span> volume</span> "</span>lv1_snap</span>"</span> created.</span></span>
☁</span>  ~</span>  mount</span> /dev/vg1/lv1_snap</span> /mnt2</span>                  </span></span>
mount:</span> /mnt2:</span> WARNING:</span> source</span> write-protected,</span> mounted</span> read-only.</span></span>
☁</span>  ~</span>  df</span> -</span>h</span></span>
文件系统</span>                  大小</span>  已用</span>  可用</span> 已用%</span> 挂载点</span></span>
udev</span>                      3.9G</span>     0</span>  3.9G</span>    0%</span> /dev</span></span>
tmpfs</span>                     791M</span>  888K</span>  790M</span>    1%</span> /run</span></span>
/dev/sdc1</span>                  39G</span>   26G</span>   11G</span>   71%</span> /</span></span>
tmpfs</span>                     3.9G</span>     0</span>  3.9G</span>    0%</span> /dev/shm</span></span>
tmpfs</span>                     5.0M</span>     0</span>  5.0M</span>    0%</span> /run/lock</span></span>
tmpfs</span>                     791M</span>     0</span>  791M</span>    0%</span> /run/user/0</span></span>
/dev/mapper/vg1-lv1</span>       4.9G</span>   28K</span>  4.6G</span>    1%</span> /mnt</span></span>
/dev/mapper/vg1-lv1_snap</span>  4.9G</span>   28K</span>  4.6G</span>    1%</span> /mnt2</span></span>
☁</span>  ~</span>  echo</span> "</span>test123123123</span>"</span> ></span> /mnt/1.txt</span></span>
☁</span>  ~</span>  echo</span> "</span>test</span>"</span> ></span> /mnt/2.txt</span>                             </span></span>
☁</span>  ~</span>  ls</span> -</span>l</span> /mnt</span> </span></span>
总计</span> 24</span></span>
-rw-r--r--</span> 1</span> root</span> root</span>    14</span> 12月21日</span> 10:34</span> 1.txt</span></span>
-rw-r--r--</span> 1</span> root</span> root</span>     5</span> 12月21日</span> 10:34</span> 2.txt</span></span>
drwx------</span> 2</span> root</span> root</span> 16384</span> 12月21日</span> 10:32</span> lost+found</span></span>
☁</span>  ~</span>  ls</span> -</span>l</span> /mnt2</span>                      </span></span>
总计</span> 20</span></span>
-rw-r--r--</span> 1</span> root</span> root</span>     5</span> 12月21日</span> 10:33</span> 1.txt</span></span>
drwx------</span> 2</span> root</span> root</span> 16384</span> 12月21日</span> 10:32</span> lost+found</span></span>
☁</span>  ~</span>  cat</span> /mnt/1.txt</span> </span></span>
test123123123</span></span>
☁</span>  ~</span>  cat</span> /mnt2/1.txt</span></span>
test</span></span></code></pre>
可以看到，我们创建了一个逻辑卷 lv1，然后挂载到 /mnt 目录，并将文本内容 "test" 写入到了 /mnt/1.txt，然后创建了一个快照 lv1_snap，挂载到 /mnt2 目录，这时修改了 /mnt/1.txt 的内容为 "test123123123"，然后再次查看 /mnt/1.txt 和 /mnt2/1.txt 的内容，可以看到 /mnt/1.txt 的内容已经发生了变化，而 /mnt2/1.txt 的内容还是 "test"，这是因为快照卷记录了 /mnt/1.txt 的原数据，所以 /mnt2/1.txt 的内容还是 "test"。同时，我们还创建了一个 /mnt/2.txt 文件，这个文件只会出现在 /mnt 目录下，而不会出现在 /mnt2 目录下，因为快照卷只记录了原始逻辑卷的原数据，而不会记录原始逻辑卷新增的数据。</p>

注意快照不能用于替代备份，因为快照卷只记录了原始逻辑卷修改后的原数据，当原始逻辑卷或所属卷组损坏时，快照卷也会损坏。</p>
</blockquote>
4.3 还原快照</h3>
还原快照的命令为：</p>
lvconvert</span> -</span>-merge</span> SOURCE_SNAPSHOT_VOLUME_PATH</span></span></code></pre>
其中 SOURCE_SNAPSHOT_VOLUME_PATH</code> 为快照卷的路径。使用该命令后，快照卷会被删除，原始逻辑卷会恢复到快照卷创建时的状态</strong>。</p>
5. LVM 诊断</h2>
5.1. 查看各个 PV 占用情况</h3>
使用 pvdisplay -m</code> 命令查看各个 PV 占用情况，如下所示：</p>
☁</span>  ~</span>  pvdisplay</span> -</span>m</span></span>
  ---</span> Physical</span> volume</span> -</span>--</span></span>
  PV</span> Name</span>               /dev/sda</span></span>
  VG</span> Name</span>               vg1</span></span>
  PV</span> Size</span>               10.00</span> GiB</span> /</span> not</span> usable</span> 4.00</span> MiB</span></span>
  Allocatable</span>           yes</span> (but</span> full</span>)</span></span>
  PE</span> Size</span>               4.00</span> MiB</span></span>
  Total</span> PE</span>              2559</span></span>
  Free</span> PE</span>               0</span></span>
  Allocated</span> PE</span>          2559</span></span>
  PV</span> UUID</span>               Ly2wh9-c8iU-h2Gn-4REY-ioZJ-ykJG-uysyAC</span></span>
   </span></span>
  ---</span> Physical</span> Segments</span> -</span>--</span></span>
  Physical</span> extent</span> 0</span> to</span> 2558:</span></span>
    Logical</span> volume</span>	/dev/vg1/lv1</span></span>
    Logical</span> extents</span>	0</span> to</span> 2558</span></span>
   </span></span>
  ---</span> Physical</span> volume</span> -</span>--</span></span>
  PV</span> Name</span>               /dev/sdc</span></span>
  VG</span> Name</span>               vg1</span></span>
  PV</span> Size</span>               10.00</span> GiB</span> /</span> not</span> usable</span> 4.00</span> MiB</span></span>
  Allocatable</span>           yes</span> </span></span>
  PE</span> Size</span>               4.00</span> MiB</span></span>
  Total</span> PE</span>              2559</span></span>
  Free</span> PE</span>               510</span></span>
  Allocated</span> PE</span>          2049</span></span>
  PV</span> UUID</span>               yfRAu7-EX5S-nlQL-YcdH-N7N1-Layf-QJ2ivo</span></span>
   </span></span>
  ---</span> Physical</span> Segments</span> -</span>--</span></span>
  Physical</span> extent</span> 0</span> to</span> 2048:</span></span>
    Logical</span> volume</span>	/dev/vg1/lv1</span></span>
    Logical</span> extents</span>	2559</span> to</span> 4607</span></span>
  Physical</span> extent</span> 2049</span> to</span> 2558:</span></span>
    FREE</span></span></code></pre>
也可以使用 pvscan</code> 命令查看，如下所示：</p>
☁</span>  ~</span>  pvscan</span>      </span></span>
  PV</span> /dev/sda</span>   VG</span> vg1</span>             lvm2</span> [<10.00</span> GiB</span> /</span> 0</span>    free]</span></span>
  PV</span> /dev/sdc</span>   VG</span> vg1</span>             lvm2</span> [<10.00</span> GiB</span> /</span> 1.99</span> GiB</span> free]</span></span>
  Total:</span> 2</span> [19.99</span> GiB]</span> /</span> in</span> use:</span> 2</span> [19.99</span> GiB]</span> /</span> in</span> no</span> VG:</span> 0</span> [0</span>   ]</span></span></code></pre>5.2. 查看各个 VG/VL 占用情况</h3>
同 pvdisplay -m</code> 命令一样，只是命令前的 pv</code> 换成 vg</code> 或 lv</code>。</p>


Spring 技巧 - @Value 复用
2023-10-12T20:55:00+08:00
平时我们想将 Spring Boot 配置文件中的值注入到变量中，我们可以使用 @Value 注解，如：</p>
s</span>erver</span>:</span></span>
  p</span>ort</span>:</span> 8080</span></span></code></pre>@</span>Value</span>(</span>"</span>${server.port}</span>"</span>)</span></span>
private</span> Integer</span> port</span>;</span></span></code></pre>
但是，如果代码中有多个地方想使用的话，就需要在多个地方都使用 @Value 注解，这样就会显得很麻烦，而且如果配置文件中的值发生了变化，那么我们就需要在多个地方都修改，容易出错。</p>
为了解决这个问题，我们可以抽取一个自定义注解，如：</p>
import</span> org</span>.</span>springframework</span>.</span>beans</span>.</span>factory</span>.</span>annotation</span>.</span>Value</span>;</span></span>
</span>
import</span> java</span>.</span>lang</span>.</span>annotation</span>.</span>*</span>;</span></span>
</span>
@</span>Target</span>(</span>{</span>ElementType</span>.</span>FIELD</span>,</span> ElementType</span>.</span>METHOD</span>,</span> ElementType</span>.</span>PARAMETER</span>,</span> ElementType</span>.</span>ANNOTATION_TYPE</span>}</span>)</span></span>
@</span>Retention</span>(</span>RetentionPolicy</span>.</span>RUNTIME</span>)</span></span>
@</span>Documented</span></span>
@</span>Value</span>(</span>"</span>${server.port}</span>"</span>)</span></span>
public</span> @</span>interface</span> ServerPort</span> {</span></span>
}</span></span></code></pre>
然后在需要使用的地方使用该注解，如：</p>
import</span> org</span>.</span>springframework</span>.</span>stereotype</span>.</span>Component</span>;</span></span>
</span>
@</span>Component</span></span>
public</span> class</span> TestService</span> {</span></span>
</span>
    @</span>ServerPort</span></span>
    private</span> Integer</span> port</span>;</span></span>
</span>
    public</span> void</span> test</span>(</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>port</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
这样使用自定义注解和 @Value 注解的效果是一样的，但是可以减少代码量，而且如果配置文件中的值发生了变化，我们只需要修改自定义注解即可。</p>

不过这只适用于使用 @Value 注解的场景，更推荐的做法是将配置文件中的值注入到一个对象中，然后在需要使用的地方注入该对象，如：</p>
</blockquote>
s</span>erver</span>:</span></span>
  p</span>ort</span>:</span> 8080</span></span>
  a</span>ddress</span>:</span> 127.0.0.1</span></span></code></pre>import</span> org</span>.</span>springframework</span>.</span>boot</span>.</span>context</span>.</span>properties</span>.</span>ConfigurationProperties</span>;</span></span>
import</span> org</span>.</span>springframework</span>.</span>stereotype</span>.</span>Component</span>;</span></span>
</span>
@</span>Component</span></span>
@</span>ConfigurationProperties</span>(</span>prefix</span> =</span> "</span>server</span>"</span>)</span></span>
public</span> class</span> ServerProperties</span> {</span></span>
</span>
    private</span> Integer</span> port</span>;</span></span>
</span>
    private</span> String</span> address</span>;</span></span>
    </span></span>
    //</span> getter and setter</span></span>
}</span></span></code></pre>


2. MySQL 主从搭建 —— 查看同步状态
2023-09-27T20:31:00+08:00
上一节我们快速搭建了一个主从同步的环境，可以将主库的修改自动同步到从库，如果你失败了，没有同步成功也没关系，通过这篇文档你可以看到如何查看同步的状态和错误信息来排查问题。</p>
1. 通过命令查看状态</h2>
我们可以通过命令 SHOW SLAVE STATUS</code> 可以查看当前从库的状态:</p>
mysql> SHOW SLAVE STATUS \G;</span></span>
*************************** 1. row ***************************</span></span>
               Slave_IO_State: Waiting for source to send event</span></span>
                  Master_Host: mysql-master</span></span>
                  Master_User: repl</span></span>
                  Master_Port: 3306</span></span>
                Connect_Retry: 60</span></span>
              Master_Log_File: mysql-bin.000005</span></span>
          Read_Master_Log_Pos: 157</span></span>
               Relay_Log_File: mysql-relay-bin.000007</span></span>
                Relay_Log_Pos: 373</span></span>
        Relay_Master_Log_File: mysql-bin.000005</span></span>
             Slave_IO_Running: Yes</span></span>
            Slave_SQL_Running: Yes</span></span>
              Replicate_Do_DB:</span></span>
          Replicate_Ignore_DB:</span></span>
           Replicate_Do_Table:</span></span>
       Replicate_Ignore_Table:</span></span>
      Replicate_Wild_Do_Table:</span></span>
  Replicate_Wild_Ignore_Table:</span></span>
                   Last_Errno: 0</span></span>
                   Last_Error:</span></span>
                 Skip_Counter: 0</span></span>
          Exec_Master_Log_Pos: 157</span></span>
              Relay_Log_Space: 799</span></span>
              Until_Condition: None</span></span>
               Until_Log_File:</span></span>
                Until_Log_Pos: 0</span></span>
           Master_SSL_Allowed: No</span></span>
           Master_SSL_CA_File:</span></span>
           Master_SSL_CA_Path:</span></span>
              Master_SSL_Cert:</span></span>
            Master_SSL_Cipher:</span></span>
               Master_SSL_Key:</span></span>
        Seconds_Behind_Master: 0</span></span>
Master_SSL_Verify_Server_Cert: No</span></span>
                Last_IO_Errno: 0</span></span>
                Last_IO_Error:</span></span>
               Last_SQL_Errno: 0</span></span>
               Last_SQL_Error:</span></span>
  Replicate_Ignore_Server_Ids:</span></span>
             Master_Server_Id: 1</span></span>
                  Master_UUID: 9262b8ed-52c9-11ee-81cb-0242ac1e0003</span></span>
             Master_Info_File: mysql.slave_master_info</span></span>
                    SQL_Delay: 0</span></span>
          SQL_Remaining_Delay: NULL</span></span>
      Slave_SQL_Running_State: Replica has read all relay log; waiting for more updates</span></span>
           Master_Retry_Count: 86400</span></span>
                  Master_Bind:</span></span>
      Last_IO_Error_Timestamp:</span></span>
     Last_SQL_Error_Timestamp:</span></span>
               Master_SSL_Crl:</span></span>
           Master_SSL_Crlpath:</span></span>
           Retrieved_Gtid_Set:</span></span>
            Executed_Gtid_Set:</span></span>
                Auto_Position: 0</span></span>
         Replicate_Rewrite_DB:</span></span>
                 Channel_Name:</span></span>
           Master_TLS_Version:</span></span>
       Master_public_key_path:</span></span>
        Get_master_public_key: 0</span></span>
            Network_Namespace:</span></span>
1 row in set, 1 warning (0.00 sec)</span></span></code></pre>2. 状态信息详解</h2>
2.1 连接信息</h3>
关于主从同步主库的连接信息参数包含：</p>

Master_Bind</code>：slave 从库在多网络接口的情况下使用，以确定用哪一个 slave 网络接口连接到 master。</li>
Master_Host</code>：主库的 IP 地址。</li>
Master_User</code>：用于从主库复制的账号。</li>
Master_Port</code>：主库的端口号。</li>
Connect_Retry</code>：从库连接主库失败后，重试的时间间隔。</li>
Master_Retry_Count</code>：从库连接主库失败后，最大重试次数。</li>
</ul>

主库连接信息可通过 CHANGE MASTER TO</code> 命令修改，可参考前面的命令。不过必须在停止主从同步的状态下进行，停止命令为 STOP SLAVE;</code></p>
</blockquote>
2.2 主库信息</h3>
关于主从同步主库的基本信息参数包含：</p>

Master_Server_Id</code>：主库的 SERVER_ID。</li>
Master_UUID</code>：主库的 UUID。</li>
Master_Info_File</code>：主库的信息文件，老版本默认存储在文件中，如 /var/lib/mysql/master.info</code>；8.0 开始默认存储在表中，如 mysql.slave_master_info</code>。</li>
</ul>
2.3 主从同步状态</h3>
关于主从同步运行状态的参数包含：</p>

Slave_IO_State</code>：用于表示从库 IO 线程当前的状态（slave 连接 master 的状态），通过 show processlist</code> 也能看到 User = system user</code> 的 State</code> 列也显示了这个连接状态。</li>
Slave_IO_Running</code>：用于表示从库 IO 线程是否正常，该线程用来从主库拉取 binlog 日志写入到 relay log 中。如果拉取过程出现异常，如网络问题，主库宕机，用于从主库复制的账号密码变化等，该线程会停止。</li>
Slave_SQL_Running_State</code>：用于表示从库 SQL 线程当前的状态（slave 执行 binlog 日志的状态）。</li>
Slave_SQL_Running</code>：用于表示从库 SQL 线程是否正常，该线程用来将 relay log 中的日志在从库执行，这样会记录到当前从库的 binlog 中。如果执行过程出现异常，如 sql 语句报错，主键/唯一键冲突等，该线程会停止。</li>
Last_SQL_Errno</code>：用于表示从库 SQL 线程最后一次执行出错的错误码，正常情况下应该为 0。</li>
Last_SQL_Error</code>：用于表示从库 SQL 线程最后一次执行出错的错误信息。（可能会在提示信息中让去 performance_schema.replication_applier_status_by_worker 表中查看更详细的错误信息）</li>
Last_SQL_Error_Timestamp</code>：用于表示从库 SQL 线程最后一次执行出错的时间。</li>
Last_Errno</code>：等同于 Last_SQL_Errno</code>，只是另一种别名。</li>
Last_Error</code>：等同于 Last_SQL_Error</code>，只是另一种别名。</li>
Last_IO_Errno</code>：用于表示从库 IO 线程最后一次执行出错的错误码，正常情况下应该为 0。</li>
Last_IO_Error</code>：用于表示从库 IO 线程最后一次执行出错的错误信息，如网络问题，主库宕机，用于从主库复制的账号密码变化等。</li>
Last_IO_Error_Timestamp</code>：用于表示从库 IO 线程最后一次执行出错的时间。</li>
Seconds_Behind_Master</code>: 表示当前从库与主库的延迟：为 0 表示同步正常，为正数表示延迟的秒数</strong>，为 NULL 表示 IO 线程或 SQL 线程中至少有一个处于停止状态。</li>
Retrieved_Gtid_Set</code>：用于表示从库已经从主库获取到的 GTID 集合。</li>
Executed_Gtid_Set</code>：用于表示从库已经执行过的 GTID 集合。</li>
Auto_Position</code>：用于表示从库是否使用 GTID 模式，如果使用则为 1，否则为 0。GTID 模式会自动定位到主库的 binlog 文件和位置，不需要手动配置 MASTER_LOG_FILE</code> 和 MASTER_LOG_POS</code>。</li>
</ul>
2.4 主从日志文件</h3>
关于日志文件的参数包含：</p>

Master_Log_File</code>：IO 线程当前正在读取的主库 binlog 文件名。</li>
Read_Master_Log_Pos</code>：IO 线程当前正在读取的主库 binlog 文件偏移量。</li>
Relay_Log_File</code>：SQL 线程当前执行到的 relay log 文件名。</li>
Relay_Log_Pos</code>：SQL 线程当前执行到的 relay log 文件偏移量；到此位置的事件已在当前从库上执行。</li>
Relay_Master_Log_File</code>：SQL 线程当前正在执行 relay log 中的 sql 所在主库的 binlog 文件名。（如 Master_Log_File: mysql-bin.000005，但是 Relay_Master_Log_File: mysql-bin.000004，说明当前主从存在延迟，主库已经写入到了 mysql-bin.000005，但是从库还在执行 mysql-bin.000004）</li>
Exec_Master_Log_Pos</code>:SQL 线程当前正在执行 relay log 中的 sql 所在主库的 binlog 文件偏移量。</li>
</ul>
简单来讲就是从库先通过 IO 线程读取主库的二进制文件（Master_Log_File）和位置（Read_Master_Log_Pos）然后缓存到本地（从库服务器）的中继文件（Relay_Log_File）中并记录已经读取到的位置（Relay_Log_Pos），再通过从库的 SQL 线程去读取中继文件（Relay_Log_File），这个 SQL 线程执行会记录已经执行到的 SQL 在主库中对应哪个文件（Relay_Master_Log_File）和哪个位置（Exec_Master_Log_Pos）。
如果 Master_Log_File = Relay_Master_Log_File，且 Read_Master_Log_Pos = Exec_Master_Log_Pos 说明主从同步正常，当前状态一致。</p>

这里的 xxx_Pos 指文件的偏移量，用字节表示，如 100 表示文件的第 100 个字节。</p>
</blockquote>

Relay_Log_Space</code>：所有 relay log 文件的总大小，单位字节。</li>
</ul>
2.5 主从过滤规则</h3>
关于主次同步忽略数据库和表的参数包含：</p>

Replicate_Do_DB</code>：需要同步的数据库，多个数据库之间用逗号分隔。</li>
Replicate_Ignore_DB</code>：需要忽略的数据库，多个数据库之间用逗号分隔。</li>
Replicate_Do_Table</code>：需要同步的表，多个表之间用逗号分隔，注意这里的表名是 db.table</code> 的形式。如果需要同步多个库的同名表，可以使用 db1.table1,db2.table1</code> 的形式。</li>
Replicate_Ignore_Table</code>：需要忽略的表，多个表之间用逗号分隔，注意这里的表名是 db.table</code> 的形式。如果需要同步多个库的同名表，可以使用 db1.table1,db2.table1</code> 的形式。</li>
Replicate_Wild_Do_Table</code>：需要同步的表，支持通配符，多个表之间用逗号分隔。格式为 db.table</code> 的形式，但是支持通配符 %</code> 和 _</code>，含义和 like 语句中的通配符一样。</li>
Replicate_Wild_Ignore_Table</code>：需要忽略的表，支持通配符，多个表之间用逗号分隔。格式为 db.table</code> 的形式，但是支持通配符 %</code> 和 _</code>，含义和 like 语句中的通配符一样（%</code> 表示任意字符，_</code> 表示任意单个字符）。</li>
Replicate_Ignore_Server_Ids</code>：需要让 IO 线程忽略的主库 ID（不从该主库获取事件），多个 ID 之间用逗号分隔。</li>
</ul>
这些参数可以在配置文件中配置，也可以在线修改，以 REPLICATE_DO_DB</code> 为例： CHANGE REPLICATION FILTER REPLICATE_DO_DB = (db1 db2);</code>，不过同样需要在停止主从同步的状态下进行，停止命令为 STOP SLAVE;</code>。</p>
不过对于 Replicate_Do_DB</code> 和 Replicate_Ignore_DB</code> 这两个参数，不建议使用，因为可能会丢失数据。比如你在从库中设置了 Replicate_Do_DB=db1</code>，打算用来只同步 db1 库，但是如果你在主库执行 use mysql; create table db1.t (id int)</code>，那么这个语句不会被同步到从库。Replicate_Ignore_DB</code> 同理。
所以更建议使用 Replicate_Wild_Do_Table</code> 和 Replicate_Wild_Ignore_Table</code> 这两个参数，这样可以避免上面的问题。如之前通过 REPLICATE_DO_DB</code> 配置值为 db1 db2</code>，在 Replicate_Wild_Do_Table</code> 上可以配置成 db1.% db2.%</code></p>
2.6 主从同步停止条件</h3>
关于主从同步停止条件的参数包含：</p>

Until_Condition</code>：用于表示从库停止同步的条件，默认为 None</code>，可在 START SLAVE UNTIL ...</code> 命令中修改。 如 START SLAVE UNTIL MASTER_LOG_FILE='mysql-bin.000003', MASTER_LOG_POS=879;</code>，表示从库同步到主库的 mysql-bin.000003</code> 文件的 879</code> 位置时停止同步。可用的过滤条件有：

None</code>：不停止。</li>
MASTER_LOG_FILE</code> 和 MASTER_LOG_POS</code>：当从库同步到主库的指定 binlog 文件和位置时停止同步。</li>
RELAY_LOG_FILE</code> 和 RELAY_LOG_POS</code>：当从库同步到自己的 relay log 文件的指定位置时停止同步。</li>
SQL_BEFORE_GTIDS</code>：之前的 GTID 都会被执行，如 START SLAVE SQL_THREAD UNTIL SQL_BEFORE_GTIDS = 3E11FA47-71CA-11E1-9E33-C80AA9429562:11-56</code> 表示，当 SQL_thread</code> 执行到 3E11FA47-71CA-11E1-9E33-C80AA9429562:10</code> 的时候停止，不包含事务码 11。</li>
SQL_AFTER_GTIDS</code>：之前和指定的 GTID 都会被执行。如 START SLAVE SQL_THREAD UNTIL SQL_AFTER_GTIDS = 3E11FA47-71CA-11E1-9E33-C80AA9429562:11-56</code> 表示，当 SQL_thread</code> 执行到 3E11FA47-71CA-11E1-9E33-C80AA9429562:56</code> 的时候停止，包含事务码 56。</li>
</ul>
</li>
Until_Log_File</code>：用于表示从库停止同步的条件，与 Until_Condition</code> 配合使用，表示从库停止同步的 binlog 文件名（如果使用的不是 binlog 限制，则这里为空）。</li>
Until_Log_Pos</code>：用于表示从库停止同步的条件，与 Until_Condition</code> 配合使用，表示从库停止同步的 binlog 文件偏移量（如果使用的不是 binlog 限制，则这里为 0）。</li>
</ul>
2.7 主从同步延迟</h3>
关乎主从同步延迟的参数包含：</p>

Seconds_Behind_Master</code>：用于表示当前从库与主库的延迟，为 0 表示同步正常，为正数表示延迟的秒数</strong>，为 NULL 表示 IO 线程或 SQL 线程中至少有一个处于停止状态。</li>
SQL_Delay</code>：用于表示从库 SQL 线程延迟执行的时间，单位秒。设置方式如 CHANGE MASTER TO MASTER_DELAY = 3600</code>，表示延迟 1 小时执行。</li>
SQL_Remaining_Delay</code>：用于表示从库 SQL 线程延迟执行的剩余时间，单位秒。</li>
</ul>
2.8 主从同步加密传输</h3>
关于主从同步加密传输的参数包含 Master_SSL_xxxx</code>，共有 9 个参数，用于表示主从同步的加密传输相关的配置，这里不再赘述。</p>
2.9 其他参数</h3>
还有一些其他的参数，是新版本的参数，这里统一说明下：</p>

Master_TLS_Version</code>：用于表示主库和从库之间的 TLS 版本，如 TLSv1,TLSv1.1,TLSv1.2</code>。</li>
Master_public_key_path</code>：用于表示主库的公钥文件路径。</li>
Get_master_public_key</code>：用于表示从库是否获取主库的公钥，如果为 1，则从库会获取主库的公钥，如果为 0，则不会获取。</li>
Network_Namespace</code>：用于表示从库的网络命名空间。详细参考：Section 5.1.14, “Network Namespace Support”</a></li>
Channel_Name</code>：用于表示从库的通道名称。详细参考：Section 17.2.2, “Replication Channels”</a></li>
Replicate_Rewrite_DB</code>：值显示指定的任何复制过滤规则。例如，如果设置了以下复制过滤规则 CHANGE REPLICATION FILTER REPLICATE_REWRITE_DB=((db1,db2), (db3,db4));</code>，则 Replicate_Rewrite_DB</code> 显示：Replicate_Rewrite_DB: (db1,db2),(db3,db4)</code>。 详情参考：Section 13.4.2.2, “CHANGE REPLICATION FILTER Statement”</a></li>
</ul>


1. MySQL 主从搭建 —— 基础篇
2023-09-27T20:15:00+08:00
顾名思义，主从复制就是将一个数据库的数据复制到另一个数据库，这里的数据库可以是同一台服务器上的，也可以是不同服务器上的。本章会先介绍如何快速搭建一个主从复制的环境，然后再介绍主从复制的原理和常见的配置方式。</p>
1 基础环境介绍</h2>

任意安装了 Docker</code> 和 Docker Compose</code> 的操作系统。</li>
MySQL</code> 5.7-8.0</strong> 均可，我这里采用 8.0</code> 版本，但主从版本尽量要保持一致，否则可能会出现问题。</li>
</ul>
2 配置文件介绍</h2>
MySQL</code> 将使用 docker-compose</code> 安装，文件目录结构为：</p>
.</span></span>
├──</span> docker-compose.yml</span>          #</span> docker-compose 配置文件，描述主从服务信息</span></span>
├──</span> master</span></span>
│</span>   ├──</span> conf</span></span>
│</span>   │</span>   └──</span> my.cnf</span>              #</span> master 节点的 mysql 配置文件</span></span>
│</span>   └──</span> data</span>                    #</span> master 节点的数据目录，包含 binlog、redo-log、relay-log 等文件</span></span>
└──</span> slave</span></span>
    ├──</span> conf</span></span>
    │</span>   └──</span> my.cnf</span>              #</span> master 节点的 mysql 配置文件</span></span>
    └──</span> data</span>                    #</span> master 节点的数据目录，包含 binlog、redo-log、relay-log 等文件</span></span></code></pre>
根目录下有 docker-compose.yml</code> 文件，然后有个 master</code> 文件夹，还有个 slave</code> 文件夹，里面包含 conf</code> 配置文件和 data</code> 数据目录。</p>
其中 docker-compose.yml</code> 文件内容如下：</p>
v</span>ersion</span>:</span> '</span>3.1</span>'</span></span>
s</span>ervices</span>:</span></span>
  m</span>ysql-master</span>:</span></span>
    i</span>mage</span>:</span> m</span>ysql:8.0</span>                                #</span> master 指定版本号为 8.0</span></span>
    c</span>ontainer_name</span>:</span> m</span>ysql-master</span>                    #</span> master 容器名称</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    e</span>nvironment</span>:</span></span>
      T</span>Z</span>:</span> A</span>sia/Shanghai</span></span>
      M</span>YSQL_ROOT_PASSWORD</span>:</span> u</span>xUw.SyCs)bb</span>             #</span> master root 密码</span></span>
      M</span>YSQL_ROOT_HOST</span>:</span> '</span>%</span>'</span>                          #</span> master 允许 root 在任意主机远程登录，% 表示任意主机，可以指定具体的 IP 或 IP 段</span></span>
      M</span>YSQL_DATABASE</span>:</span> m</span>y-db</span>                         #</span> 初始化创建的数据库名称</span></span>
      M</span>YSQL_USER</span>:</span> m</span>y-db-user</span>                        #</span> 初始化创建的普通数据库用户，将自动授予默认数据库所有权限</span></span>
      M</span>YSQL_PASSWORD</span>:</span> u</span>xUw.SyCs)bb</span>                  #</span> 初始化创建的普通数据库用户的密码</span></span>
    p</span>orts</span>:</span> </span></span>
      -</span> '</span>53306:3306</span>'</span>                                #</span> master 容器对外暴露的端口号</span></span>
    v</span>olumes</span>:</span></span>
      -</span> .</span>/master/data/:/var/lib/mysql/</span></span>
      -</span> .</span>/master/conf/:/etc/mysql/conf.d/</span></span>
</span>
  #</span> slave 的配置与 master 类似，这里不再赘述</span></span>
  m</span>ysql-slave</span>:</span> </span></span>
    i</span>mage</span>:</span> m</span>ysql:8.0</span>                                </span></span>
    c</span>ontainer_name</span>:</span> m</span>ysql-slave</span></span>
    r</span>estart</span>:</span> a</span>lways</span></span>
    e</span>nvironment</span>:</span></span>
      T</span>Z</span>:</span> A</span>sia/Shanghai</span></span>
      M</span>YSQL_ROOT_PASSWORD</span>:</span> u</span>xUw.SyCs)bb</span></span>
      M</span>YSQL_ROOT_HOST</span>:</span> '</span>%</span>'</span></span>
      M</span>YSQL_DATABASE</span>:</span> m</span>y-db</span></span>
      M</span>YSQL_USER</span>:</span> m</span>y-db-user</span></span>
      M</span>YSQL_PASSWORD</span>:</span> u</span>xUw.SyCs)bb</span></span>
    p</span>orts</span>:</span></span>
      -</span> '</span>53307:3306</span>'</span></span>
    v</span>olumes</span>:</span></span>
      -</span> .</span>/slave/data/:/var/lib/mysql/</span></span>
      -</span> .</span>/slave/conf/:/etc/mysql/conf.d/</span></span></code></pre>
master/conf/my.cnf</code> 配置文件：</p>
[mysqld]</span></span>
</span>
# 集群相关配置：</span></span>
server_id                       = 1                     # server-id，集群中不同服务之间，不应重复</span></span>
skip_slave_start                = true                  # 禁止自动开启复制功能，建议手动操作</span></span>
log_slave_updates               = true                  # 是否将从库收到的变更事件重新写入到自己的 binlog 中，建议开启。不然将从库切换为主库时，或者该从库作为其他从库的数据源时，将会出现问题。</span></span>
</span>
# 数据存储格式和名称：</span></span>
log_bin                         = mysql-bin             # binlog 的存储文件名，也可以写绝对路径。否则将存储在默认目录下</span></span>
relay_log                       = mysql-relay-bin       # 中继日志的存储文件名，也可以写绝对路径。否则将存储在默认目录下，默认时 hostname-relay-bin</span></span>
binlog_format                   = row                   # 采用更安全可靠的 row 格式，但可能会占用大量存储</span></span></code></pre>
slave/conf/my.cnf</code> 配置文件：</p>
[mysqld]</span></span>
# 从库配置</span></span>
read_only                       = true                  # 从库只读</span></span>
</span>
# 集群相关配置：</span></span>
server_id                       = 2                     # server-id，集群中不同服务之间，不应重复</span></span>
skip_slave_start                = true                  # 禁止自动开启复制功能，建议手动操作</span></span>
log_slave_updates               = true                  # 是否将从库收到的变更事件重新写入到自己的 binlog 中，建议开启。不然将从库切换为主库时，或者该从库作为其他从库的数据源时，将会出现问题。</span></span>
</span>
# 数据存储格式和名称：</span></span>
log_bin                         = mysql-bin             # binlog 的存储文件名，也可以写绝对路径。否则将存储在默认目录下</span></span>
relay_log                       = mysql-relay-bin       # 中继日志的存储文件名，也可以写绝对路径。否则将存储在默认目录下，默认时 hostname-relay-bin</span></span>
binlog_format                   = row                   # 采用更安全可靠的 row 格式，但可能会占用大量存储</span></span></code></pre>
master</code> 和 slave</code> 两者的配置文件不同点是：</p>

从库增加了 read_only</code> 限制了只读，需要注意该选项只能限制平台用户，限制不了 root 权限用户。为了避免误操作，建议启动通过 set global super_read_only=true;</code>(重启 MySQL 后失效)</strong>，这样会限制 root 权限用户也无法进行写入操作。（之所以没有把这个选项配置到配置文件中将限制无法进行连接）</li>
集群中不同服务的 server_id</code> 应避免重复。</li>
其他的参数值都一样，不过也都是重要参数，详细作用可看配置文件后的注释。</li>
</ul>

这里 master</code> 和 slave</code> 的配置文件只是默认配置，下面介绍不同的部署方式会在这个默认配置文件的基础上修改（会注明修改内容）。</p>
</blockquote>
然后在 docker-compose.yml</code> 文件所在目录下执行 docker-compose up -d</code> 即可启动服务。</p>
3 常见启动报错</h2>
如果你启动过程报错了，可以在这里找找解决方案，正常启动的话，跳过这一步。</p>
3.1 windows wsl 内启动失败</h3>
如果你使用的是 windows</code> 的 wsl</code>，那么也可能会遇到无法启动的问题，报错信息有：</p>
mysql-master  | </span>2023-09-11</span>T06:44:31.139281Z</span> 0</span> [ERROR]</span> [MY-</span>010295</span>] [Server] Could not set file permission for </span>ca.pem</span></span>
mysql-master  | </span>2023-09-11</span>T06:44:31.139281Z</span> 0</span> [ERROR]</span> [MY-</span>010295</span>] [Server] Could not set file permission for </span>private_key.pem</span></span>
mysql-master  | </span>2023-09-11</span>T06:44:31.139316Z</span> 0</span> [ERROR]</span> [MY-</span>010119</span>] [Server] Aborting</span></span></code></pre>
可以通过在 wsl 内配置文件 /etc/wsl.conf</code> 内增加（没有这个配置文件则创建）：</p>
[automount]</span></span>
enabled = true</span></span>
options = "metadata"</span></span>
mountFsTab = false</span></span></code></pre>
然后重启 wsl，再尝试即可解决。</p>
4 主从技术</h2>
4.1 验证配置文件生效</h3>
前面我们通过 docker-compose up -d</code> 启动了服务，现在我们需要连接 MySQL 并验证配置文件中的配置项是否生效，这很重要，不然你后续做的操作可能都是无用功。</p>
验证方式通过 show variables</code> 命令，如 show variables like '%server_id%';</code>，master 服务器上应该返回 1，slave 服务器上应该返回 2。</p>

如果配置文件未生效，这里提一个可能的原因，如果在启动日志中有日志：mysqld: [Warning] World-writable config file '/etc/mysql/conf.d/my.cnf' is ignored.</code>，这表示忽略了你的配置文件而使用了默认配置，原因是 MySQL 对配置文件有权限要求，需要是 0444</code> 权限，Linux 的话，可以通过 chmod 0444 master/conf/my.cnf</code> 和 chmod 0444 slave/conf/my.cnf</code> 来设置主从的配置文件权限。</p>
</blockquote>
4.2 配置主从</h3>
分别连接主从两个库(都使用 root 用户)。</p>
4.2.1 在主库创建用于同步的账号</h4>
在主库</strong>上执行以下命令，创建一个用于同步的账号 repl</code>，允许所有主机 %</code> 可访问，密码为 uxUw.SyCs)bb</code>，并授予 REPLICATION SLAVE</code> 权限，最后刷新权限:</p>
CREATE</span> USER</span> '</span>repl</span>'</span>@</span>'</span>%</span>'</span> IDENTIFIED </span>BY</span> '</span>uxUw.SyCs)bb</span>'</span>;  </span></span>
GRANT</span> REPLICATION SLAVE </span>ON</span> *</span>.</span>*</span> TO</span> '</span>repl</span>'</span>@</span>'</span>%</span>'</span>;  </span></span>
FLUSH PRIVILEGES;</span></span></code></pre>4.2.2 确认开始同步的位置</h4>
在主库</strong>执行命令查看主库的 binlog 当前文件名和位置：</p>
mysql> SHOW MASTER STATUS;</span></span>
+------------------+----------+--------------+------------------+-------------------+</span></span>
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |</span></span>
+------------------+----------+--------------+------------------+-------------------+</span></span>
| mysql-bin.000003 |      879 |              |                  |                   |</span></span>
+------------------+----------+--------------+------------------+-------------------+</span></span>
1 row in set (0.00 sec)</span></span></code></pre>4.2.3 在从库配置主库信息</h4>
在从库</strong>上配置从主库同步使用的信息：</p>
CHANGE </span>MASTER</span> TO</span></span>
    MASTER_HOST </span>=</span> '</span>mysql-master</span>'</span>,              </span></span>
    MASTER_PORT </span>=</span> '</span>3306</span>'</span>,</span></span>
    MASTER_USER </span>=</span> '</span>repl</span>'</span>,</span></span>
    MASTER_PASSWORD </span>=</span> '</span>uxUw.SyCs)bb</span>'</span>,</span></span>
    MASTER_LOG_FILE </span>=</span> '</span>mysql-bin.000003</span>'</span>,</span></span>
    MASTER_LOG_POS </span>=</span> 879</span>;</span></span></code></pre>
各个参数含义如下：</p>

MASTER_HOST</code>：主库的 IP 地址或域名，由于这里使用的是 docker-compose</code>，他们在同一个 docker-compose.yml</code> 文件中声明，所以可以直接使用容器名称 mysql-master</code> 互相访问。</li>
MASTER_PORT</code>：主库的端口号。</li>
MASTER_USER</code>：用于从主库复制的账号。</li>
MASTER_PASSWORD</code>：用于从主库复制的账号的密码。</li>
MASTER_LOG_FILE</code>：主库的 binlog 当前文件名，表示从库从主库的哪个 binlog 文件开始复制，这里参考上一步我们从主库获取到的信息。</li>
MASTER_LOG_POS</code>：主库的 binlog 当前位置，表示从库从主库指定 binlog 的哪个位置开始复制，这里参考上一步我们从主库获取到的信息。</li>
</ul>
4.2.4 从库</strong>启用同步</h4>
由于我们在 my.conf 中配置的参数 skip_slave_start</code> 为 true，所以需要手动启动同步，且非常建议手动启动，这样可以避免不可预知的情况导致从库自动启动同步，从而导致数据丢失。</p>
START</span> SLAVE;</span></span></code></pre>4.2.5 验证同步</h4>
可在主库</strong>上建库、建表，插入数据等操作，从库</strong>应该会自动同步过来。</p>


debian 11 vps 安装 pve7
2023-09-27T20:10:00+08:00
1 基础环境配置</h2>
1.1 配置 hosts</h3>
1.1.1 检查是否启用了 manage_etc_hosts</code></h4>
先 cat /etc/hosts</code> 文件，查看下默认配置，看看有没有一些注释说明该文件是自动设置的（一般 cloud-init</code> 方式安装的系统会有这个），如 vultr</code> 的该文件开头注释：</p>
# Your system has configured 'manage_etc_hosts' as True.</span></span>
# As a result, if you wish for changes to this file to persist</span></span>
# then you will need to either</span></span>
# a.) make changes to the master file in /etc/cloud/templates/hosts.debian.tmpl</span></span>
# b.) change or remove the value of 'manage_etc_hosts' in</span></span>
#     /etc/cloud/cloud.cfg or cloud-config from user-data</span></span>
#</span></span></code></pre>
注释的意思是，你的系统开启了 manage_etc_hosts</code> 功能，如果你想修改 /etc/hosts</code> 内容，有两种办法：</p>

编辑模板文件 /etc/cloud/templates/hosts.debian.tmpl</code>，这种重启后 /etc/hosts</code> 会自动重置为该模板的内容。</li>
修改 /etc/cloud/cloud.cfg</code> 文件，关闭掉 manage_etc_hosts</code> 功能，然后再修改 /etc/hosts</code>。
推荐使用第一种方式。</li>
</ol>
1.1.2 修改 hosts 文件</h4>
需保证 /etc/hosts</code> 文件为下面的内容，第二行要修改为你服务器的 ip</code> 地址和 hostname</code>，如我的 ip</code> 为 45.76.157.191</code>，hostname</code> 为 vultr</code>：</p>
127.0.0.1</span>       localhost</span></span>
45.76.157.191</span>   vultr.proxmox.com</span> vultr</span></span>
</span>
#</span> The following lines are desirable for IPv6 capable hosts</span></span>
:</span>:</span>1</span>     localhost</span> ip6-localhost</span> ip6-loopback</span></span>
ff02::1</span> ip6-allnodes</span></span>
ff02::2</span> ip6-allrouters</span></span></code></pre>

如果你检查到你机器启用了 manage_etc_hosts</code> 功能，不要直接修改 /etc/hosts</code>，而是按照上一步的方式修改，且改完要重启后</strong>重新查看 /etc/hosts</code> 确认已经修改成功了噢。</p>
</blockquote>
1.2 验证 hosts</h3>
然后执行 hostname --ip-address</code> 来查看 hosts 是否配置正确，正常应该返回你机器的 ip</code>，如我 ip</code> 是 45.76.157.191</code>：</p>
root@vultr:~#</span> hostname</span> -</span>-ip-address</span></span>
45.76.157.191</span></span></code></pre>1.3 网络配置</h3>
先通过 ifconfig</code> 查看你机器的主要网卡：</p>
root@vultr:~#</span> ifconfig</span></span>
enp1s0:</span> flags=</span>4163</span><</span>UP,BROADCAST,RUNNING,MULTICAS</span>T</span>></span>  mtu</span> 1500</span></span>
        inet</span> 45.76.157.191</span>  netmask</span> 255.255.254.0</span>  broadcast</span> 45.76.157.255</span></span>
        inet6</span> fe80::5400:4ff:fe94:96a9</span>  prefixlen</span> 64</span>  scopeid</span> 0x20</span><</span>lin</span>k</span>></span></span>
        inet6</span> 2001:19f0:4400:49aa:5400:4ff:fe94:96a9</span>  prefixlen</span> 64</span>  scopeid</span> 0x0</span><</span>globa</span>l</span>></span></span>
        ether</span> 56:00:04:94:96:a9</span>  txqueuelen</span> 1000</span>  (Ethernet</span>)</span></span>
        RX</span> packets</span> 829</span>  bytes</span> 129892</span> (126.8</span> KiB</span>)</span></span>
        RX</span> errors</span> 0</span>  dropped</span> 0</span>  overruns</span> 0</span>  frame</span> 0</span></span>
        TX</span> packets</span> 853</span>  bytes</span> 274794</span> (268.3</span> KiB</span>)</span></span>
        TX</span> errors</span> 0</span>  dropped</span> 0</span> overruns</span> 0</span>  carrier</span> 0</span>  collisions</span> 0</span></span>
</span>
lo:</span> flags=</span>73</span><</span>UP,LOOPBACK,RUNNIN</span>G</span>></span>  mtu</span> 65536</span></span>
        inet</span> 127.0.0.1</span>  netmask</span> 255.0.0.0</span></span>
        inet6</span> ::1</span>  prefixlen</span> 128</span>  scopeid</span> 0x10</span><</span>hos</span>t</span>></span></span>
        loop</span>  txqueuelen</span> 1000</span>  (Local</span> Loopback</span>)</span></span>
        RX</span> packets</span> 0</span>  bytes</span> 0</span> (0.0</span> B</span>)</span></span>
        RX</span> errors</span> 0</span>  dropped</span> 0</span>  overruns</span> 0</span>  frame</span> 0</span></span>
        TX</span> packets</span> 0</span>  bytes</span> 0</span> (0.0</span> B</span>)</span></span>
        TX</span> errors</span> 0</span>  dropped</span> 0</span> overruns</span> 0</span>  carrier</span> 0</span>  collisions</span> 0</span></span></code></pre>
从返回的信息中看到我的网卡名称是 enp1s0</code>，先查看 vim /etc/network/interfaces</code> 文件，原内容为：</p>
#</span> network interface settings; autogenerated</span></span>
#</span> Please do NOT modify this file directly, unless you know what</span></span>
#</span> you're doing.</span></span>
#</span></span>
#</span> If you want to manage parts of the network configuration manually,</span></span>
#</span> please utilize the 'source' or 'source-directory' directives to do</span></span>
#</span> so.</span></span>
#</span> PVE will preserve these directives, but will NOT read its network</span></span>
#</span> configuration from sourced files, so do not attempt to move any of</span></span>
#</span> the PVE managed interfaces into external files!</span></span>
</span>
source</span> /etc/network/interfaces.d/</span>*</span></span>
</span>
auto</span> lo</span></span>
iface</span> lo</span> inet</span> loopback</span></span>
</span>
auto</span> enp0s2</span></span>
iface</span> enp0s2</span> inet</span> dhcp</span></span></code></pre>
在最后新增两行，其中 enp1s0</code> 为你的网卡地址，注意检查下，如果你这个配置文件已经默认有该配置了，就不用配了：</p>
auto enp1s0</span></span>
iface enp1s0 inet dhcp</span></span></code></pre>1.4 禁用 cloud-init</code> 网络配置（可选）</h3>
如果你的服务器网络不是使用 cloud-init</code> 设置的，请跳过此部分。如果你不清楚，可以通过检查您的服务器上是否存在 /etc/network/interfaces.d/50-cloud-init</code> 文件来验证这一点，有则说明你需要这一步操作。
先执行 vim /etc/cloud/cloud.cfg.d/99-custom-networking.cfg</code> 编辑文件，内容为：</p>
network: {config: disabled}</span></span></code></pre>
保存上面的文件后，执行命令 rm -f /etc/network/interfaces.d/50-cloud-init</code> 删除 cloud-init</code> 网络配置文件。</p>
然后 reboot</code> 重启服务器，重启后请再次执行 hostname --ip-address</code> 来查看 hosts 是否配置正确，正常应该返回你机器的 ip</code>。</p>
2 安装 PVE</h2>
2.1 配置 debian 11 国内镜像源 (可选)</h3>
debian 11</code> 默认的镜像源可能是国外的，为了加速软件安装，可配置为国内的，如果你不需要，可跳过这一步。
执行命令 vim /etc/apt/sources.list</code> 编辑文件内容为：</p>
deb</span> https://mirrors.tuna.tsinghua.edu.cn/debian/</span> bullseye</span> main</span> contrib</span> non-free</span></span>
deb-src</span> https://mirrors.tuna.tsinghua.edu.cn/debian/</span> bullseye</span> main</span> contrib</span> non-free</span></span>
deb</span> https://mirrors.tuna.tsinghua.edu.cn/debian/</span> bullseye-updates</span> main</span> contrib</span> non-free</span></span>
deb-src</span> https://mirrors.tuna.tsinghua.edu.cn/debian/</span> bullseye-updates</span> main</span> contrib</span> non-free</span></span>
deb</span> https://mirrors.tuna.tsinghua.edu.cn/debian/</span> bullseye-backports</span> main</span> contrib</span> non-free</span></span>
deb-src</span> https://mirrors.tuna.tsinghua.edu.cn/debian/</span> bullseye-backports</span> main</span> contrib</span> non-free</span></span>
deb</span> https://mirrors.tuna.tsinghua.edu.cn/debian-security</span> bullseye-security</span> main</span> contrib</span> non-free</span></span>
deb-src</span> https://mirrors.tuna.tsinghua.edu.cn/debian-security</span> bullseye-security</span> main</span> contrib</span> non-free</span></span></code></pre>2.2 添加 Proxmox VE 存储库</h3>
国外环境用：</p>
echo</span> "</span>deb [arch=amd64] http://download.proxmox.com/debian/pve bullseye pve-no-subscription</span>"</span> ></span> /etc/apt/sources.list.d/pve-install-repo.list</span></span></code></pre>
国内可用清华源：</p>
echo</span> "</span>deb [arch=amd64] https://mirrors.tuna.tsinghua.edu.cn/proxmox/debian bullseye pve-no-subscription</span>"</span> ></span> /etc/apt/sources.list.d/pve-install-repo.list</span></span></code></pre>2.3 添加 Proxmox VE 存储库密钥</h3>
wget</span> https://enterprise.proxmox.com/debian/proxmox-release-bullseye.gpg</span> -</span>O</span> /etc/apt/trusted.gpg.d/proxmox-release-bullseye.gpg</span> </span></span></code></pre>
然后校验下密钥文件是否正确：</p>
sha512sum</span> /etc/apt/trusted.gpg.d/proxmox-release-bullseye.gpg</span> </span></span></code></pre>
正常应该返回：</p>
7fb03ec8a1675723d2853b84aa4fdb49a46a3bb72b9951361488bfd19b29aab0a789a4f8c7406e71a69aabbc727c936d3549731c4659ffa1a08f44db8fdcebfa</span>  /etc/apt/trusted.gpg.d/proxmox-release-bullseye.gpg</span> </span></span></code></pre>2.4 更新镜像源</h3>
apt</span> update</span> -</span>y</span> &&</span> apt</span> full-upgrade</span> -</span>y</span></span></code></pre>2.5 安装 Proxmox VE 包</h3>
apt</span> install</span> proxmox-ve</span> postfix</span> open-iscsi</span> -</span>y</span></span></code></pre>
安装过程如果弹出一个 Postfix Configuration</code> 弹窗，选择 Local Only</code> 回车，然后还有个弹窗会显示你 domain，也直接回车。
安装完后，执行 reboot</code> 重启服务器。重启完就可以通过 https://youripaddress:8006 访问了。
如果访问不了，检查下是不是自带的 ufw</code> 防火墙处于开启状态，需关闭防火墙或开通 8006 端口：</p>
关闭防火墙并禁止开机自启：</p>
systemctl</span> stop</span> ufw</span></span>
systemctl</span> disable</span> ufw</span></span></code></pre>
放行 8006 端口：</p>
ufw</span> allow</span> 8006</span></span></code></pre>3 扩展工作</h2>
3.1 移除 os-prober (可选)</h3>
pve</code> 官方建议删除 os-prober</code> 软件包：
该 os-prober</code> 软件包会扫描主机的所有分区以创建双引导 GRUB</code> 条目。但扫描的分区还可以包括分配给虚拟机的分区，而虚拟机不希望将其添加为启动项。</p>
简而言之，如果你不需要在服务器上安装双系统，如一个 pve</code>，一个其他系统，您可以安全地删除该 os-prober</code> 软件包 (这不影响在 pve</code> 上开其他系统的 vm</code> 或  lxc</code>)：</p>
apt</span> remove</span> os-prober</span> -</span>y</span>;</span></span></code></pre>3.2 配置 CT Template 为清华源 (可选)</h3>
如果你需要加速 Proxmox</code> 网页端下载 CT Templates</code>，可以替换 CT Templates</code> 的源。</p>
具体方法：将 /usr/share/perl5/PVE/APLInfo.pm</code> 文件中默认的源地址 http://download.proxmox.com</code> 替换为</p>
https://mirrors.tuna.tsinghua.edu.cn/proxmox</span></span></code></pre>
可以使用以下命令一键修改：</p>
cp</span> /usr/share/perl5/PVE/APLInfo.pm</span> /usr/share/perl5/PVE/APLInfo.pm_back</span></span>
sed</span> -</span>i</span> '</span>s|http://download.proxmox.com|https://mirrors.tuna.tsinghua.edu.cn/proxmox|g</span>'</span> /usr/share/perl5/PVE/APLInfo.pm</span></span></code></pre>
重启后生效。</p>
3.3 禁用企业源</h3>
企业源是要收费的，不禁用掉的话，你 apt update</code> 时会报错：</p>
Err:7</span> https://enterprise.proxmox.com/debian/pve</span> bullseye</span> InRelease</span></span>
  401</span>  Unauthorized</span> [IP:</span> 2407:6180:1:a:70dc:f0ff:fe97:4cbb</span> 443]</span></span>
Reading</span> package</span> lists...</span> Done</span></span>
E:</span> Failed</span> to</span> fetch</span> https://enterprise.proxmox.com/debian/pve/dists/bullseye/InRelease</span>  401</span>  Unauthorized</span> [IP:</span> 2407:6180:1:a:70dc:f0ff:fe97:4cbb</span> 443]</span></span>
E:</span> The</span> repository</span> '</span>https://enterprise.proxmox.com/debian/pve bullseye InRelease</span>'</span> is</span> not</span> signed.</span></span>
N:</span> Updating</span> from</span> such</span> a</span> repository</span> can</span>'</span>t be done securely, and is therefore disabled by default.</span></span>
N: See apt-secure(8) manpage for repository creation and user configuration details.</span></span></code></pre>
禁用方式为编辑  /etc/apt/sources.list.d/pve-enterprise.list</code> 文件，注释掉第一行（即在第一行最前面加个 #</code>），修改完执行 apt update</code> 验证下没有上面的那个报错就是禁用成功了。</p>
3.4 屏蔽登录后弹窗</h3>
由于我们不是付费的订阅用户，所以 pve</code> 会在登录后弹窗提示：</p>
You</span> do</span> not</span> have</span> a</span> valid</span> subscription</span> for</span> this</span> server.</span> Please</span> visit [www.proxmox.com]</span>(</span>https://www.proxmox.com/proxmox-ve/pricing</span>)</span> to</span> get</span> a</span> list</span> of</span> available</span> options.</span></span></code></pre>
可通过以下命令屏蔽：</p>
sed</span> -</span>i.bak</span> "</span>s/data.status.toLowerCase() !== 'active'/false/g</span>"</span> /usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js</span> &&</span> systemctl</span> restart</span> pveproxy</span></span></code></pre>
命令含义是编辑 /usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js</code> 文件替换文件中内容 data.status !== 'Active'</code> 为 false</code>，并将原文件备份为 .bak</code> 后缀，然后重启 pve</code> 服务。</p>
修改完可以重新登录 pve</code> 验证是否还有弹窗，如果还有检查下是不是浏览器缓存，如果还是不行，可能你用的版本不适用这个修改方式，请重新在搜索引擎搜索你所用 pve</code> 版本的去除弹窗方式。</p>
4 开 lxc 容器</h2>
4.1 下载 LXC 模板</h3>
点击左侧磁盘图标的 local(机器hostname)</code>，然后选 CT 模板</code>，点 模板</code>，选择要下载的系统模板，然后下载即可。</p>
4.2 创建 LXC 容器</h3>
点击 pve 网页右上角的 创建 CT</code>，按照提示填写即可，网络中：</p>

桥接</code> 选择 vmbr0</code> 网卡</li>
IPv4</code> 选择静态</li>
IPv4/CIDR</code>：写 10.10.10.100/24</code>，其中 10.10.10.100</code> 是容器 IP 地址。</li>
网关（IPv4）</code>：写 10.10.10.1</code></li>
其他的保持默认即可。</li>
</ul>
添加完，启动即可。</p>
4.3 添加 ssh 服务并允许 root 登录</h3>
启动 lxc</code> 容器后，先使用宿主机 ping 一下，确保可以 ping 通，然后就可以通过控制台连接了，如果控制台连接不上，可点击右上方的选项，使用其他方式的控制台访问，进入到服务器 shell 命令行后输入账号密码登录，接下来执行命令安装 ssh</code> 服务，可远程连接：</p>
如果是 centos</code>，则需要安装 ssh</code> 服务：</p>
yum</span> install</span> openssh-server</span></span>
systemctl</span> start</span> sshd.service</span></span>
systemctl</span> enable</span> sshd.service</span></span></code></pre>
如果是 debian/ubuntu</code>，默认已安装 ssh，但禁止了 root 用户登录，需开启：</p>
sed -i '/PermitRootLogin /c PermitRootLogin yes' /etc/ssh/sshd_config</span></span>
systemctl restart sshd</span></span></code></pre>


RabbitMQ 笔记
2023-09-05T20:25:00+08:00
1 基本概念</h2>
1.1 为什么要用 MQ？</h3>
主要是因为 MQ 可以实现以下三种功能：</p>

服务解耦：如 A 服务产生数据后要发送给下游的 B、C、D 服务：

使用传统模式：要一个一个调用给对方，如果新增或修改下游，还要修改代码，还要保证所有服务都可以收到，且下游服务直接依赖上游的服务 A。</li>
使用 MQ：则 A 可以直接将消息发送到消息队列，下游需要时可主动去订阅服务，不需要时取消订阅即可。避免了服务之间的耦合。</li>
</ul>
</li>
流量削峰：如有一个应用，每秒最多可以处理 300 个请求，但高峰期突然会每秒产生 3000 个请求：

使用传统模式：需要增加到 10 台服务器来处理，不然请求可能会超时。但平时又用不到这么多服务器，动态扩容缩减服务器很麻烦且扩缩容本身也需要时间。</li>
使用 MQ：可以将请求发送到消息队列中，然后根据自身的处理能力慢慢从消息队列中取消息来消费，这样对于客户端的请求不会一直在等待服务端处理，避免客户端请求超时。</li>
</ul>
</li>
异步调用：如用户下订单后，还需要做扣减余额、库存、通知发货等操作：

使用传统模式：依次调用对应服务的接口来处理，但每个服务处理时间不定，会导致客户端一直在等待。</li>
使用 MQ：将信息发送到对应的消息队列中即可，每个服务取自己要处理的数据，客户端不用一直等待。相当于异步调用了其他服务的接口。</li>
</ul>
</li>
</ol>
1.2 类似 MQ 产品</h3>

Kafka：分布式消息队列，高吞吐量，适用于日志场景。</li>
RabbitMQ</strong>：基于 AMQP 协议，erlang 语言开发，老牌功能全、扩展多、稳定性好。</li>
RocketMQ：基于 JMS 协议，阿里出品，目前交由 Apache 基金会</li>
</ul>
2 安装</h2>
RabbitMQ</a> 是使用 Erlang</code> 语言开发的，可使用 docker-compose</code> 进行安装：</p>
v</span>ersion</span>:</span> '</span>3.7</span>'</span></span>
s</span>ervices</span>:</span></span>
  r</span>abbitmq</span>:</span></span>
    i</span>mage</span>:</span> r</span>abbitmq:3-management</span></span>
    c</span>ontainer_name</span>:</span> r</span>abbitmq</span></span>
    e</span>nvironment</span>:</span></span>
      R</span>ABBITMQ_DEFAULT_USER</span>:</span> a</span>dmin</span></span>
      R</span>ABBITMQ_DEFAULT_PASS</span>:</span> x</span>xxxx</span></span>
    p</span>orts</span>:</span></span>
      -</span> 1</span>5672:15672</span></span>
      -</span> 5</span>672:5672</span></span></code></pre>

image</code>：tag 中带 -management</code> 的是带管理网页的。</li>
environment</code>

RABBITMQ_DEFAULT_PASS</code>：默认用户名</li>
RABBITMQ_DEFAULT_PASS</code>：默认密码</li>
</ul>
</li>
ports</code>

15672</code>：http</code> 协议的管理页面断开</li>
5672</code>：amqp</code> 协议的端口号，一般用于各个语言 sdk</code> 连接。</li>
</ul>
</li>
</ul>
docker-compose up -d</code> 后可以访问 ip:15672</code> 访问管理页面。</p>
3 管理页面概述</h2>
3.1 Overview</h3>
</p>
3.2 Connections</h3>
</p>

Name</code>： 连接名，点击连接名, 还可以查看详细的信息</li>
User name</code>： 当前连接登录 MQ 的用户</li>
State</code>： 当前连接的状态，running 运行</code> idle 空闲</code></li>
SSL|TLS</code>： 是否使用的是 SSL|TLS协议</code></li>
Protocol</code>： AMQP 0-9-1</code> 指的是 AMQP 的协议版本号</li>
Channels</code>： 当前连接创建的通道 (Channel</code>) 数</li>
From client</code>： 每秒发出的消息数</li>
To client</code>： 每秒接收的消息数</li>
</ul>
3.3 Channels</h3>
</p>
记录各个连接的信道：</p>
一个连接IP 可以有多个信道</code> 多个通道通过多线程实现，不相互干扰
生产者的通道一般使用完之后会立马关闭，消费者是一直监听的</p>

Channel</code>： 通道名称</li>
User name</code>： 通道创建者用户名</li>
Model</code>： 通道的确认模式 C confirm模式</code> T 表示事务</code></li>
State</code>： 通道当前的状态 running 运行</code> idie 空闲</code></li>
Unconfirmed</code>： 待确认的消息数</li>
Prefetch</code>： 预取消息数
Prefetch 表示每个消费者最大的能承受的未确认消息数目
简单来说就是用来指定一个消费者一次可以从 RabbitMQ 中获取多少条消息并缓存在消费者中，
一旦消费者的缓冲区满了，RabbitMQ 将会停止投递新的消息到该消费者中直到它发出有消息被 ack 了
消费者负责不断处理消息，不断 ack，然后只要 UnAcked</code> 数少于 Prefetch * consumer</code> 数目，RabbitMQ 就不断将消息投递过去</li>
Unacker</code>： 待 ack 的消息数</li>
publish</code>： 消息生产者发送消息的 速率</code></li>
confirm</code>： 消息生产者确认消息的 速率</code></li>
unroutable</code>： drop</code> 表示消息，未被接收，且已经删除的消息</li>
deliver / get</code>： 消息消费者获取消息的 速率</code></li>
ack</code>： 消息消费者 ack 消息的速率</li>
</ul>
3.4 Exchange</h3>
</p>
3.5 Queue</h3>
</p>

Name</code>：表示消息队列的名称</li>
Type</code>：消息队列的类型</li>
Features</code>：表示消息队列的特性，D 表示消息队列持久化</li>
State</code>：表示当前队列的状态，running 表示运行中，idle 表示空闲</li>
Ready</code>：表示待消费的消息总数</li>
Unacked</code>：表示待应答的消息总数</li>
Total</code>：表示消息总数 Ready</code> + Unacked</code></li>
incoming</code>：表示消息进入的速率</li>
deliver/get</code>：表示获取消息的速率</li>
ack</code>：表示消息应答的速率</li>
</ul>
3.6 Admin</h3>
</p>
4 基本概念</h2>
rabbitmq</code> 的架构图如下：

广义上分为：生产者、消费者、消息队列服务</p>
其中生产者、消费者通过 amqp</code> 协议与消息队列服务建立 connection</code> （物理/实际连接），再通过逻辑通信信道 channel</code> 进行生产或消费消息。(这所以这么做，是因为 connection 创建和连接是一个很重的操作，逻辑的 channel</code> 就相对轻量很多。)</p>
消息队列服务中还包含：</p>

Virtual Host</code>：类似多租户环境隔离、不同环境可以配置不同的 Virtual Host</code>，每个 Virtual Host</code> 中的 Exchange</code> 和 Queue</code> 互不影响（如可同名）。</li>
Exchange</code>：功能为交换机，用于决定将消息转发到实际的 Queue</code> 中，可以通过 Exchange</code> 实现多种不同的消息收发模式。（下面会介绍）</li>
Queue</code>：消息队列本体</li>
Broker</code>：表示 RabbitMQ 服务端</li>
</ul>
4.1 Exchange 属性概述</h3>

红色圈住的是 Exchange</code> 在网页中的入口。
蓝色圈住的是 Exchange</code> 列表（本图中的都是 rabbitmq</code> 系统默认提供的）
黄色圈住的是创建 Exchange</code> 的参数：</p>

Name</code>：Exchange</code> 名称，同一个 Virtual Host</code> 中不能重复。</li>
Type</code>：目前只需要了解 direct，还有 fanout、headers、topic，路由功能不同，后面会一一讲解。</li>
Durability</code>：是否需要持久化（如蓝色框中 Features 列标记了一个 D</code>，就是当前参数启用的意思）</li>
Auto Delete</code>：当有客户端连接后，所有客户端断开与当前 Exchange</code> 的连接后，是否自动删除该 Exchagne</code></li>
Intenal</code>：是否仅用于 rabbitmq 内部使用（可以用于记录 rabbitmq 日志，如蓝色框中的 amq.rabbitmq.trace</code> 的 Features 中标记了一个 I</code>，就是当前参数启用的意思）</li>
Arguments</code>：扩展的参数信息，可根据业务需要自定义。</li>
</ul>

如果系统中有多个 Virtual host</code>，创建 Exchange</code> 时也会让选择所属 Virtual host</code>。</p>
</blockquote>
4.2 Queue 属性概述</h3>

红色圈住的是 Queue</code> 在网页中的入口。
蓝色圈住的是 Queue</code> 列表，默认是什么都没有的。
黄色圈住的是创建 Queue</code> 的参数：</p>

Virtual host</code>：虚拟主机，用来数据隔离。</li>
Type</code>

Default for virtual host</code>：使用创建 Virtual host</code> 时的默认值。</li>
Classic</code>：经典模式的队列</li>
Quorum</code>：特点是自动复制，可以在多个节点之间复制消息。</li>
Stream</code>：流式队列，面向日志场景，具有高吞吐量，采用追加写入模式。</li>
</ul>
</li>
Name</code>：队列名称</li>
Durability</code>：是否持久化</li>
Arguments</code>：扩展的参数信息，可根据业务需要自定义。</li>
</ul>
4.3 Exchange 和 Queue 绑定</h3>
现在已添加一个名为 my-exchange</code> 的 Exchange</code> 和一个名为 my-queue</code> 的 Queue</code>，现在尝试绑定两者。如：

</p>
红色框住的是功能入口
蓝色框住的是已经绑定的 exchange，可以看到这里已经有一个默认绑定的，这个就是在 Exchange 页面看到的名为 (AMQP default)</code> 的 exchange。
黄色框住的是绑定所需的参数：</p>

From exchange</code>：要绑定到的 Exchange</code> 名称</li>
Routing key</code>：绑定的路由 key，建议与 Exchange</code> 同名。后面也可以通过这个 key 来过滤 queue。</li>
Arguments</code>：扩展的参数信息，可根据业务需要自定义。</li>
</ul>
4.4 通过网页端发送消息</h3>
</p>
我们在 my-exchange</code> 交换机中发送消息：
Routing Key</code> 使用 Exchange 和 Queue 绑定时设置的值。
Payload</code> 要发送的消息正文。</p>
发送成功后会提示：Message published.</code>
如 Routing Key</code> 写错，可能会提示：Message published, but not routed.</code></p>
4.5 通过网页端接收消息</h3>
然后切换到 Queue</code> 标签，可以看到绑定时对应 Routing Key</code>  的队列 my-queue</code> 中有一条消息。
</p>
点进去 my-queue</code> 队列详情后，可接收消息：
</p>
接收消息有三个参数：</p>

Ack Mode</code>：应答模式

Nack message request true</code>：获取消息，但不做 ack 应答确认，消息重新入队，可以批量 Nack</code></strong>。</li>
Automatic ack</code>：获取消息，应答确认，消息不重新入队，将会从队列中删除</li>
Reject requeue true</code>：拒绝获取消息，消息重新入队，只能拒绝单条消息</strong>。</li>
Reject requeue false</code>：拒绝获取消息，消息不重新入队，将会被删除，只能拒绝单条消息</strong>。</li>
</ul>
</li>
Encoding</code>：消息编码

Auto string / base64</code>：因为可能会传输二进制消息，但二进制消息基本不可读很难在浏览器上显示，如果消息可以被解释成 UTF-8 的字符串，则按照字符串显示，否则将以 base64</code> 进行编码后显示。</li>
base64</code>：读取消息后使用 base64</code> 格式显示。</li>
</ul>
</li>
Messages</code>：一次从队列获取消息的数量</li>
</ul>
4.6 通过 Java 声明 Exchange、Queue、Binding</h3>
通过 maven 引入依赖</p>
<dependency></span></span>
    <groupId>com.rabbitmq</groupId></span></span>
    <artifactId>amqp-client</artifactId></span></span>
    <version>5.14.2</version></span></span>
</dependency></span></span></code></pre>public static void main(String[] args) throws IOException, TimeoutException {  </span></span>
    String queueName = "my-queue";  </span></span>
    String exchangeName = "my-exchange";  </span></span>
    String routingKey = "my-routing-key";  </span></span>
</span>
    // 连接信息</span></span>
    ConnectionFactory factory = new ConnectionFactory();  </span></span>
    factory.setHost("127.0.0.1");  </span></span>
    factory.setPort(5672);   // amqp 协议的端口</span></span>
    factory.setUsername("admin");  </span></span>
    factory.setPassword("123456");</span></span>
</span>
    // 创建连接</span></span>
    try (Connection connection = factory.newConnection()) {  </span></span>
        // 创建 channel</span></span>
        Channel channel = connection.createChannel();  </span></span>
        // 声明交换机  </span></span>
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT, true, false, null);</span></span>
        // 声明队列  </span></span>
        channel.queueDeclare(queueName, true, false, false, null);  </span></span>
        // 将交换机与队列绑定  </span></span>
        channel.queueBind(queueName, exchangeName, routingKey);  </span></span>
    } catch (Exception e) {  </span></span>
        e.printStackTrace();  </span></span>
    }  </span></span>
}</span></span></code></pre>
其中 exchangeDeclare</code> 方法的参数如下：</p>

exchange</code>：交换机名称</li>
type</code>：类型，支持 direct</code>、fanout</code>、headers</code>、topic</code></li>
durable</code>：是否持久化</li>
autoDelete</code>：是否自动删除</li>
arguments</code>：业务额外参数</li>
</ul>
其中 queueDeclare</code> 方法的参数如下：</p>

queue</code>：队列的名称</li>
durable</code>：是否持久化。</li>
exclusive</code>：是否排他，如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除。排他队列是基于Connection可见，同一个Connection的不同Channel是可以同时访问同一个连接创建的排他队列，并且，如果一个Connection已经声明了一个排他队列，其他的Connection是不允许建立同名的排他队列的，即使该队列是持久化的，一旦Connection关闭或者客户端退出，该排他队列都会自动被删除。</li>
autoDelete</code>：是否自动删除。</li>
arguments</code>：设置队列的其他一些参数，这里我们暂时不需要什么其他参数。</li>
</ul>
其中 queueBind</code> 方法参数如下：</p>

queue</code>：需要绑定的队列名称。</li>
exchange</code>：需要绑定的交换机名称。</li>
routingKey</code>：绑定用的 key。</li>
</ul>
4.7 通过 Java 发送消息</h3>
public static void main(String[] args) throws IOException, TimeoutException {  </span></span>
    String queueName = "my-queue";  </span></span>
    String exchangeName = "my-exchange";  </span></span>
    String routingKey = "my-routing-key";  </span></span>
</span>
    // 连接信息</span></span>
    ConnectionFactory factory = new ConnectionFactory();  </span></span>
    factory.setHost("127.0.0.1");  </span></span>
    factory.setPort(5672);  </span></span>
    factory.setUsername("admin");  </span></span>
    factory.setPassword("123456");</span></span>
</span>
    // 创建连接</span></span>
    try (Connection connection = factory.newConnection()) {  </span></span>
        // 创建 channel</span></span>
        Channel channel = connection.createChannel();  </span></span>
        // 声明交换机  </span></span>
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT, true, false, false,null);</span></span>
        // 声明队列  </span></span>
        channel.queueDeclare(queueName, true, false, false, null);  </span></span>
        // 将交换机与队列绑定  </span></span>
        channel.queueBind(queueName, exchangeName, routingKey);  </span></span>
        </span></span>
        // 向交换机发送消息  </span></span>
        channel.basicPublish(exchangeName, routingKey, null, "Hello World!".getBytes());</span></span>
    } catch (Exception e) {  </span></span>
        e.printStackTrace();  </span></span>
    }  </span></span>
}</span></span></code></pre>
channel.basicPublish</code> 方法用于发送消息，参数如下：</p>

exchange</code>：交换机名称</li>
routingKey</code>：路由 key</li>
props</code>：其他额外的参数配置</li>
body</code>：消息体，byte[]</code> 类型的</li>
</ul>
其中 exchange</code> 参数可以写空字符串 ""</code>，这样的话，第二个参数 routingKey</code> 字段要写参数为队列名称，这样可以 "直接" 往队列中发送消息 (其实使用的是自带的 (AMQP default)</code> 交换机，他默认与所有队列绑定，无需 routingKey，或者说 routingKey 就是队列名</strong>)</p>
public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws IOException</span>,</span> TimeoutException </span>{</span>  </span></span>
    String</span> queueName</span> =</span> "</span>my-queue</span>"</span>;</span>  </span></span>
  </span></span>
    //</span> 连接信息  </span></span>
    ConnectionFactory</span> factory</span> =</span> new</span> ConnectionFactory</span>(</span>)</span>;</span>  </span></span>
    factory</span>.</span>setHost</span>(</span>"</span>127.0.0.1</span>"</span>)</span>;</span>  </span></span>
    factory</span>.</span>setPort</span>(</span>5672</span>)</span>;</span>  </span></span>
    factory</span>.</span>setUsername</span>(</span>"</span>admin</span>"</span>)</span>;</span>  </span></span>
    factory</span>.</span>setPassword</span>(</span>"</span>123456</span>"</span>)</span>;</span>  </span></span>
  </span></span>
    //</span> 创建连接  </span></span>
    try</span> (</span>Connection</span> connection</span> =</span> factory</span>.</span>newConnection</span>(</span>)</span>)</span> {</span>  </span></span>
        //</span> 创建 channel        </span></span>
        Channel</span> channel</span> =</span> connection</span>.</span>createChannel</span>(</span>)</span>;</span>  </span></span>
        //</span> 声明队列  </span></span>
        channel</span>.</span>queueDeclare</span>(</span>queueName</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span>  </span></span>
  </span></span>
        //</span> 向交换机发送消息  </span></span>
        channel</span>.</span>basicPublish</span>(</span>"</span>"</span>,</span> queueName</span>,</span> null</span>,</span> "</span>Hello World!</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span>  </span></span>
    }</span> catch</span> (</span>Exception</span> e</span>)</span> {</span>  </span></span>
        e</span>.</span>printStackTrace</span>(</span>)</span>;</span>  </span></span>
    }</span>  </span></span>
}</span></span></code></pre>4.8 通过 Java 接收消息（被动等待推送）</h3>
public static void main(String[] args) throws IOException, TimeoutException {  </span></span>
    String queueName = "my-queue";  </span></span>
  </span></span>
    // 连接信息  </span></span>
    ConnectionFactory factory = new ConnectionFactory();  </span></span>
    factory.setHost("127.0.0.1");  </span></span>
    factory.setPort(5672);  </span></span>
    factory.setUsername("admin");  </span></span>
    factory.setPassword("123456");  </span></span>
  </span></span>
    Connection connection = factory.newConnection();  </span></span>
    // 创建 channel    </span></span>
    Channel channel = connection.createChannel();  </span></span>
  </span></span>
    // 监听队列的消息  </span></span>
    channel.basicConsume(queueName, false, (consumerTag, message) -> {  </span></span>
        log.info("收到消息: {}", new String(message.getBody()));  </span></span>
        // 手动确认消息  </span></span>
        channel.basicAck(message.getEnvelope().getDeliveryTag(), false);  </span></span>
    }, consumerTag -> {  </span></span>
        log.info("消息消费被中断");  </span></span>
    });  </span></span>
}</span></span></code></pre>
channel.basicConsume</code> 方法用于接收消息，参数如下：</p>

queue</code>：队列名称</li>
autoAck</code>：是否自动回复 ack 消息，开启为 true 时，只要接收到消息，不论消息处理过程是否有报错，都会返回 ack，消息队列会将消息从队列删除。为 false，则需要程序中手动确认回复 ack 还是 nack、reject</li>
deliverCallback</code>：消息接收后的回调函数</li>
cancelCallback</code>：当消费者取消订阅时进行的函数回调</li>
</ul>
这只是较为常用的一个方法，channel.basicConsume</code> 还有很多重载方法，最完整的方法中还包含：</p>

指定 consumerTag</code>，即消费者的 id，在每个 channel</code> 中不可重复。</li>
指定更多回调：

void handleConsumeOk(String consumerTag)</code>：当消费者通过调用 channel.basicConsume</code> 方法注册时调用。</li>
void handleCancelOk(String consumerTag)</code>：当显示调用 channel.basicCancel</code> 方法取消消费者时调用</li>
void handleShutdownSignal(String consumerTag, ShutdownSignalException sig)</code>：当 connection</code> 或 channel</code> 关闭时会调用</li>
handleRecoverOk</code>：</li>
handleDelivery</code>：上面的 deliverCallback</code> 实际就是调用的这个方法</li>
handleCancel</code>：上面的 cancelCallback</code> 实际就是调用的这个方法</li>
</ul>
</li>
</ul>
4.9 通过 Java 接收消息（主动拉取）</h3>
除了监听某个队列的消息，等待 Broker 推送过来，还可以主动去拉取某个队列的消息：</p>
GetResponse</span> basicGet</span>(</span>String</span> queue</span>,</span> boolean</span> autoAck</span>)</span> throws IOExcepiton</span>;</span></span>
</span>
//</span> demo:</span></span>
GetResponse</span> getResponse</span> =</span> channel</span>.</span>basicGet</span>(</span>queueName</span>,</span> false</span>)</span>;</span>  </span></span>
if</span> (</span>getResponse </span>!=</span> null</span>)</span> {</span>  </span></span>
    channel</span>.</span>basicAck</span>(</span>getResponse</span>.</span>getEnvelope</span>(</span>)</span>.</span>getDeliveryTag</span>(</span>)</span>,</span> false</span>)</span>;</span>  </span></span>
}</span></span></code></pre>
其中 queue 表示从哪个队列获取消息，autoAck 表示是否自动 ack。不自动 ack 的话需要手动调用 channel.basicAck</code> 进行响应。</p>

虽然可以使用无限循环的方式主动拉取消息来实现和 basicConsume</code> 一样的效果，但是不建议这么做。这样会严重影响 RabbitMQ 的性能，如果要实现高吞吐量，还是建议使用 basicConsume</code>。</p>
</blockquote>
5 工作模式</h2>
5.1 基础模式</h3>
</p>
简单说就一个生产者 -> 消息队列 -> 一个消费者。
生产者只需要将消息丢入消息队列，消费者只需要去指定队列中取即可。如本文中的 2.6、2.7、2.8 的内容，就是基础模式。</p>
5.2 工作队列模式 Work Queue 交换机类型：direct (AMQP default)</code></h3>

其实就是一个生产者，两个消费者。两个消费者会轮流获取到消息，这里用代码实现如下：</p>
生产者每秒生产一条消息：</p>
public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws IOException</span>,</span> TimeoutException </span>{</span>  </span></span>
    String</span> queueName</span> =</span> "</span>my-queue</span>"</span>;</span>  </span></span>
  </span></span>
    //</span> 连接信息  </span></span>
    ConnectionFactory</span> factory</span> =</span> new</span> ConnectionFactory</span>(</span>)</span>;</span>  </span></span>
    factory</span>.</span>setHost</span>(</span>"</span>127.0.0.1</span>"</span>)</span>;</span>  </span></span>
    factory</span>.</span>setPort</span>(</span>5672</span>)</span>;</span>  </span></span>
    factory</span>.</span>setUsername</span>(</span>"</span>admin</span>"</span>)</span>;</span>  </span></span>
    factory</span>.</span>setPassword</span>(</span>"</span>123456</span>"</span>)</span>;</span>  </span></span>
  </span></span>
    //</span> 创建连接  </span></span>
    try</span> (</span>Connection</span> connection</span> =</span> factory</span>.</span>newConnection</span>(</span>)</span>)</span> {</span>  </span></span>
        //</span> 创建 channel        </span></span>
        Channel</span> channel</span> =</span> connection</span>.</span>createChannel</span>(</span>)</span>;</span>  </span></span>
        //</span> 声明队列  </span></span>
        channel</span>.</span>queueDeclare</span>(</span>queueName</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span>  </span></span>
  </span></span>
        int</span> n</span> =</span> 0</span>;</span>  </span></span>
        while</span> (</span>true</span>)</span> {</span>  </span></span>
            //</span> 向交换机发送消息  </span></span>
            channel</span>.</span>basicPublish</span>(</span>"</span>"</span>,</span> queueName</span>,</span> null</span>,</span> (</span>"</span>Hello World!, </span>"</span> +</span> n</span>)</span>.</span>getBytes</span>(</span>)</span>)</span>;</span>  </span></span>
            n</span>++</span>;</span>  </span></span>
            Thread</span>.</span>sleep</span>(</span>1000L</span>)</span>;</span>  </span></span>
        }</span>  </span></span>
    }</span> catch</span> (</span>Exception</span> e</span>)</span> {</span>  </span></span>
        e</span>.</span>printStackTrace</span>(</span>)</span>;</span>  </span></span>
    }</span>  </span></span>
}</span></span></code></pre>
两个消费者监听同一个队列的消息：</p>
private</span> static</span> final</span> String</span> queueName</span> =</span> "</span>my-queue</span>"</span>;</span></span>
</span>
public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws IOException</span>,</span> TimeoutException </span>{</span></span>
</span>
    //</span> 连接信息</span></span>
    ConnectionFactory</span> factory</span> =</span> new</span> ConnectionFactory</span>(</span>)</span>;</span></span>
    factory</span>.</span>setHost</span>(</span>"</span>127.0.0.1</span>"</span>)</span>;</span></span>
    factory</span>.</span>setPort</span>(</span>5672</span>)</span>;</span></span>
    factory</span>.</span>setUsername</span>(</span>"</span>admin</span>"</span>)</span>;</span></span>
    factory</span>.</span>setPassword</span>(</span>"</span>123456</span>"</span>)</span>;</span></span>
</span>
    Connection</span> connection</span> =</span> factory</span>.</span>newConnection</span>(</span>)</span>;</span></span>
    createConsumer</span>(</span>connection</span>,</span> "</span>消费者1</span>"</span>)</span>;</span></span>
    createConsumer</span>(</span>connection</span>,</span> "</span>消费者2</span>"</span>)</span>;</span></span>
}</span></span>
</span>
public</span> static</span> void</span> createConsumer</span>(</span>Connection</span> connection</span>,</span> String</span> consumerName</span>)</span> throws IOException </span>{</span></span>
    //</span> 创建 channel</span></span>
    Channel</span> channel</span> =</span> connection</span>.</span>createChannel</span>(</span>)</span>;</span></span>
</span>
    //</span> 监听队列的消息</span></span>
    channel</span>.</span>basicConsume</span>(</span>queueName</span>,</span> false</span>,</span> (</span>consumerTag</span>,</span> message</span>)</span> -></span> {</span></span>
        log</span>.</span>info</span>(</span>consumerName </span>+</span> "</span> 收到消息: {}</span>"</span>,</span> new</span> String</span>(</span>message</span>.</span>getBody</span>(</span>)</span>)</span>)</span>;</span></span>
        //</span> 手动确认消息</span></span>
        channel</span>.</span>basicAck</span>(</span>message</span>.</span>getEnvelope</span>(</span>)</span>.</span>getDeliveryTag</span>(</span>)</span>,</span> false</span>)</span>;</span></span>
    }</span>,</span> consumerTag </span>-></span> {</span></span>
        log</span>.</span>info</span>(</span>"</span>消息消费被中断</span>"</span>)</span>;</span></span>
    }</span>)</span>;</span></span>
}</span></span></code></pre>
先启动消费者，再启动生产者，然后消费者的控制台可以看到：</p>
15</span>:</span>14</span>:</span>00</span>.</span>878</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>5</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 0</span></span>
15</span>:</span>14</span>:</span>01</span>.</span>886</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>6</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者2 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 1</span></span>
15</span>:</span>14</span>:</span>02</span>.</span>895</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>7</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 2</span></span>
15</span>:</span>14</span>:</span>03</span>.</span>904</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>8</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者2 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 3</span></span>
15</span>:</span>14</span>:</span>04</span>.</span>914</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>9</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 4</span></span>
15</span>:</span>14</span>:</span>05</span>.</span>923</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>10</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者2 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 5</span></span>
15</span>:</span>14</span>:</span>06</span>.</span>934</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>11</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 6</span></span></code></pre>
刚才是队列初始时空的，然后先启动的消费者，再启动的生产者，两个消费者会轮流收到消息。</p>
但如果先启动消费者，再启动生产者，这时候队列中已经有一条消息了，这时候对积压的消息还会轮流处理吗？来试试。
我先生产一些消息，然后启动消费者，日志输出如下：</p>
15</span>:</span>19</span>:</span>40.124</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>4</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 16</span></span>
15</span>:</span>19</span>:</span>40.129</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>4</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 17</span></span>
15</span>:</span>19</span>:</span>40.130</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>4</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 18</span></span>
15</span>:</span>19</span>:</span>40.130</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>4</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 19</span></span>
15</span>:</span>19</span>:</span>40.130</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>6</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 20</span></span>
15</span>:</span>19</span>:</span>40.130</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>6</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 21</span></span>
15</span>:</span>19</span>:</span>40.130</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>6</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 22</span></span>
15</span>:</span>19</span>:</span>40.130</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>6</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 23</span></span>
15</span>:</span>19</span>:</span>40.130</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>6</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 24</span></span>
15</span>:</span>19</span>:</span>40.130</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>6</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>worker</span>.</span>RabbitReceiveTest</span> -</span> 消费者1 收到消息</span>:</span> Hello</span> World</span>!</span>,</span> 25</span></span></code></pre>
可以看到，如果一开始就存在消息，会被一个消费者一次性全部消耗，这是因为我们没有设置 Prefetch count</strong>（预获取数量，一次性获取消息的最大数量）进行限制，如图可以看到现在是没有限制的。
</p>
5.2.1 拓展：prefetchCount/qos</h4>
在 Java 中可以通过以下代码来设置：</p>
channel</span>.</span>basicQos</span>(</span>0</span>,</span> 1</span>,</span> true</span>)</span>;</span></span></code></pre>
参数释义如下：</p>

prefetchSize</code>：最大 unchecked 消息的字节数。</li>
prefetchCount</code>：最大 unchecked 消息的条数。0 表示无限制（消息过多可能会导致客户端内存溢出）</li>
global</code>：限定范围，true 为整个 channel</code>，false 为后续创建的 consumer</code></li>
</ul>

unchecked</code> 表示客户端接收到消息，但未回复 ack 的消息数量。如果 unchecked</code> = prefetchCount</code> 则服务端将不再发送消息给该消费者，直到 unchecked</code> < perfecthCount</code>。</p>
</blockquote>
如，一个 channel 中有一个消费者，想让这个消费者，一次最多有 10 条 unchecked 的消息：</p>
Channel</span> channel</span> =</span> .</span>.</span>.</span>;</span></span>
Consumer</span> consumer</span> =</span> .</span>.</span>.</span>;</span></span>
channel</span>.</span>basicQos</span>(</span>10</span>,</span> false</span>)</span>;</span> //</span> Per consumer limit</span></span>
channel</span>.</span>basicConsume</span>(</span>"</span>my-queue</span>"</span>,</span> false</span>,</span> consumer</span>)</span>;</span></span></code></pre>
如，一个 channel 中有两个消费者，每个消费者分别一次最多接收 10 条 unchecked 的消息。</p>
Channel</span> channel</span> =</span> .</span>.</span>.</span>;</span></span>
Consumer</span> consumer1</span> =</span> .</span>.</span>.</span>;</span></span>
Consumer</span> consumer2</span> =</span> .</span>.</span>.</span>;</span></span>
channel</span>.</span>basicQos</span>(</span>10</span>,</span> false</span>)</span>;</span> //</span> Per consumer limit</span></span>
channel</span>.</span>basicConsume</span>(</span>"</span>my-queue1</span>"</span>,</span> false</span>,</span> consumer1</span>)</span>;</span></span>
channel</span>.</span>basicConsume</span>(</span>"</span>my-queue2</span>"</span>,</span> false</span>,</span> consumer2</span>)</span>;</span></span></code></pre>
如，一个 channel 中有两个消费者，想让每个消费者分别一次最多接收 10 条 unchecked 的消息，但是一共加起来不能超过 15 条 unchecked 消息。</p>
Channel</span> channel</span> =</span> .</span>.</span>.</span>;</span></span>
Consumer</span> consumer1</span> =</span> .</span>.</span>.</span>;</span></span>
Consumer</span> consumer2</span> =</span> .</span>.</span>.</span>;</span></span>
channel</span>.</span>basicQos</span>(</span>10</span>,</span> false</span>)</span>;</span> //</span> Per consumer limit</span></span>
channel</span>.</span>basicQos</span>(</span>15</span>,</span> true</span>)</span>;</span>  //</span> Per channel limit</span></span>
channel</span>.</span>basicConsume</span>(</span>"</span>my-queue1</span>"</span>,</span> false</span>,</span> consumer1</span>)</span>;</span></span>
channel</span>.</span>basicConsume</span>(</span>"</span>my-queue2</span>"</span>,</span> false</span>,</span> consumer2</span>)</span>;</span></span></code></pre>

可以理解为 channel 有一个大的容器，里面可以存储 unchecked 消息，channel 中每个 consumer 在这个容器中有一部分自己的空间，但所有 channel 加起来的空间肯定不会超过整个 channel 的空间。</strong></p>
</blockquote>
扩展知识：
RabbitMQ</code> 的 global</code> 表示的含义和 AMQP 0-9-1</code> 标准协议中定义的不同。
AMQP 0-9-1</code> 中 global 的含义：</p>

true</code>：整个 connection 中所有消费者共享</li>
false</code>：整个 channel 中所有消费者共享
RabbitMQ</code> 中 global 的含义：</li>
true</code>：整个 channel 中所有消费者共享</li>
false</code>：分别应用于 channel 中每个消费者</li>
</ul>
参考链接：</p>

RabbitMQ 官方文档： https://www.rabbitmq.com/consumer-prefetch.html</li>
RabbitMQ 之 Qos prefetch[简书]： https://www.jianshu.com/p/4d043d3045ca</li>
</ol>
5.3 发布订阅模式 Publish/Subscribe 交换机类型 fanout</code></h3>

发布订阅模式就是有一个 fanout</code> 类型的交换机，N 个与该交换机绑定的队列。当生产者向这个交换机发送消息时，会向所有绑定的队列都发送消息（而不是工作队列模式 direct</code> 类型的交换机时，消费者轮流消费）。</p>
创建一个 fanout 类型的 exchange，并将两个队列绑定到该 exchange，然后发送一条消息：</p>
public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws IOException</span>,</span> TimeoutException </span>{</span>  </span></span>
    ConnectionFactory</span> factory</span> =</span> new</span> ConnectionFactory</span>(</span>)</span>;</span>  </span></span>
    factory</span>.</span>setHost</span>(</span>"</span>127.0.0.1</span>"</span>)</span>;</span>  </span></span>
    factory</span>.</span>setPort</span>(</span>5672</span>)</span>;</span>  </span></span>
    factory</span>.</span>setUsername</span>(</span>"</span>admin</span>"</span>)</span>;</span>  </span></span>
    factory</span>.</span>setPassword</span>(</span>"</span>123456</span>"</span>)</span>;</span>  </span></span>
  </span></span>
    Connection</span> connection</span> =</span> factory</span>.</span>newConnection</span>(</span>)</span>;</span>  </span></span>
    Channel</span> channel</span> =</span> connection</span>.</span>createChannel</span>(</span>)</span>;</span>  </span></span>
  </span></span>
  </span></span>
    //</span> 创建一个 fanout 类型的交换机  </span></span>
    String</span> exchangeName</span> =</span> "</span>my-fanout-exchange</span>"</span>;</span>  </span></span>
    channel</span>.</span>exchangeDeclare</span>(</span>exchangeName</span>,</span> BuiltinExchangeType</span>.</span>FANOUT</span>,</span> true</span>,</span> false</span>,</span> null</span>)</span>;</span>  </span></span>
  </span></span>
    //</span> 创建两个队列，绑定到交换机上，无需指定 routingKey    String queueName1 = "queue-one";  </span></span>
    String</span> queueName2</span> =</span> "</span>queue-two</span>"</span>;</span>  </span></span>
    channel</span>.</span>queueDeclare</span>(</span>queueName1</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span>  </span></span>
    channel</span>.</span>queueDeclare</span>(</span>queueName2</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span>  </span></span>
    channel</span>.</span>queueBind</span>(</span>queueName1</span>,</span> exchangeName</span>,</span> "</span>"</span>)</span>;</span>  </span></span>
    channel</span>.</span>queueBind</span>(</span>queueName2</span>,</span> exchangeName</span>,</span> "</span>"</span>)</span>;</span>  </span></span>
  </span></span>
    //</span> 向交换机发送消息  </span></span>
    channel</span>.</span>basicPublish</span>(</span>exchangeName</span>,</span> "</span>"</span>,</span> null</span>,</span> "</span>fanout 消息</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span>  </span></span>
}</span></span></code></pre>
当队列与 fanout 类型的 exchange 绑定时，routingKey 可以写空字符串，或者写任意字符都可以，都不影响 fanout 的功能。</p>
然后创建两个消费者，去获取这两个绑定到 fanout 的队列中的消息：</p>
public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws IOException</span>,</span> TimeoutException </span>{</span>  </span></span>
    ConnectionFactory</span> factory</span> =</span> new</span> ConnectionFactory</span>(</span>)</span>;</span>  </span></span>
    factory</span>.</span>setHost</span>(</span>"</span>127.0.0.1</span>"</span>)</span>;</span>  </span></span>
    factory</span>.</span>setPort</span>(</span>5672</span>)</span>;</span>  </span></span>
    factory</span>.</span>setUsername</span>(</span>"</span>admin</span>"</span>)</span>;</span>  </span></span>
    factory</span>.</span>setPassword</span>(</span>"</span>123456</span>"</span>)</span>;</span>  </span></span>
  </span></span>
    Connection</span> connection</span> =</span> factory</span>.</span>newConnection</span>(</span>)</span>;</span>  </span></span>
    Channel</span> channel</span> =</span> connection</span>.</span>createChannel</span>(</span>)</span>;</span>  </span></span>
  </span></span>
    //</span> 创建一个 fanout 类型的交换机  </span></span>
    String</span> exchangeName</span> =</span> "</span>my-fanout-exchange</span>"</span>;</span>  </span></span>
    channel</span>.</span>exchangeDeclare</span>(</span>exchangeName</span>,</span> BuiltinExchangeType</span>.</span>FANOUT</span>,</span> true</span>,</span> false</span>,</span> null</span>)</span>;</span>  </span></span>
  </span></span>
    //</span> 创建两个队列，绑定到交换机上，无需指定 routingKey    String queueName1 = "queue-one";  </span></span>
    String</span> queueName2</span> =</span> "</span>queue-two</span>"</span>;</span>  </span></span>
    channel</span>.</span>queueDeclare</span>(</span>queueName1</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span>  </span></span>
    channel</span>.</span>queueDeclare</span>(</span>queueName2</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span>  </span></span>
    channel</span>.</span>queueBind</span>(</span>queueName1</span>,</span> exchangeName</span>,</span> "</span>"</span>)</span>;</span>  </span></span>
    channel</span>.</span>queueBind</span>(</span>queueName2</span>,</span> exchangeName</span>,</span> "</span>"</span>)</span>;</span>  </span></span>
  </span></span>
    channel</span>.</span>basicConsume</span>(</span>queueName1</span>,</span> true</span>,</span> (</span>consumerTag</span>,</span> message</span>)</span> -></span> {</span>  </span></span>
        log</span>.</span>info</span>(</span>"</span>消费者1收到消息: {}</span>"</span>,</span> new</span> String</span>(</span>message</span>.</span>getBody</span>(</span>)</span>)</span>)</span>;</span>  </span></span>
    }</span>,</span> consumerTag </span>-></span> {</span>}</span>)</span>;</span>  </span></span>
  </span></span>
    channel</span>.</span>basicConsume</span>(</span>queueName2</span>,</span> true</span>,</span> (</span>consumerTag</span>,</span> message</span>)</span> -></span> {</span>  </span></span>
        log</span>.</span>info</span>(</span>"</span>消费者2收到消息: {}</span>"</span>,</span> new</span> String</span>(</span>message</span>.</span>getBody</span>(</span>)</span>)</span>)</span>;</span>  </span></span>
    }</span>,</span> consumerTag </span>-></span> {</span>}</span>)</span>;</span>  </span></span>
}</span></span></code></pre>
日志输出为：</p>
13</span>:</span>45</span>:</span>49.999</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>4</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>fanout</span>.</span>RabbitMQFanoutReceive</span> -</span> 消费者1收到消息</span>:</span> fanout 消息</span></span>
13</span>:</span>45</span>:</span>50.004</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>5</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>fanout</span>.</span>RabbitMQFanoutReceive</span> -</span> 消费者2收到消息</span>:</span> fanout 消息</span></span></code></pre>
可以看到两个队列都收到了这个消息，这就是 fanout 模式。</p>
5.4 路由模式 Routing 交换机类型：direct</code></h3>
这里和 3.2 工作队列模式</strong>很像, 只不过当时没有额外声明 exchange</code>，routingKey</code> 使用的是空字符串，这样会使用 RabbitMQ 自带的 (AMQP default)</code>，路由模式就是使用 routingkey</code> 将队列绑定到指定交换机，然后发送消息时，exchange</code> 会根据 routingKey</code> 转发到指定的队列中。</p>
如一个自定义 exchange，创建两个队列分别使用不同的 routingKey 绑定，然后分别向这两个 routingKey 发送不同的消息：</p>
public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws IOException</span>,</span> TimeoutException </span>{</span></span>
        ConnectionFactory</span> factory</span> =</span> new</span> ConnectionFactory</span>(</span>)</span>;</span></span>
        factory</span>.</span>setHost</span>(</span>"</span>127.0.0.1</span>"</span>)</span>;</span></span>
        factory</span>.</span>setPort</span>(</span>5672</span>)</span>;</span></span>
        factory</span>.</span>setUsername</span>(</span>"</span>admin</span>"</span>)</span>;</span></span>
        factory</span>.</span>setPassword</span>(</span>"</span>123456</span>"</span>)</span>;</span></span>
</span>
        Connection</span> connection</span> =</span> factory</span>.</span>newConnection</span>(</span>)</span>;</span></span>
        Channel</span> channel</span> =</span> connection</span>.</span>createChannel</span>(</span>)</span>;</span></span>
</span>
        //</span> 创建一个 direct 类型的交换机</span></span>
        String</span> exchangeName</span> =</span> "</span>my-routing-exchange</span>"</span>;</span></span>
        channel</span>.</span>exchangeDeclare</span>(</span>exchangeName</span>,</span> BuiltinExchangeType</span>.</span>DIRECT</span>,</span> true</span>,</span> false</span>,</span> null</span>)</span>;</span></span>
</span>
        //</span> 创建两个队列，绑定到交换机上，无需指定 routingKey</span></span>
        String</span> queueName1</span> =</span> "</span>queue-one</span>"</span>;</span></span>
        String</span> queueName2</span> =</span> "</span>queue-two</span>"</span>;</span></span>
        String</span> routingKey1</span> =</span> "</span>routing-key-1</span>"</span>;</span></span>
        String</span> routingKey2</span> =</span> "</span>routing-key-2</span>"</span>;</span></span>
</span>
        channel</span>.</span>queueDeclare</span>(</span>queueName1</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span></span>
        channel</span>.</span>queueDeclare</span>(</span>queueName2</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span></span>
        channel</span>.</span>queueBind</span>(</span>queueName1</span>,</span> exchangeName</span>,</span> routingKey1</span>)</span>;</span></span>
        channel</span>.</span>queueBind</span>(</span>queueName2</span>,</span> exchangeName</span>,</span> routingKey2</span>)</span>;</span></span>
</span>
        //</span> 向交换机发送消息</span></span>
        channel</span>.</span>basicPublish</span>(</span>exchangeName</span>,</span> routingKey1</span>,</span> null</span>,</span> "</span>routingKey1 message</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span></span>
        channel</span>.</span>basicPublish</span>(</span>exchangeName</span>,</span> routingKey2</span>,</span> null</span>,</span> "</span>routingKey2 message</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span></span>
    }</span></span></code></pre>
在创建两个消费者，分别取获取这两个队列的消息：</p>
public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws IOException</span>,</span> TimeoutException </span>{</span></span>
        ConnectionFactory</span> factory</span> =</span> new</span> ConnectionFactory</span>(</span>)</span>;</span></span>
        factory</span>.</span>setHost</span>(</span>"</span>127.0.0.1</span>"</span>)</span>;</span></span>
        factory</span>.</span>setPort</span>(</span>5672</span>)</span>;</span></span>
        factory</span>.</span>setUsername</span>(</span>"</span>admin</span>"</span>)</span>;</span></span>
        factory</span>.</span>setPassword</span>(</span>"</span>123456</span>"</span>)</span>;</span></span>
</span>
        Connection</span> connection</span> =</span> factory</span>.</span>newConnection</span>(</span>)</span>;</span></span>
        Channel</span> channel</span> =</span> connection</span>.</span>createChannel</span>(</span>)</span>;</span></span>
</span>
        //</span> 创建一个 direct 类型的交换机</span></span>
        String</span> exchangeName</span> =</span> "</span>my-routing-exchange</span>"</span>;</span></span>
        channel</span>.</span>exchangeDeclare</span>(</span>exchangeName</span>,</span> BuiltinExchangeType</span>.</span>DIRECT</span>,</span> true</span>,</span> false</span>,</span> null</span>)</span>;</span></span>
</span>
        //</span> 创建两个队列，绑定到交换机上，无需指定 routingKey</span></span>
        String</span> queueName1</span> =</span> "</span>queue-one</span>"</span>;</span></span>
        String</span> queueName2</span> =</span> "</span>queue-two</span>"</span>;</span></span>
        String</span> routingKey1</span> =</span> "</span>routing-key-1</span>"</span>;</span></span>
        String</span> routingKey2</span> =</span> "</span>routing-key-2</span>"</span>;</span></span>
</span>
        channel</span>.</span>queueDeclare</span>(</span>queueName1</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span></span>
        channel</span>.</span>queueDeclare</span>(</span>queueName2</span>,</span> true</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span></span>
        channel</span>.</span>queueBind</span>(</span>queueName1</span>,</span> exchangeName</span>,</span> routingKey1</span>)</span>;</span></span>
        channel</span>.</span>queueBind</span>(</span>queueName2</span>,</span> exchangeName</span>,</span> routingKey2</span>)</span>;</span></span>
</span>
        channel</span>.</span>basicConsume</span>(</span>queueName1</span>,</span> true</span>,</span> (</span>consumerTag</span>,</span> message</span>)</span> -></span> {</span></span>
            log</span>.</span>info</span>(</span>"</span>从队列 {} 中收到消息: {}</span>"</span>,</span> queueName1</span>,</span> new</span> String</span>(</span>message</span>.</span>getBody</span>(</span>)</span>)</span>)</span>;</span></span>
        }</span>,</span> consumerTag </span>-></span> {</span>}</span>)</span>;</span></span>
</span>
        channel</span>.</span>basicConsume</span>(</span>queueName2</span>,</span> true</span>,</span> (</span>consumerTag</span>,</span> message</span>)</span> -></span> {</span></span>
            log</span>.</span>info</span>(</span>"</span>从队列 {} 中收到消息: {}</span>"</span>,</span> queueName2</span>,</span> new</span> String</span>(</span>message</span>.</span>getBody</span>(</span>)</span>)</span>)</span>;</span></span>
        }</span>,</span> consumerTag </span>-></span> {</span>}</span>)</span>;</span></span>
    }</span></span></code></pre>
然后日志输出为：</p>
14</span>:</span>07</span>:</span>32.459</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>4</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>routing</span>.</span>RabbitMQRoutingReceive</span> -</span> 从队列 queue</span>-</span>one 中收到消息</span>:</span> routingKey1 message</span></span>
14</span>:</span>07</span>:</span>32.464</span> [</span>pool</span>-</span>1</span>-</span>thread</span>-</span>5</span>]</span> INFO</span> com</span>.</span>mqtest</span>.</span>routing</span>.</span>RabbitMQRoutingReceive</span> -</span> 从队列 queue</span>-</span>two 中收到消息</span>:</span> routingKey2 message</span></span></code></pre>
可以看到 exchange</code> 通过 routingKey</code>  分别发送到了对应的队列中。</p>
5.5 主题模式 Topic 交换机类型 topic</code></h3>

topic 类型实际上是一种模糊匹配的模式，可以在和 exchange</code> 绑定时的 routingKey</code> 上使用通配符：</p>

#</code>：表示 0 个或多个单词</li>
*</code>：表示 1 个单词</li>
</ul>
如队列对交换机绑定时以下两种情况：</p>

使用的 routingKey</code> 为 a.#</code>，那么发送消息时，指定 routingKey</code>  为 a</code>、a.a</code>、a.b</code>、a.b.c</code>、a.b.c.d.e</code> 都可以发送到对应的队列中，但 b.c</code>、b</code> 这种不行。</li>
使用的 routingKey</code> 为 a.*</code>，那么发送消息时，指定 routingKey</code> 为 a.a</code>、a.b</code> 可以发送到对应的队列中，但 a</code>、b.c</code>、b</code> 这种不行。</li>
</ul>
5.6 头部模式 Header 交换机类型 headers</code></h3>
RabbitMQ 的消息也可以有消息头，有点像 HTTP 协议。headers</code> 类型的交换机不再使用 routingKey</code> 来路由消息，而是在与队列绑定时的 arguments 中添加匹配规则和匹配的消息头，然后发送消息时携带消息头，交换机会根据绑定时 arguments 的信息来判断发给哪个队列。</p>
如，绑定关系时：</p>
// 创建一个 headers 类型的交换机  </span></span>
String exchangeName = "my-headers-exchange";  </span></span>
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.HEADERS, true, false, null);  </span></span>
  </span></span>
// 创建队列</span></span>
String queueName1 = "headers-queue";  </span></span>
channel.queueDeclare(queueName1, true, false, false, null);  </span></span>
</span>
// 声明绑定关系用到的 header 匹配规则和数据</span></span>
Map<String, Object> header = new HashMap<>();  </span></span>
header.put("x-match", "all");  //x-match: all 表所有 key-value 全部匹配才匹配成功 ，any 表只需要匹配任意一个 key-value 即匹配成功。  </span></span>
header.put("age", "10");  </span></span>
header.put("size", "20");  </span></span>
</span>
// 将交换机与队列绑定，routingKey 留空，但增加 header 参数</span></span>
channel.queueBind(queueName1, exchangeName, "", header);</span></span></code></pre>

需要注意的时，headers 类型的交换机有两种匹配模式，一种是 all 一种是 any，分别表示 header 全部匹配和任意匹配其中一个的情况。</p>
</blockquote>
发送消息时：</p>
// 构建发送消息时的 header</span></span>
Map<String, Object> header = new HashMap<>();  </span></span>
header.put("age", "10");  </span></span>
header.put("size", "20");  </span></span>
header.put("name", "zhangsan");</span></span>
</span>
AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties().builder().headers(header);  </span></span>
  </span></span>
// 向交换机发送消息，携带上 header</span></span>
channel.basicPublish(exchangeName, "", properties.build(), "header 消息".getBytes());</span></span></code></pre>

注意： 多出来的 header 不影响 all 匹配模式，只要 bind 时指定的 header 全部匹配即可。</p>
</blockquote>

headers</code> 模式性能比较差，不推荐使用。</p>
</blockquote>
5.7 死信队列 DLX</h3>
先说说什么是死信，正常情况，producer 生产消息，消费者从 queue 获取消息。但是有些时候出现一些特定的原因导致 queue 中的消息无法被正常消费，就称之为死信消息，具体有以下几种情况：</p>

消息被消费者拒绝 (通过 basic.reject</code> 或者 basic.nack</code>)，且 requeue = false。</li>
消息过期，因为队列或者消息设置了 TTL 时间</strong>。

队列的 x-message-ttl</code> 参数可设置消息的过期时间，单位：毫秒。</li>
发送消息时，可通过指定 properties</code> 的 expiration</code> 值设置该消息的过期时间，单位：毫秒。</li>
</ul>
</li>
消息因超出队列长度限制被丢弃

队列的 x-max-length</code> 参数可设置队列最大长度，超出后会从队头开始删除消息。</li>
队列的 x-max-length-bytes</code> 参数可设置队列所有消息最大存储的字节数，超出后会从队头开始删除消息。</li>
</ul>
</li>
</ul>
如实际业务场景：用户下订单，订单 30 分钟超时，如果 30 分钟内支付成功，则进行后续的扣减库存、发货、邮件/短信通知等业务。如果 30 分钟内没有支付，则认为订单失效，但不能直接删除订单，也要记录下来。</p>
那么就可以在用户下单后将消息发送到待支付队列，然后设置消息超时时间为 30 分钟，并为这个队列设置一个死信队列，这样消息超时未处理就会自动转发到绑定的死信队列中。</p>
或者准确的说，绑定的是死信交换机</strong>，一个对象在创建时可以增加参数，x-dead-letter-exchange</code> 和 x-dead-letter-routing-key</code>，前者是死信时转发到的交换机，后者是转发时指定的 routing-key</code>，最终目的地是 routing-key</code> 对应的队列，所以也可以称之为死信队列</strong>。</p>
下面给出代码示例：
先声明普通队列和死信队列：</p>
// 正常队列和交换机</span></span>
String normalQueueName = "normal-queue";  </span></span>
String normalExchangeName = "normal-exchange";  </span></span>
String normalRoutingKey = "normal-routing-key";  </span></span>
</span>
// 死信队列和交换机  </span></span>
String deadQueueName = "dead-queue";  </span></span>
String deadExchangeName = "dead-exchange";  </span></span>
String deadRoutingKey = "dead-routing-key";  </span></span>
</span>
// 声明普通和死信交换机  </span></span>
channel.exchangeDeclare(normalExchangeName, BuiltinExchangeType.DIRECT, true, false, null);  </span></span>
channel.exchangeDeclare(deadExchangeName, BuiltinExchangeType.DIRECT, true, false, null);  </span></span>
  </span></span>
// 声明死信队列并绑定死信交换机</span></span>
channel.queueDeclare(deadQueueName, true, false, false, null);  </span></span>
channel.queueBind(deadQueueName, deadExchangeName, deadRoutingKey);  </span></span>
  </span></span>
// 声明死信队列的参数  </span></span>
HashMap<String, Object> params = new HashMap<>();  </span></span>
params.put("x-dead-letter-exchange", deadExchangeName);  </span></span>
params.put("x-dead-letter-routing-key", deadRoutingKey);  </span></span>
  </span></span>
// 声明正常队列并设置对应的死信队列参数，然后绑定正常交换机  </span></span>
channel.queueDeclare(normalQueueName, true, false, false, params);  // 重点是这里的 params</span></span>
channel.queueBind(normalQueueName, normalExchangeName, normalRoutingKey);</span></span></code></pre>
然后发送带超时时间的消息：</p>
AMQP</span>.</span>BasicProperties</span> properties</span> =</span> new</span> AMQP</span>.</span>BasicProperties</span>(</span>)</span>.</span>builder</span>(</span>)</span>.</span>expiration</span>(</span>"</span>10000</span>"</span>)</span>.</span>build</span>(</span>)</span>;</span>  </span></span>
channel</span>.</span>basicPublish</span>(</span>normalExchangeName</span>,</span> normalRoutingKey</span>,</span> properties</span>,</span> "</span>Hello World!</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span></span></code></pre>
然后就可以去 rabbitmq</code> 控制台查看，normal-queue</code> 队列有一条 Ready 状态的消息，10 秒后就没了，到 dead-queue</code> 队列中了。</p>
5.8 仲裁队列</h3>
https://support.huaweicloud.com/intl/zh-cn/usermanual-rabbitmq/rabbitmq_ug_0016.html</p>
5.9 延迟队列</h3>
延迟队列有多种实现方式：</p>

插件方式</li>
死信队列 + 队列/消息 TTL</li>
</ul>
5.9.1 插件方式延迟队列</h4>
需要先去下载插件： https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases/ ，如我下载时最新为 v3.12.0，文件名为：rabbitmq_delayed_message_exchange-3.12.0.ez</code></p>
然后复制到 RabbitMQ</code> 插件目录下：</p>
docker</span> cp</span> ./rabbitmq_delayed_message_exchange-3.12.0.ez</span> rabbitmq-container-name:/plugins</span></span></code></pre>
然后：</p>
docker</span> exec</span> rabbitmq-container-name</span> rabbitmq-plugins</span> enable</span> rabbitmq_delayed_message_exchange</span></span></code></pre>
上面两个命令中的 rabbitmq-container-name</code> 为 docker 容器的名称。需要替换为你自己实际的。</p>
启用成功后会返回：</p>
Enabling plugins on node rabbit@9edb04dcd1cd:</span></span>
rabbitmq_delayed_message_exchange</span></span>
The following plugins have been configured:</span></span>
  rabbitmq_delayed_message_exchange</span></span>
  rabbitmq_management</span></span>
  rabbitmq_management_agent</span></span>
  rabbitmq_prometheus</span></span>
  rabbitmq_web_dispatch</span></span>
Applying plugin configuration to rabbit@9edb04dcd1cd...</span></span>
Plugin configuration unchanged.</span></span></code></pre>
启用插件后，可以在创建交换机时，type 写 x-delayed-message</code>，交换机的原始类型通过参数 x-delayed-type</code> 指定，如指定为 direct</code> / fanout</code> / headers</code> / topic</code>。然后发送消息时，指定参数 x-delay</code> 值 (毫秒)来设置消息的延迟时间。</p>
5.9.2 死信队列 + TTL (Time To Live)延迟队列</h4>
如有两个交换机 E1</code>、E2</code>。两个队列 Q1</code>、Q2</code>。然后将 E1</code> 与 Q1</code> 绑定，E2</code> 与 Q2</code> 绑定。再将 E2</code> 作为 E1</code> 的死信交换机。</p>
然后消息向 E1</code> 发送时，消息中设置 TTL 过期时间，到期后会自动发送给对应的死信队列。这样监听 Q2</code> 的消费者就会延迟收到消息。 （除了发送消息时设置 TTL 过期时间，也可以给 Q1</code> 队列设置 TTL 过期时间，如果两个同时设置，以较小的值为准。）</p>
5.10 优先级队列</h3>
RabbitMQ 3.5.0 版本开始支持了优先级队列，使用方法为：</p>

创建队列时，在 arguments</code> 中设置 x-max-priority</code>，值为队列允许设置的最大优先级，只支持在 1-255</code> 之间设置（默认为 0），优先级越高，越先被消费，且允许的最大值越大，对性能消耗越高！</li>
发送消息时，在 properties</code> 中设置 priority</code>，值为消息的优先级，值越大，优先级越高。（如果队列没有设置 x-max-priority</code>，则消息的 priority</code> 也无效）</li>
</ol>
使用时也有一些注意事项：</p>

如果消息的 priority</code> 大于 x-max-priority</code>，那么消息的优先级会被认为是 x-max-priority</code>。如 x-max-priority=10</code>，那么发送消息时指定 priority=100</code> 和 priority=200</code> 都会被认为</strong>是 10</code>，不过从消息的 properties</code> 上看还是原值。</li>
对于设置了最大长度（x-max-length</code>）的队列，当队列满时，也和普通队列一样会从队头开始删除元素，但优先级队列中，高优先级的在队头，这就导致会删除高优先级的消息</strong>。</li>
当在优先级队列中使用消息自动过期，可能会因为优先级的问题，导致低优先级的消息在未被消费时就已经过期，但仍占用了存储空间，直到消息投递到消费者前检测过期后删除。</li>
如果消息立刻被消费了，那么优先级无效。仅当消息积压时，才会按照优先级进行排序。</li>
</ol>
5.11 RPC 调用</h3>
RPC 是 Remote Procedure Call</code> 的简称，可以通过网络来远程调用方法。
如有 A 和 B 两台机器，A 想调用 B 中的一个方法，就可以使用 RPC 的方式来调用，这样两个服务甚至可以是不同语言的，只要都通过 AMQP 协议通信即可。</p>
RabbitMQ 的实现方式是：RPC 客户端发送消息到 RPC 队列</strong> 时在消息属性中指定一个参数 replyTo</code>，用于表示接收返回结果的队列，RPC 服务端接收到消息后，将调用方法的返回结果发送到消息属性中指定的 replyTo</code> 队列中，然后 RPC 客户端监听这个队列即可取到返回结果。但是有可能这个队列有多条消息，不知道结果和哪一条 RPC 调用消息相对应，所以 RabbitMQ 在消息中还提供了个 correlationId</code> 属性，用来唯一标记一条消息。

下面有一个例子，A 服务调用 B 服务的 add(Integer a, Integer b)</code> 方法来计算两个数相加的结果：</p>
A 服务 (RPC 客户端)：</p>
import</span> com</span>.</span>rabbitmq</span>.</span>client</span>.</span>AMQP</span>;</span>  </span></span>
import</span> com</span>.</span>rabbitmq</span>.</span>client</span>.</span>Channel</span>;</span>  </span></span>
import</span> lombok</span>.</span>extern</span>.</span>slf4j</span>.</span>Slf4j</span>;</span>  </span></span>
  </span></span>
import</span> java</span>.</span>io</span>.</span>IOException</span>;</span>  </span></span>
import</span> java</span>.</span>nio</span>.</span>charset</span>.</span>StandardCharsets</span>;</span>  </span></span>
import</span> java</span>.</span>util</span>.</span>Objects</span>;</span>  </span></span>
import</span> java</span>.</span>util</span>.</span>UUID</span>;</span>  </span></span>
import</span> java</span>.</span>util</span>.</span>concurrent</span>.</span>CompletableFuture</span>;</span>  </span></span>
import</span> java</span>.</span>util</span>.</span>concurrent</span>.</span>ExecutionException</span>;</span>  </span></span>
  </span></span>
@</span>Slf4j</span>  </span></span>
public</span> class</span> RpcClient</span> {</span>  </span></span>
  </span></span>
    private</span> static</span> final</span> String</span> RPC_QUEUE</span> =</span> "</span>rpc_queue</span>"</span>;</span>  </span></span>
  </span></span>
    private</span> static</span> Channel</span> channel</span>;</span>  </span></span>
  </span></span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws</span> IOException</span>,</span> ExecutionException</span>,</span> InterruptedException</span> {</span>  </span></span>
        ConnectionFactory</span> factory</span> =</span> new</span> ConnectionFactory</span>(</span>)</span>;</span></span>
        factory</span>.</span>setHost</span>(</span>"</span>127.0.0.1</span>"</span>)</span>;</span></span>
        factory</span>.</span>setPort</span>(</span>5672</span>)</span>;</span></span>
        factory</span>.</span>setUsername</span>(</span>"</span>admin</span>"</span>)</span>;</span></span>
        factory</span>.</span>setPassword</span>(</span>"</span>123456</span>"</span>)</span>;</span></span>
        </span></span>
        Connection</span> connection</span> =</span> factory</span>.</span>newConnection</span>(</span>)</span>;</span></span>
        Channel</span> channel</span> =</span> connection</span>.</span>createChannel</span>(</span>)</span>;</span></span>
  </span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> 10</span>;</span> i</span>++</span>)</span> {</span>  </span></span>
            Integer</span> callResult</span> =</span> call</span>(</span>i</span>,</span> i</span>)</span>;</span>  </span></span>
            log</span>.</span>info</span>(</span>"</span>调用远程 rpc 方法, 参数为 ({}, {})，结果：{}</span>"</span>,</span> i</span>,</span> i</span>,</span> callResult</span>)</span>;</span>  </span></span>
        }</span>  </span></span>
    }</span>  </span></span>
  </span></span>
    public</span> static</span> Integer</span> call</span>(</span>Integer</span> a</span>,</span> Integer</span> b</span>)</span> throws</span> IOException</span>,</span> ExecutionException</span>,</span> InterruptedException</span> {</span>  </span></span>
        //</span> 让 RabbitMQ 为我们生成一个随机的队列名称  </span></span>
        String</span> replyQueueName</span> =</span> channel</span>.</span>queueDeclare</span>(</span>)</span>.</span>getQueue</span>(</span>)</span>;</span>  </span></span>
        //</span> 生成一个随机的字符串作为 correlationId 值  </span></span>
        String</span> correlationId</span> =</span> UUID</span>.</span>randomUUID</span>(</span>)</span>.</span>toString</span>(</span>)</span>;</span>  </span></span>
  </span></span>
        AMQP</span>.</span>BasicProperties</span> basicProperties</span> =</span> new</span> AMQP</span>.</span>BasicProperties</span>.</span>Builder</span>(</span>)</span>  </span></span>
                .</span>replyTo</span>(</span>replyQueueName</span>)</span>  </span></span>
                .</span>correlationId</span>(</span>correlationId</span>)</span>  </span></span>
                .</span>build</span>(</span>)</span>;</span>  </span></span>
  </span></span>
        //</span> 发送消息到 rpc 服务端队列  </span></span>
        String</span> message</span> =</span> a </span>+</span> "</span>+</span>"</span> +</span> b</span>;</span>  </span></span>
        channel</span>.</span>basicPublish</span>(</span>"</span>"</span>,</span> RPC_QUEUE</span>,</span> basicProperties</span>,</span> message</span>.</span>getBytes</span>(</span>StandardCharsets</span>.</span>UTF_8</span>)</span>)</span>;</span>  </span></span>
  </span></span>
        //</span> 等待 rpc 响应，使用 future 来存储响应结果  </span></span>
        final</span> CompletableFuture</span><</span>String</span>></span> response</span> =</span> new</span> CompletableFuture</span><</span>></span>(</span>)</span>;</span>  </span></span>
  </span></span>
        //</span> 消费 rpc 响应队列  </span></span>
        String</span> ctag</span> =</span> channel</span>.</span>basicConsume</span>(</span>replyQueueName</span>,</span> true</span>,</span> (</span>consumerTag</span>,</span> message1</span>)</span> -></span> {</span>  </span></span>
            if</span> (</span>Objects</span>.</span>equals</span>(</span>message1</span>.</span>getProperties</span>(</span>)</span>.</span>getCorrelationId</span>(</span>)</span>,</span> correlationId</span>)</span>)</span> {</span>  </span></span>
                response</span>.</span>complete</span>(</span>new</span> String</span>(</span>message1</span>.</span>getBody</span>(</span>)</span>,</span> StandardCharsets</span>.</span>UTF_8</span>)</span>)</span>;</span>  </span></span>
            }</span>  </span></span>
        }</span>,</span> consumerTag </span>-></span> {</span>  </span></span>
        }</span>)</span>;</span>  </span></span>
  </span></span>
        //</span> 返回结果  </span></span>
        String</span> result</span> =</span> response</span>.</span>get</span>(</span>)</span>;</span>  </span></span>
        //</span> 取消对随机队列的监听  </span></span>
        channel</span>.</span>basicCancel</span>(</span>ctag</span>)</span>;</span>  </span></span>
        //</span> 返回结果  </span></span>
        return</span> Integer</span>.</span>valueOf</span>(</span>result</span>)</span>;</span>  </span></span>
    }</span>  </span></span>
  </span></span>
}</span></span></code></pre>import</span> com</span>.</span>rabbitmq</span>.</span>utils</span>.</span>RabbitMQUtils</span>;</span>  </span></span>
import</span> com</span>.</span>rabbitmq</span>.</span>client</span>.</span>AMQP</span>;</span>  </span></span>
import</span> com</span>.</span>rabbitmq</span>.</span>client</span>.</span>Channel</span>;</span>  </span></span>
  </span></span>
import</span> java</span>.</span>io</span>.</span>IOException</span>;</span>  </span></span>
  </span></span>
public</span> class</span> RpcServer</span> {</span>  </span></span>
  </span></span>
    private</span> static</span> final</span> String</span> RPC_QUEUE</span> =</span> "</span>rpc_queue</span>"</span>;</span>  </span></span>
  </span></span>
    private</span> static</span> Channel</span> channel</span>;</span>  </span></span>
  </span></span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws</span> IOException</span> {</span>  </span></span>
        ConnectionFactory</span> factory</span> =</span> new</span> ConnectionFactory</span>(</span>)</span>;</span></span>
        factory</span>.</span>setHost</span>(</span>"</span>127.0.0.1</span>"</span>)</span>;</span></span>
        factory</span>.</span>setPort</span>(</span>5672</span>)</span>;</span></span>
        factory</span>.</span>setUsername</span>(</span>"</span>admin</span>"</span>)</span>;</span></span>
        factory</span>.</span>setPassword</span>(</span>"</span>123456</span>"</span>)</span>;</span></span>
        </span></span>
        Connection</span> connection</span> =</span> factory</span>.</span>newConnection</span>(</span>)</span>;</span></span>
        Channel</span> channel</span> =</span> connection</span>.</span>createChannel</span>(</span>)</span>;</span></span>
  </span></span>
        channel</span>.</span>queueDeclare</span>(</span>RPC_QUEUE</span>,</span> false</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span>  </span></span>
        channel</span>.</span>basicConsume</span>(</span>RPC_QUEUE</span>,</span> false</span>,</span> (</span>consumerTag</span>,</span> message</span>)</span> -></span> {</span>  </span></span>
            String</span> msg</span> =</span> new</span> String</span>(</span>message</span>.</span>getBody</span>(</span>)</span>)</span>;</span>  </span></span>
            String</span>[</span>]</span> split</span> =</span> msg</span>.</span>split</span>(</span>"</span>\\</span>+</span>"</span>)</span>;</span>  </span></span>
            Integer</span> a</span> =</span> Integer</span>.</span>parseInt</span>(</span>split</span>[</span>0</span>]</span>)</span>;</span>  </span></span>
            Integer</span> b</span> =</span> Integer</span>.</span>parseInt</span>(</span>split</span>[</span>1</span>]</span>)</span>;</span>  </span></span>
  </span></span>
            String</span> result</span> =</span> String</span>.</span>valueOf</span>(</span>add</span>(</span>a</span>,</span> b</span>)</span>)</span>;</span>  </span></span>
  </span></span>
            AMQP</span>.</span>BasicProperties</span> basicProperties</span> =</span> new</span> AMQP</span>.</span>BasicProperties</span>.</span>Builder</span>(</span>)</span>  </span></span>
                    .</span>correlationId</span>(</span>message</span>.</span>getProperties</span>(</span>)</span>.</span>getCorrelationId</span>(</span>)</span>)</span>  </span></span>
                    .</span>build</span>(</span>)</span>;</span>  </span></span>
  </span></span>
            String</span> replyToQueue</span> =</span> message</span>.</span>getProperties</span>(</span>)</span>.</span>getReplyTo</span>(</span>)</span>;</span>  </span></span>
            channel</span>.</span>basicPublish</span>(</span>"</span>"</span>,</span> replyToQueue</span>,</span> basicProperties</span>,</span> result</span>.</span>getBytes</span>(</span>)</span>)</span>;</span>  </span></span>
            channel</span>.</span>basicAck</span>(</span>message</span>.</span>getEnvelope</span>(</span>)</span>.</span>getDeliveryTag</span>(</span>)</span>,</span> false</span>)</span>;</span>  </span></span>
        }</span>,</span> consumerTag </span>-></span> {</span>  </span></span>
        }</span>)</span>;</span>  </span></span>
    }</span>  </span></span>
  </span></span>
    public</span> static</span> Integer</span> add</span>(</span>Integer</span> a</span>,</span> Integer</span> b</span>)</span> {</span>  </span></span>
        return</span> a </span>+</span> b</span>;</span>  </span></span>
    }</span>  </span></span>
  </span></span>
}</span></span></code></pre>6 其他细节</h2>
6.1 消息确认接收机制 ACK</h3>
为什么需要消息确认机制，试想下，消费者从队列中取到一个消息，要去处理，但是处理消息的过程中出现了异常，那么这条消息应该如何处理，RabbitMQ 是否知道消息消费的过程中出现了异常，这条消息要不要被认为正常处理完进行删除。
因此 RabbitMQ 有一个 ACK 机制，当消费者收到消息后，要向 RabbitMQ 服务端发送回执 ACK，告知消息处理情况，支持以下两种 ACK 方式：</p>

自动 ACK：消费者从队列中取出消息后，就自动给服务端发送一个 ACK 成功的回执。表示消息消费成功，然后消息将会从消息队列中被删除</strong>。</li>
手动 ACK：消费者从队列中取出消息后，根据处理情况手动</strong>进行 ACK 回执，告诉是否消费成功。</li>
</ul>
自动 ACK：</strong>
在监听队列消息时有参数设置是否自动 ACK，这种模式优点是吞吐量高，避免队列中挤压过多的未 ACK 消息，但是可能存在消费者处理异常后消息丢失的问题。</p>
手动 ACK：</strong>
接收消息后手动调用代码进行处理：
void basicAck(long deliveryTag, boolean multiple);</code> 用于表示确认收到消息，参数释义如下：</p>

long deliverTag</code>：表示消息的唯一标识符。</li>
boolean multiple</code>：表示是否批量处理，如果设置为 true，则表示确认所有该消息之前的所有消息。
void basicReject(long deliveryTag, boolean requeue);</code> 表示拒绝消息，参数释义如下：</li>
long deliverTag</code>：表示消息的唯一标识符。</li>
boolean requeue</code>：表示是否将消息重新入队。
void basicNack(long deliveryTag, boolean multiple, boolean requeue);</code> 同样用于表示拒绝消息，但多了一个参数 multiple</code>，参数释义如下：</li>
long deliverTag</code>：表示消息的唯一标识符。</li>
boolean multiple</code>：表示是否批量处理，如果设置为 true，则表示确认所有该消息之前的所有消息。</li>
boolean requeue</code>：表示是否将消息重新入队。</li>
</ul>
可能你会疑惑，为什么有两个拒绝消息的 API，这两个除了多一个参数外还有什么区别？</p>

basicNack</code> 额外多一个功能，支持批量 ACK。</li>
basicReject</code> 是 AMQP 0-9-1</code> 协议的标准支持。在所有支持该协议的消息队列中间件中都可以使用这个 API，但 basicNack</code> 只是 RabbitMQ 自己做的一个扩展功能，为了支持批量 ACK。</li>
</ol>
关于 Multiple</strong> 批量消息处理：</p>

true</code>：表示支持批量应答，如队列上有 1、2、3、4 四个消息，消费者 A 收到了这四条，对 4 这个消息进行 ack 时如果设置了 multiple = true，则会自动将之前收到的消息 1、2、3 中未进行过 ack 的消息以当前相同的方式进行 ack。

优点：在服务稳定时，支持大量的消息处理速度</li>
缺点：可能会丢失消息，如消息 2 处理过程中报错了，没有进行 ack，那么在 4 时批量 ack 的话，就会把消息 2 误以为处理成功，造成消息丢失。</li>
</ul>
</li>
false</code>：建议使用这种方式，不批量应答，只是处理当前消息的 ACK / NACK</code></li>
</ul>
关于消息自动重新入队：</strong></p>

如果消费者由于某些原因失去了连接，那么已经接收但未 ACK 的消息，会自动重新入队，避免消息丢失。</li>
⭐⭐⭐ 使用 reject / nack</code> 将消息重新入队时，消息不会从尾部入队，仍然还是在头部！如果需要在尾部入队，则需要先正常 ACK、然后再 publish</code> 消息。（这很重要，不然当你拒绝消息后，可能消息还在你这，处理不当会无限循环）</li>
</ul>
除了 ack / nack / reject</code> 还有 recover</code> 功能，它有两个重载方法：</p>

channel.basicRecover(boolean requeue);</code> 让 Broker</code> 将当前 channel</code> 未确认的消息重新发送。

如果 requeue</code> 为 true</code>，则未被确认的消息会重新入队，这将可能会分配到其他消费者。</li>
如果 requeue</code> 为 false</code>，则同一条消息会被分配给与之前相同的消费者。</li>
</ul>
</li>
channel.basicRecover();</code>：默认调用 requeue</code> 为 true</code> 的方法。</li>
</ul>
参考：</p>

https://www.rabbitmq.com/confirms.html#acknowledgement-modes</li>
https://www.rabbitmq.com/nack.html</li>
</ul>
6.2 消息持久化</h3>
6.2.1 交换机持久化</h4>
队列持久化很简单，在创建交换机时有个参数 durable</code> 来表示是否持久化，且只能在创建时指定，创建后无法修改：</p>
boolean</span> durable</span> =</span> true</span>;</span>  </span></span>
channel</span>.</span>exchangeDeclare</span>(</span>交换机名称</span>,</span> BuiltinExchangeType</span>.</span>DIRECT</span>,</span> durable</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span></span></code></pre>
这个持久化指的是，如果 rabbitmq</code> 重启了，交换机是否还存在。注意，如果交换机是非持久化，但队列是持久化的，那么重启后，交换机会消失，同时两者之间如果有绑定关系也会消失。</strong></p>
6.2.2 队列持久化</h4>
队列持久化很简单，在创建队列时有个参数 durable</code> 来表示是否持久化，且只能在创建时指定，创建后无法修改：</p>
boolean</span> durable</span> =</span> true</span>;</span></span>
channel</span>.</span>queueDeclare</span>(</span>队列名</span>,</span> durable</span>,</span> false</span>,</span> false</span>,</span> null</span>)</span>;</span></span></code></pre>
这个持久化指的是，如果 rabbitmq</code> 重启了，队列是否还存在。注意，如果队列是非持久化，但队列中的消息是持久化的，那么重启后，队列和消息都会消失！</strong></p>
6.2.3 消息持久化</h4>
发送消息时有个 BasicProperties props</code> 参数，这个参数中有个属性 deliveryMode</code> 表示消息是否持久化，如发送消息时这个值传递的 null，则消息默认是非持久化的，也就是重启 rabbitmq</code> 的话，消息就会丢失。</p>
BasicProperties</code> 的 deliveryMode</code> 属性有两个办法创建，第一种是通过 builder 来创建：</p>
AMQP</span>.</span>BasicProperties</span> basicProperties</span> =</span></span>
        new</span> AMQP</span>.</span>BasicProperties</span></span>
                .</span>Builder</span>(</span>)</span></span>
                .</span>deliveryMode</span>(</span>2</span>)</span> //</span> 1: 非持久化消息 2: 持久化消息</span></span>
                .</span>build</span>(</span>)</span>;</span></span>
</span>
channel</span>.</span>basicPublish</span>(</span>"</span>"</span>,</span></span>
        queueName</span>,</span></span>
        true</span>,</span></span>
        basicProperties</span>,</span> //</span> 消息属性</span></span>
        "</span>Hello World</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span></span></code></pre>
也可以通过内置的常量：</p>
AMQP</span>.</span>BasicProperties</span> basicProperties</span> =</span> MessageProperties</span>.</span>PERSISTENT_TEXT_PLAIN</span>;</span></span>
</span>
channel</span>.</span>basicPublish</span> (</span>"</span>"</span>,</span></span>
        queueName</span>,</span></span>
        true</span>,</span></span>
        basicProperties</span>,</span> //</span> 消息属性</span></span>
        "</span>Hello World</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span></span></code></pre>
其实 MessageProperties.PERSISTENT_TEXT_PLAIN</code> 也是通过创建 BasicProperties</code> 对象，指定 deliveryMode</code> 来生成的，rabbitmq</code> 的 java sdk</code> 中将常用的创建成常量放到 MessageProperties</code> 类中了。</p>

不过这里有个特殊情况，就是当设置为需要持久化的消息刚发送到 rabbitmq 中，但还未写入磁盘成功（此时还在内存中），这时消息也是会丢失的，不过这种属于极端情况了。</p>
</blockquote>
6.3 发送确认机制 & 事务机制</h3>
前面讲到了消息持久化来解决 rabbitmq</code> 服务崩溃重启后避免消息丢失。但还有个问题，就是如果消息压根都没有到达 RabbitMQ Broker</code> 呢，默认情况下，basicPublish 是没有任何返回的，你不知道到底发出去没有，发送成功没有。如果压根没发送到 Broker</code>，那么消息持久化自然也没有任何意义。</p>
RabbitMQ 提供了两种方案来解决：</p>

事务机制（低性能）</li>
发送方确认机制

同步单个确认（低性能）</li>
同步批量确认（中性能）</li>
异步确认（高性能）</li>
</ul>
</li>
</ul>
6.3.1 事务机制</h4>
RabbitMQ Java 客户端中，与事务相关的方法有：</p>

channel.txSelect()</code> 用于将当前信道设置为事务模式。</li>
channel.txCommit()</code> 提交当前事务，只要事务提交成功，那么就确保 RabbitMQ 已经确认接收到了消息，且如果开启了持久化，也会确保数据已经落盘。</strong></li>
channel.txRollback()</code> 回滚事务。</li>
</ul>
开启事务后就可以发送消息给 RabbitMQ</code>，如果事务提交成功了，消息一定达到了 RabbitMQ</code> 中，如果事务提交前由于 RabbitMQ 异常崩溃或者发送了其他故障，就会抛出异常，这时候可以捕获异常进行回滚或决定要不要重发消息，如：</p>
public static void main (String[] args) throws IOException, TimeoutException {  </span></span>
    String _queueName = "my-queue";  </span></span>
    ConnectionFactory factory = new ConnectionFactory();  </span></span>
    factory.setHost("127.0.0.1");  </span></span>
    factory.setPort(5672);  </span></span>
    factory.setUsername("admin");  </span></span>
    factory.setPassword("123456");  </span></span>
  </span></span>
    Connection conn = factory.newConnection();  </span></span>
    // 创建信道  </span></span>
    Channel channel = conn.createChannel();  </span></span>
    // 声明队列  </span></span>
    channel.queueDeclare(_queueName, true, false, false, null);  </span></span>
    String message = String.format("时间 => %s", new Date().getTime());  </span></span>
    try {  </span></span>
        channel.txSelect(); // 声明事务  </span></span>
        // 发送消息  </span></span>
        channel.basicPublish("", _queueName, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes(StandardCharsets.UTF_8));  </span></span>
        int i = 1 / 0; // 抛出 Exception</span></span>
        channel.txCommit(); // 提交事务  </span></span>
    } catch (Exception e) {  </span></span>
        channel.txRollback();  </span></span>
    } finally {  </span></span>
        channel.close();  </span></span>
        conn.close();  </span></span>
    }  </span></span>
}</span></span></code></pre>6.3.1.1 事务性能</h5>
引用 RabbitMQ 官网的一句话：使用标准 AMQP 0-9-1，保证消息不丢失的唯一方法是使用事务 —— 使通道具有事务性，然后针对每条消息或一组消息发布、提交。在这种情况下，事务会非常重量级，会使吞吐量降低 250 倍。为了解决这个问题，引入了确认机制。它模仿协议中已有的消费者确认机制。</code></p>
我这里实测了一下，虽然没有测出官网所说的极端情况 250 倍的性能差距，但是也不少了：</p>

每发送一条开启一个事务并提交，耗时 10982 ms</code></li>
每发送一条开启一个事务并回滚，耗时 10526 ms</code></li>
所有消息只用一个事务，耗时 538 ms</code></li>
所有消息不启用事务，耗时 369 ms</code></li>
</ul>
那为什么事务的性能会这么差呢？其实主要原因是事务机制将整个消息流程复杂很多。不启用事务时发送消息的流程为：

启用后变为：
</p>
可以发现，每个事务步骤多了四步：</p>

客户端发送 Tx.Select</code>，将 channel</code> 设置为事务模式</li>
Broker</code> 回复 Tx.Select-Ok</code>，确认已将 channel</code> 设置为事务模式</li>
在发送完消息后，客户端发送 Tx.Commit</code> 提交事务</li>
Broker</code> 回复 Tx.Commit-Ok</code>，确保事务提交</li>
</ul>
6.3.1.2 消费者中使用事务</h5>
事务不仅可以用于发送方确认，还可以用于消息接收方。如 channel.txSelect()</code> 开启事务后，创建一个消费者监听队列：</p>

不开启 autoAck</code> ：对消息做的 ack/nack/reject</code> 等操作在 channel.txCommit()</code> 前，消息会一直处于 unacked</code> 状态。 channel.txCommmit</code> 后，消息才会将消息按照事务中的操作进行处理。（在事务中接收消息再 rollback 的话，消息会一致处于 unacked 状态，除非事务所在客户端断开连接才会释放。</strong>）</li>
开启 autoAck</code> ：事务不支持 autoAck</code> 模式，在这种模式下使用事务是无效的，无法回滚消息。</li>
</ol>
6.3.2 发送方确认</h4>
由于事务性能很差，所以 RabbitMQ</code> 提供了发送方确认 (confirm) 模式，生产者将 channel 设置为 confirm 模式，一旦 channel 进入这个模式，所有该 channel 发送的消息都有一个唯一的 ID（从 1 开始），当消息被确认投递到 Broker</code> 会返回一个确认消息给生产者（包含消息的唯一 ID），如果开启了持久化，则是数据落盘后返回确认消息。生产者根据这个唯一 ID 就知道了消息是否正确到达目的地。</p>
关于发送方确认的 API 如下：</p>

Confirm.SelectOk channel.confirmSelect()</code>：开启发送方确认机制</li>
boolean channel.waitForConfirms()</code>：判断当前到上次执行 waitForConfirms</code> 后所有消息都被确认或拒绝</strong>，会返回 boolean</code> 值，没有参数会一直等待 broker</code> 返回 ack | nack</code></li>
boolean channel.waitForConfirms(long timeout)</code>：和上面无参的方法相比，多了个 timeout 参数，单位为毫秒，超时未收到 broker 确认结果会抛出 TimeoutException</code> 异常（虽然抛出了异常，但可能消息也已经被接收，只不过只是超出了限制的时间而已）。</li>
void waitForConfirmsOrDie()</code>：和 waitForConfirms</code> 功能一样，只是消息发送未被确认，则会抛出 IOException</code>，并关闭当前 channel 连接，接下来将无法发送消息。</li>
voide waitForConfirmsOrDie(long time)</code>：和上面无法的方法相比，只是增加了超时时间，超时会抛出 IOException</code> 并关闭当前 channel 连接。</li>
</ul>
再来看看发送方确认的流程：

相较于事务模式每次都要开启和提交事务，发送方确认模式只需开启 confirm 模式后，每次正常发送消息即可，Broker 会返回消息确认状态，比事务模式少了一些步骤。</p>
6.3.2.1 同步单个发送确认</h5>
channel</span>.</span>confirmSelect</span>(</span>)</span>;</span></span>
for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> 10_000</span>;</span> i</span>++</span>)</span> {</span></span>
    channel</span>.</span>basicPublish</span>(</span>"</span>"</span>,</span> "</span>routing-key</span>"</span>,</span> null</span>,</span> "</span>hello</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span>  </span></span>
    if</span> (</span>!</span>channel</span>.</span>waitForConfirms</span>(</span>)</span>)</span> {</span>  </span></span>
        log</span>.</span>error</span>(</span>"</span>消息发送失败 => {}</span>"</span>,</span> i</span>)</span>;</span>  </span></span>
    }</span></span>
}</span></span></code></pre>
可以看到上面代码中，先使用 channel.confirmSelect()</code> 开启了发送方确认机制，然后每次发送一条消息都调用 channel.waitForConfirms()</code> 来同步等待 broker 返回是否确认成功接收到消息。</p>
再次用发送 1w 条数据的方式验证下性能，结果为 5141ms</code>，虽然比事务模式快一倍，但是也还比直接发消息慢了 13 倍。为了优化性能，还可以批量进行发送确认：</p>
6.3.2.2 同步批量发送确认</h5>
channel</span>.</span>confirmSelect</span>(</span>)</span>;</span></span>
for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> 10_000</span>;</span> i</span>++</span>)</span> {</span></span>
    channel</span>.</span>basicPublish</span>(</span>"</span>"</span>,</span> "</span>routing-key</span>"</span>,</span> null</span>,</span> "</span>hello</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span>  </span></span>
}</span></span>
</span>
if</span> (</span>!</span>channel</span>.</span>waitForConfirms</span>(</span>)</span>)</span> {</span>  </span></span>
    log</span>.</span>error</span>(</span>"</span>消息发送失败 => {}</span>"</span>,</span> i</span>)</span>;</span>  </span></span>
}</span></span></code></pre>
这次是直接发送多条数据，最后只调用一次 waitForConfirms</code>，因为他的功能就是判断之前所有未确认的消息是否已确认，所以可以在这里用来批量确认，测试后下性能，耗时为：306ms</code>，可以看到基本和不开启任何机制持平了。</p>

不过需要注意的是，虽然批量确认性能高，但是如果确认失败了，将无法得知到底是哪些条发送失败。</p>
</blockquote>
6.3.2.3 异步发送确认</h5>
//</span> 存储未确认的消息号</span></span>
SortedSet</span><</span>Long</span>></span> unconfirmedSet</span> =</span> Collections</span>.</span>synchronizedSortedSet</span>(</span>new</span> TreeSet</span><</span>></span>(</span>)</span>)</span>;</span>  </span></span>
  </span></span>
channel</span>.</span>confirmSelect</span>(</span>)</span>;</span>  </span></span>
channel</span>.</span>addConfirmListener</span>(</span>new</span> ConfirmListener</span>(</span>)</span> {</span> </span></span>
</span>
    @</span>Override</span>  </span></span>
    public</span> void</span> handleAck</span>(</span>long</span> deliveryTag</span>,</span> boolean</span> multiple</span>)</span> throws</span> IOException</span> {</span>  </span></span>
        log</span>.</span>info</span>(</span>"</span>ack deliveryTag => {}, multiple: {}</span>"</span>,</span> deliveryTag</span>,</span> multiple</span>)</span>;</span>  </span></span>
        if</span> (</span>multiple</span>)</span> {</span>  </span></span>
            unconfirmedSet</span>.</span>headSet</span>(</span>deliveryTag </span>+</span> 1</span>)</span>.</span>clear</span>(</span>)</span>;</span>  </span></span>
        }</span> else</span> {</span>  </span></span>
            unconfirmedSet</span>.</span>remove</span>(</span>deliveryTag</span>)</span>;</span>  </span></span>
        }</span>  </span></span>
    }</span>  </span></span>
  </span></span>
    @</span>Override</span>  </span></span>
    public</span> void</span> handleNack</span>(</span>long</span> deliveryTag</span>,</span> boolean</span> multiple</span>)</span> throws</span> IOException</span> {</span>  </span></span>
        log</span>.</span>info</span>(</span>"</span>nack deliveryTag => {}, multiple: {}</span>"</span>,</span> deliveryTag</span>,</span> multiple</span>)</span>;</span>  </span></span>
        if</span> (</span>multiple</span>)</span> {</span>  </span></span>
            unconfirmedSet</span>.</span>headSet</span>(</span>deliveryTag </span>+</span> 1</span>)</span>.</span>clear</span>(</span>)</span>;</span>  </span></span>
        }</span> else</span> {</span>  </span></span>
            unconfirmedSet</span>.</span>remove</span>(</span>deliveryTag</span>)</span>;</span>  </span></span>
        }</span>  </span></span>
        //</span> todo 重发 / 记录日志 / 异常处理  </span></span>
    }</span>  </span></span>
}</span>)</span>;</span>  </span></span>
</span>
for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> 10_000</span>;</span> i</span>++</span>)</span> {</span></span>
    long</span> nextPublishSeqNo</span> =</span> channel</span>.</span>getNextPublishSeqNo</span>(</span>)</span>;</span>  </span></span>
    channel</span>.</span>basicPublish</span>(</span>"</span>"</span>,</span> "</span>routing-key</span>"</span>,</span> null</span>,</span> "</span>hello</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span>  </span></span>
    unconfirmedSet</span>.</span>add</span>(</span>nextPublishSeqNo</span>)</span>;</span>  </span></span>
}</span></span>
</span>
//</span> 如果有未确认的消息, 则等待.  </span></span>
int</span> maxWaitTime</span> =</span> 1000</span>;</span>  </span></span>
int</span> waitTime</span> =</span> 10</span>;</span>  </span></span>
while</span> (</span>!</span>unconfirmedSet</span>.</span>isEmpty</span>(</span>)</span>)</span> {</span>  </span></span>
    if</span> (</span>waitTime </span>></span> maxWaitTime</span>)</span> {</span>  </span></span>
        log</span>.</span>error</span>(</span>"</span>等待确认超时, 未确认消息数量: {}</span>"</span>,</span> unconfirmedSet</span>.</span>size</span>(</span>)</span>)</span>;</span>  </span></span>
        break</span>;</span>  </span></span>
    }</span>  </span></span>
    Thread</span>.</span>sleep</span>(</span>waitTime</span>)</span>;</span>  </span></span>
    waitTime </span>*=</span> 2</span>;</span>  </span></span>
}</span>  </span></span>
  </span></span>
log</span>.</span>info</span>(</span>"</span>等待确认完成, 未确认消息数量: {}</span>"</span>,</span> unconfirmedSet</span>.</span>size</span>(</span>)</span>)</span>;</span></span></code></pre>
可以看到异步确认是创建一个监听器，用来监听服务端返回的 confirm，返回的信息中包含消息的唯一 ID 和 multiple，表示这个唯一 ID 到上次 ack/nack 前的数据 confirm 结果。性能上测试大约为 300 ms</code> 和批量确认模式还有不开启发送确认差不多。实际开发中推荐使用这种方式。</p>
6.3.3 注意事项</h4>
需要注意的是：</p>

事务机制和 confirm 是互斥的，不支持同时使用。</li>
事务机制和 publish confirm 机制确保的是消息能够正常的发送至 RabbitMQ，这里的 "发送至 RabbitMQ" 值的是消息正确的发往 RabbitMQ 交换机，如果此交换机没有匹配的路由，那么消息也会丢失，所以使用这两种机制要确保交换机可以路由到队列。如果要确保消息可以匹配到队列，需要结合 mandatory</code> 或备用交换机一起来使用提高消息传输的可靠性。</li>
事务机制和单条 confirm 机制虽然性能差，但是胜在开发简单，不需要额外维护状态（这里指的是维护 deliveryTag</code> 及缓存未确认的消息），批量 confirm 和事务机制就需要记录下未确认的消息列表，当出现异常时，需要对异常的消息进行处理（一般是批量的），不过因为批量 confirm 还是同步的方法，批量重发时也会导致性能降低。</li>
</ul>
6.3.4 参考 ：</h4>

https://www.rabbitmq.com/tutorials/tutorial-seven-java.html</li>
https://blog.rabbitmq.com/posts/2011/02/introducing-publisher-confirms/</li>
</ul>
6.4 消息回退</h3>
上一节我们讲到发送方消息确认，可以确认消息是否发送到了 Broker</code>，但还个问题，就是如果 Broker</code> 根据 routingKey</code> 无法路由到对应的队列有没有办法得知呢。可以在发送消息时，设置 mandatory</code> 为 true</code>，那么消息无法路由到队列时 （如 routingKey</code> 写错了，没有对应的队列），那么消息会返回给客户端，反之，如果不设置 mandatory</code>，默认为 false，消息将会静默丢弃</strong>。</p>
如：</p>
channel</span>.</span>addReturnListener</span> (</span>new</span> ReturnListener</span> (</span>)</span> {</span>  </span></span>
    @</span>Override</span>  </span></span>
    public</span> void</span> handleReturn</span>(</span>int</span> replyCode</span>,</span> String</span> replyText</span>,</span> String</span> exchange</span>,</span> String</span> routingKey</span>,</span> AMQP</span>.</span>BasicProperties</span> properties</span>,</span> byte</span>[</span>]</span> body</span>)</span> throws</span> IOException</span> {</span>  </span></span>
        log</span>.</span>info</span>(</span>"</span>replyCode = </span>"</span> +</span> replyCode </span>+</span> "</span>, replyText = </span>"</span> +</span> replyText </span>+</span> "</span>, exchange = </span>"</span> +</span> exchange </span>+</span> "</span>, routingKey = </span>"</span> +</span> routingKey </span>+</span> "</span>, properties = </span>"</span> +</span> properties </span>+</span> "</span>, body = </span>"</span> +</span> Arrays</span>.</span>toString</span>(</span>body</span>)</span>)</span>;</span>  </span></span>
    }</span>  </span></span>
}</span>)</span>;</span>  </span></span>
channel</span>.</span>basicPublish</span> (</span>"</span>"</span>,</span>  //</span> 交换机名称, 没有指定则使用默认 Default Exchange</span></span>
                "</span>xxx-queue-name</span>"</span>,</span>  //</span> 随便输入一个不存在的 routingKey</span></span>
                true</span>,</span>  //</span> mandatory 参数设置为 true</span></span>
                null</span>,</span> //</span> 消息属性，这里先不设置</span></span>
                "</span>Hello World</span>"</span>.</span>getBytes</span>(</span>)</span>)</span>;</span> //</span> 消息内容</span></span></code></pre>
将会在监听器中收到一条消息：</p>
19:55:06.039</span> [AMQP Connection </span>127</span>.</span>0</span>.</span>0</span>.</span>1</span>:</span>5672</span>] </span>INFO</span> com.mqtest.basic.RabbitSendTest</span> - replyCode = </span>312</span>, replyText = NO_ROUTE, exchange = , routingKey = xxx-queue-name, properties = #contentHeader<basic>(content-type=</span>null</span>, content-encoding=</span>null</span>, headers=</span>null</span>, delivery-mode=</span>null</span>, priority=</span>null</span>, correlation-id=</span>null</span>, reply-to=</span>null</span>, expiration=</span>null</span>, message-id=</span>null</span>, timestamp=</span>null</span>, type=</span>null</span>, user-id=</span>null</span>, app-id=</span>null</span>, cluster-id=</span>null</span>), body = [</span>72</span>, </span>101</span>, </span>108</span>, </span>108</span>, </span>111</span>, </span>32</span>, </span>87</span>, </span>111</span>, </span>114</span>, </span>108</span>, </span>100</span>]</span></span></code></pre>6.5 exchange 备机</h3>
为了应对 exchange 根据路由找不到 queue 的情况, 除了上面的消息回退机制外, 还可以使用 exchange 备机</strong> 模式, 简单点说就是当 exchange 根据路由没有匹配的 queue 时, 会自动转发给 exchange 备机</strong>, 一般备机会设置为 fanout</code> 类型, 这样能把所有消息投递到与其绑定的队列中, 备机对应的队列会存储所有无法路由的消息, 也可以用专门的报警程序监听这个队列来做出响应的处理。</p>
设置方法为在创建 exchange 时, 在 argument 中指定 alternate-exchange</code> ,值就是 exchange 备机</code> 的名称。
</p>
除了根据 routing key 找不到 queue 外，queue 不存在或 queue 满了也会进入备机队列，但是 queue 慢了，不会通过 mandatory return</code> 返回。</p>

exchange 备机</code> 比 mandatory return</code> 模式优先级高，两者同时使用时，mandatory return</code> 不会收到消息（不过备用交换机也无法路由到队列时，就没有办法了，且这时 mandatory return</code> 也不会收到消息的，所以推荐将备用交换机设置为 fanout</code> 模式）</p>
</blockquote>
6.6 消息 100% 送达</h3>
要保证消息 100% 送达，需要做很多工作：</p>

exchange</code>、queue</code>、message</code> 都要开启持久化。</li>
发送时做好异常处理，要有重发机制，或记录到数据库采用定时扫描重发的方式。</li>
为每条消息记录发送日志，是否发送成功，消息体，消息 deliveryTag 等信息。便于重发时使用。</li>
开启事务 / 发布者确认模式来保证消息到达 exchange。</li>
发送消息时指定 mandatory</code> 开启消息回退模式或使用 exchange 备机</code> 来处理未成功路由的消息。更推荐使用 exchange 备机</code> 功能，因为 mandatory</code> 无法应用于队列满了的清理。</li>
消费者避免使用 autoAck</code> 功能。</li>
开启死信队列功能，当重复消息发送之后仍不能正常消费，把消息发送到死信队列，对于消费失败的消息进行人工干预。</li>
</ol>
6.7 防止消息重复消费</h3>
以下这些情况都可能会造成消息重复消费：</p>

消息消费成功，ack</code> 时宕机，导致没有成功 ack</code>，broker</code> 的消息由 unacked</code> 变成了 ready</code>，又给了其他消费者消费。</li>
消费失败时，由于重试机制，自动又将消息重发出去。</li>
</ol>
解决办法未：消息中携带唯一的 id，并存储到 redis/数据库，当消息重复发送时，检查该全局唯一 id 是否已经被消息过，如果已经被消费过，直接返回 ACK 即可。</p>
6.8 单一活跃消费者</h3>
单一活跃消费者（Single Active Consumer）表示队列中可以注册多个消费者，但是只允许一个消费者消费消息，只有在此消费者出现异常时，才会自动转移到另一个消费者进行消费。单一活跃消费者适用于需要保证消息消费顺序性，同时提供高可靠能力的场景。</p>
在创建队列时，可以通过参数 x-single-active-consumer</code> 指定为 true</code> 将队列设置为单一活跃消费者模式。</p>
6.9 消息顺序性</h3>
消息顺序性指的是消费者消费到的消息和发送者发送的消息顺序是一致的，如发送 a、b、c 三条消息，消费者接收到的顺序也是 a、b、c。这么一看似乎 RabbitMQ 可以保证消息顺序性，实则不然，有很多情况会打破这个情况：</p>

消息通过事务回滚、消息 nack / reject</code> 或其他原因导致消息重新入队时，消息的顺序可能会变化。</li>
消息设置了优先级，也不会按照原有的顺序接收到，而是按照优先级排序。</li>
使用消息 TTL  + 死信队列的方式实现的延迟队列，也会打破消息的顺序，在这里，消息的顺序时按照消息 TTL 排序的。</li>
</ol>
包括但不限于上述的情况都会导致 RabbitMQ 的消息错序。</p>
6.10 消息自动过期</h3>
前面死信队列和延迟队列用到了消息自动过期，但是还有很多细节，这里详细说说。</p>
设置消息自动过期有两种方式：</p>

通过队列的 x-message-ttl</code> 属性来设置，单位为毫秒，表示队列中所有消息默认的有效期。</li>
通过消息的 expiration</code> 属性来设置，单位为毫秒，表示当前这条消息的有效期。</li>
</ol>
当同时使用两种方式时，将使用两者中的较低值。</p>
两者还是有很大区别的：</p>

前者一旦消息过期，就会从队列中抹去，但后者即使消息过期，也不会马上从队列中抹去，每条消息是否过期是在即将投递到消费者之前判断的。（出现这种差异是因为前者，也就是队列的 TTL 是统一的，队列中过期的消息肯定在队头，RabbitMQ 只需要定期从队头开始扫描直到有未过期的消息停止并删除扫描到已过期的消息即可。但是后者消息自身的过期时间可能各不相同，可能队列中前面的消息的过期时间晚于头部的，想要发现所有过期消息就要遍历整个队列，很消耗性能，所以不如在消息到队头时在投递前进行检查。也就是说，你可能发送了一些消息，在还没有消费到这些消息时，就已经过期了，但是从统计信息来看，还对这些消息进行了计数，且它们仍然占用着空间。）</li>
</ul>
其他注意事项：</p>

RabbitMQ 保证已经过期的消息不会投递给消费者，但是在投递的网络传输过程中过期是有可能的。</li>
如果不设置 TTL，则表示消息不会过期；如果设置 TTL 为 0，则表示除非可以直接向消息投递给消费者，否则消息将会被丢弃 (或死信)</li>
路由到多个队列的消息可能在其队列中不同时间消亡，甚至不消亡。一个队列中的消息的死亡不会影响其他队列中同一条消息的生命周期。</li>
如果消息被重新排队（nack/reject</code> 时 requeue</code>），将会保留原始的过期时间。换句话说就是不会因为 requeue</code> 重置 ttl</code> 时间。</li>
</ul>
7 RabbitMQ 管理</h2>
7.1 多租户与权限</h3>
RabbitMQ</code> 中可以创建虚拟主机，简称 vhost</code>。每个 vhost</code> 之间的队列、交换机是独立的，相互隔离的。每个用户至少应有一个 vhost</code>，客户端连接时，也应指定一个 vhost</code>，且 RabbitMQ</code> 中默认提供一个 /</code> 的 vhost</code>。
在 RabbitMQ</code> 中授权是以 vhost</code> 为单位的，用户通常被授予至少一个 vhost，用户只能访问被授予的 vhost。授权的参数有：</p>

vhost</code>：授予用户权限的 vhost</code> 名称。</li>
user</code>：可访问该 vhost</code> 的用户名</li>
conf</code>：匹配用户在哪些资源有可配置权限的正则表达式</li>
write</code>：匹配用户在哪些资源有可写权限的正则表达式</li>
read</code>：匹配用户在哪些资源有可配置权限的正则表达式</li>
</ul>

可配置指队列和交换机的创建及删除等操作；可写指发布消息；可读指和消息有关的操作，包括读取消息及清空整个队列。</p>
</blockquote>
</p>
7.2 用户管理</h3>
RabbitMQ 中，用户是访问控制的基本单元，一个用户可以被授予多个 vhost，且在不同的 vhost 中可有不同的权限，并使用标准的用户名和密码来认证用户。</p>
创建用户时还可以授予用户角色：</p>

none</code>：无任何角色，新创建的用户的角色默认为 none</code>。</li>
managment</code>：可以访问 Web 管理页面。</li>
policymarker</code>：包含 managment</code> 的所有权限，并可以管理策略和参数。</li>
monitoring</code>：包含 managment</code> 的所有权限，并可以看到连接、信道、节点相关的信息。</li>
administrator</code>：超级管理员，可以做所有操作。</li>
</ul>


leetcode 1247. 交换字符使得字符串相同
2023-02-26T10:20:32+08:00
题目</h2>
有两个长度相同的字符串 s1</code> 和 s2</code>，且它们其中 只含有</strong> 字符 "x"</code> 和 "y"</code>，你需要通过「交换字符」的方式使这两个字符串相同。</p>
每次「交换字符」的时候，你都可以在两个字符串中各选一个字符进行交换。</p>
交换只能发生在两个不同的字符串之间，绝对不能发生在同一个字符串内部。也就是说，我们可以交换 s1[i]</code> 和 s2[j]</code>，但不能交换 s1[i]</code> 和 s1[j]</code>。</p>
最后，请你返回使 s1</code> 和 s2</code> 相同的最小交换次数，如果没有方法能够使得这两个字符串相同，则返回 -1</code> 。</p>
示例 1：</strong></p>
输入：</strong> s1 = "xx", s2 = "yy"
输出：</strong> 1
解释：</strong>
交换 s1[0] 和 s2[1]，得到 s1 = "yx"，s2 = "yx"。</p>
示例 2：</strong></p>
输入：</strong> s1 = "xy", s2 = "yx"
输出：</strong> 2
解释：</strong>
交换 s1[0] 和 s2[0]，得到 s1 = "yy"，s2 = "xx" 。
交换 s1[0] 和 s2[1]，得到 s1 = "xy"，s2 = "xy" 。
注意，你不能交换 s1[0] 和 s1[1] 使得 s1 变成 "yx"，因为我们只能交换属于两个不同字符串的字符。</p>
示例 3：</strong></p>
输入：</strong> s1 = "xx", s2 = "xy"
输出：</strong>-1</p>
示例 4：</strong></p>
输入：</strong> s1 = "xxyyxyxyxx", s2 = "xyyxyxxxyx"
输出：</strong> 4</p>
提示：</strong></p>

1 <= s1.length, s2.length <= 1000</code></li>
s1, s2</code> 只包含 'x'</code> 或 'y'</code>。</li>
</ul>
思路</h2>
首先判断两个字符串长度是否相等，如果长度都不相等，无论如何交换都无法一致，直接返回 -1 即可。</p>
然后从头到尾判断每个字符的情况，有三种可能：</p>

s1[i] == s2[i]</code> 两个字符相等，可直接跳过，无需交换</li>
s1[i] == 'x', s2[i] == 'y'</code></li>
s1[i] == 'y', s2[i] == 'x'</code></li>
</ol>
对于以下几种情况，只需要交换一次即可，即斜对角交换：</p>
x</span>   x</span>  ＝</span>  y</span>   x</span>      y</span>   y</span>  =</span>  x</span>   y</span></span>
 ↖</span>                     ↖</span>         </span></span>
   ↘</span>                     ↘</span>        </span></span>
y</span>   y</span>      y</span>   x</span>      x</span>   x</span>     x</span>   y</span></span></code></pre>
对于以下情况，需要两次交换，即先上下，在斜对角交换：</p>
x</span>   y</span>   =</span>    y</span>   y</span>  =</span>   x</span>   y</span></span>
↑</span>             ↖</span>         </span></span>
↓</span>               ↘</span></span>
y</span>   x</span>        x</span>   x</span>      x</span>   y</span></span></code></pre>
根据上面的规律，可以得出，每两个 xy 可以当成 1 次，每两个 yx 也可以当成交换 1 次。
剩下不成对的，则就是需要交换两次的了。xy 和 yx 组成一对当成需要交换 2 次。</p>
这样的话，也可以得出，如果 xy + yx 不是偶数的话，他是不可能凑成对来交换的，所以这种情况也可以直接返回 -1</p>
代码</h2>
class</span> Solution</span> {</span></span>
    public</span> int</span> minimumSwap</span>(</span>String</span> s1</span>,</span> String</span> s2</span>)</span> {</span></span>
        int</span> len</span> =</span> s1</span>.</span>length</span>(</span>)</span>;</span></span>
        if</span> (</span>s2</span>.</span>length</span>(</span>)</span> !=</span> len</span>)</span> return</span> -</span>1</span>;</span></span>
        int</span> xy</span> =</span> 0</span>,</span> yx </span>=</span> 0</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> len</span>;</span> i</span>++</span>)</span> {</span></span>
            if</span> (</span>s1</span>.</span>charAt</span>(</span>i</span>)</span> ==</span> s2</span>.</span>charAt</span>(</span>i</span>)</span>)</span> {</span></span>
                continue</span>;</span></span>
            }</span></span>
</span>
            if</span> (</span>s1</span>.</span>charAt</span>(</span>i</span>)</span> ></span> s2</span>.</span>charAt</span>(</span>i</span>)</span>)</span> {</span></span>
                yx</span>++</span>;</span></span>
            }</span> else</span> {</span></span>
                xy</span>++</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        if</span> (</span>(</span>xy </span>+</span> yx</span>)</span> %</span> 2</span> !=</span> 0</span>)</span> return</span> -</span>1</span>;</span></span>
        return</span> xy </span>/</span> 2</span> +</span> yx </span>/</span> 2</span> +</span> xy </span>%</span> 2</span> +</span> yx </span>%</span> 2</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


vue 或 react 动态加载混合 JavaScript 片段
2023-02-12T18:41:00+08:00
如网站有一个自定义 JS 功能，然后用户输入了这样一个内容:</p>
<</span>script</span> src</span>=</span>"</span>https://xxx.com/Base64/1.1.0/base64.js</span>"</span> type</span>=</span>"</span>application/javascript</span>"</span>></span></</span>script</span>></span></span>
console</span>.</span>log</span>(</span>1</span>)</span></span>
<</span>script</span> src</span>=</span>"</span>https://xxx.com/jquery/3.6.0/jquery.js</span>"</span> type</span>=</span>"</span>application/javascript</span>"</span>></span></</span>script</span>></span></span>
console</span>.</span>log</span>(</span>2</span>)</span></span>
</span>
<</span>script</span>></span></span>
console.log(3);</span></span>
console.log(4);</span></span>
</</span>script</span>></span></span>
</span>
<</span>script</span>></span></span>
console.log(5);</span></span>
</</span>script</span>></span></span></code></pre>
其中包含两段引入外部 js 的语句，还包含两行未由 <script></code> 包裹的 js 代码，还有两段包含在 <script></code> 中的代码。想让这些代码都正常执行。</p>
可以使用下面的方式：</p>
const</span> loadScriptDom</span> =</span> (</span>scriptDom</span>)</span> =></span> {</span></span>
  if</span> (</span>scriptDom</span>)</span> {</span></span>
    document</span>.</span>getElementsByTagName</span>(</span>'</span>head</span>'</span>)</span>[</span>0</span>]</span>.</span>appendChild</span>(</span>scriptDom</span>)</span>;</span></span>
    console</span>.</span>log</span>(</span>`</span>加载自定义 js, src:</span>${</span>scriptDom</span>.</span>src</span>}</span>, text:</span>${</span>scriptDom</span>.</span>text</span>}</span>`</span>)</span>;</span></span>
  }</span></span>
}</span></span>
</span>
const</span> loadScriptText</span> =</span> (</span>scriptText</span>)</span> =></span> {</span></span>
  if</span> (</span>scriptText</span> &&</span> scriptText</span>.</span>trim</span>(</span>)</span>)</span> {</span></span>
    let</span> scriptDom</span> =</span> document</span>.</span>createElement</span>(</span>'</span>script</span>'</span>)</span>;</span></span>
    scriptDom</span>.</span>type</span> =</span> '</span>text/javascript</span>'</span>;</span></span>
    scriptDom</span>.</span>text</span> =</span> scriptText</span>;</span></span>
    loadScriptDom</span>(</span>scriptDom</span>)</span>;</span></span>
  }</span></span>
}</span></span>
</span>
//</span> 自定义 js 拍段</span></span>
let</span> customJsStr</span> =</span> "</span>...</span>"</span>;</span></span>
if</span> (</span>customJsStr</span>)</span> {</span></span>
    //</span> 创建一个新的 div 元素</span></span>
    const</span> tempDivDom</span> =</span> document</span>.</span>createElement</span>(</span>'</span>div</span>'</span>)</span>;</span></span>
    //</span> 将字符串作为 HTML 插入到新的 div 中</span></span>
    tempDivDom</span>.</span>innerHTML</span> =</span> customJsStr</span>;</span></span>
    //</span> 遍历新 div 中的所有 script 元素</span></span>
    Array</span>.</span>from</span>(</span>tempDivDom</span>.</span>getElementsByTagName</span>(</span>'</span>script</span>'</span>)</span>)</span>.</span>forEach</span>(</span>script</span> =></span> {</span></span>
      //</span> 如果该 script 元素有 src 属性，则动态引入外部 JavaScript</span></span>
      if</span> (</span>script</span>.</span>src</span>)</span> {</span></span>
          const</span> newScript</span> =</span> document</span>.</span>createElement</span>(</span>'</span>script</span>'</span>)</span>;</span></span>
          for</span> (</span>let</span> i</span> =</span> 0</span>;</span> i</span> <</span> script</span>.</span>attributes</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
            const</span> attr</span> =</span> script</span>.</span>attributes</span>[</span>i</span>]</span>;</span></span>
            newScript</span>.</span>setAttribute</span>(</span>attr</span>.</span>name</span>,</span> attr</span>.</span>value</span>)</span>;</span></span>
          }</span></span>
          loadScriptDom</span>(</span>newScript</span>)</span>;</span></span>
      }</span> else</span> {</span></span>
          //</span> 否则，执行内联的 JavaScript 代码</span></span>
          loadScriptText</span>(</span>script</span>.</span>innerHTML</span>)</span>;</span></span>
      }</span></span>
</span>
      //</span> 删除已加载的片段</span></span>
      tempDivDom</span>.</span>removeChild</span>(</span>script</span>)</span>;</span></span>
    }</span>)</span>;</span></span>
    //</span> 将剩余未经 script 包裹的片段加载</span></span>
    loadScriptText</span>(</span>tempDivDom</span>.</span>innerHTML</span>)</span>;</span></span>
}</span></span></code></pre>


leetcode 415 字符串相加
2023-02-08T20:03:30+08:00
https://leetcode.cn/problems/add-strings/description/</p>
题目</h2>
给定两个字符串形式的非负整数 num1</code> 和 num2</code> ，计算它们的和并同样以字符串形式返回。</p>
你不能使用任何內建的用于处理大整数的库（比如 BigInteger</code>）， 也不能直接将输入的字符串转换为整数形式。</p>
示例 1：</strong></p>
输入：</strong> num1 = "11", num2 = "123"
输出：</strong>"134"</p>
示例 2：</strong></p>
输入：</strong> num1 = "456", num2 = "77"
输出：</strong>"533"</p>
示例 3：</strong></p>
输入：</strong> num1 = "0", num2 = "0"
输出：</strong>"0"</p>
提示：</strong></p>

1 <= num1.length, num2.length <= 104</code></li>
num1</code> 和num2</code> 都只包含数字 0-9</code></li>
num1</code> 和num2</code> 都不包含任何前导零</li>
</ul>
思路</h2>
依次将两个字符串格式的数字从最低位开始相加，如果相加值大于 10，则表示需要向前进一位，如 5 + 8 = 13，进位是 1 存储到 caddy 变量，结果为 3 添加到 StringBuilder 中，将其添加到最后。下两位数字除了本身相加外，还要加上进位数，如 25  + 38，进位是 1，第二位相加为 （2 + 3 + 1）。以此类推，直到其中一个位数不够，对另外一个数字进行同样的运算。直到最后判断进位数是否为 1，如果还有进位数，也加入到 StringBuilder 结果中，最后将字符串结果翻转就是计算结果了（因为每次 StringBuilder.append()</code> 是加入到字符串最后了，所以要翻转一下）。</p>
代码</h2>
class</span> Solution</span> {</span></span>
    public</span> String</span> addStrings</span>(</span>String</span> num1</span>,</span> String</span> num2</span>)</span> {</span></span>
        StringBuilder</span> sb</span> =</span> new</span> StringBuilder</span>(</span>)</span>;</span></span>
        int</span> carry</span> =</span> 0</span>;</span></span>
        int</span> n</span> =</span> num1</span>.</span>length</span>(</span>)</span> -</span> 1</span>,</span> m </span>=</span> num2</span>.</span>length</span>(</span>)</span> -</span> 1</span>;</span></span>
        while</span> (</span>n </span>>=</span> 0</span> &&</span> m </span>>=</span> 0</span>)</span> {</span></span>
            int</span> sum</span> =</span>  carry </span>+</span> (</span>num1</span>.</span>charAt</span>(</span>n</span>)</span> -</span> 48</span>)</span> +</span> (</span>num2</span>.</span>charAt</span>(</span>m</span>)</span> -</span> 48</span>)</span>;</span></span>
            sb</span>.</span>append</span>(</span>sum </span>%</span> 10</span>)</span>;</span></span>
            carry </span>=</span> sum </span>/</span> 10</span>;</span></span>
            n</span>--</span>;</span></span>
            m</span>--</span>;</span></span>
        }</span></span>
        while</span> (</span>n </span>>=</span> 0</span>)</span> {</span></span>
            int</span> sum</span> =</span>  carry </span>+</span> (</span>num1</span>.</span>charAt</span>(</span>n</span>)</span> -</span> 48</span>)</span>;</span></span>
            sb</span>.</span>append</span>(</span>sum </span>%</span> 10</span>)</span>;</span></span>
            carry </span>=</span> sum </span>/</span> 10</span>;</span></span>
            n</span>--</span>;</span></span>
        }</span></span>
        while</span> (</span>m </span>>=</span> 0</span>)</span> {</span></span>
            int</span> sum</span> =</span>  carry </span>+</span> (</span>num2</span>.</span>charAt</span>(</span>m</span>)</span> -</span> 48</span>)</span>;</span></span>
            sb</span>.</span>append</span>(</span>sum </span>%</span> 10</span>)</span>;</span></span>
            carry </span>=</span> sum </span>/</span> 10</span>;</span></span>
            m</span>--</span>;</span></span>
        }</span></span>
        if</span> (</span>carry </span>!=</span> 0</span>)</span> {</span></span>
            sb</span>.</span>append</span>(</span>carry</span>)</span>;</span></span>
        }</span></span>
        return</span> sb</span>.</span>reverse</span>(</span>)</span>.</span>toString</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


leetcode 409 最长回文串
2023-02-05T14:04:00+08:00
题目</h2>
给定一个包含大写字母和小写字母的字符串 s</code> ，返回 通过这些字母构造成的 最长的回文串</strong></em> 。</p>
在构造过程中，请注意 区分大小写</strong> 。比如 "Aa"</code> 不能当做一个回文字符串。</p>
示例 1:</strong></p>
输入:</strong> s = "abccccdd"
输出:</strong> 7
解释:</strong>
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。</p>
示例 2:</strong></p>
输入:</strong> s = "a"
输入:</strong> 1</p>
示例 3：</strong></p>
输入:</strong> s = "aaaaaccc"
输入:</strong> 7</p>
提示:</strong></p>

1 <= s.length <= 2000</code></li>
s</code> 只由小写 和/或</strong> 大写英文字母组成</li>
</ul>
思路</h2>
使用哈希表统计每个字符出现的次数，一旦出现了 2 次，则将结果 res + 2，并将哈希表中当前字符的统计次数删除，直到最后判断哈希表中是否是空，如果是空，表示全部字符都可以出现了 2 的倍数次，如果不为空，则可以将单个出现的字符作为回文的中心，结果 res 再 + 1</p>
代码</h2>
class</span> Solution</span> {</span></span>
    public</span> int</span> longestPalindrome</span>(</span>String</span> s</span>)</span> {</span></span>
        int</span> res</span> =</span> 0</span>;</span></span>
        Map</span><</span>Character</span>,</span> Integer</span>></span> map</span> =</span> new</span> HashMap</span><</span>></span>(</span>)</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> s</span>.</span>length</span>(</span>)</span>;</span> i</span>++</span>)</span> {</span></span>
            char</span> c</span> =</span> s</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
            int</span> count</span> =</span> map</span>.</span>getOrDefault</span>(</span>c</span>,</span> 0</span>)</span>;</span></span>
            if</span> (</span>count </span>==</span> 1</span>)</span> {</span></span>
                res </span>+=</span> 2</span>;</span></span>
                map</span>.</span>remove</span>(</span>c</span>)</span>;</span></span>
            }</span> else</span> {</span></span>
                map</span>.</span>put</span>(</span>c</span>,</span> 1</span>)</span>;</span></span>
            }</span></span>
        }</span></span>
        return</span> res </span>+</span> (</span>map</span>.</span>isEmpty</span>(</span>)</span> ?</span> 0</span> :</span> 1</span>)</span>;</span></span>
    }</span></span>
}</span></span>
</span></code></pre>


leetcode 005 最长回文子串
2023-02-02T21:38:00+08:00
题目</h2>
给你一个字符串 s</code>，找到 s</code> 中最长的回文子串。</p>
如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。</p>
示例 1：</strong></p>
输入：</strong> s = "babad"
输出：</strong>"bab"
解释：</strong>"aba" 同样是符合题意的答案。</p>
示例 2：</strong></p>
输入：</strong> s = "cbbd"
输出：</strong>"bb"</p>
提示：</strong></p>

1 <= s.length <= 1000</code></li>
s</code> 仅由数字和英文字母组成</li>
</ul>
思路</h2>
中心扩散法</h3>
中心扩散法，依次把字符串中每个字符当成中心，向左右扩散比对。将某个字符最大的扩散长度和开始长度记录下来，最后返回这个最大的扩散区间即可。</p>
详细规则如下：</p>

循环 s 中每个字符作为中心，这个字符的下标定义为 i</li>
扩散初始状态

向左扩散 left = i - 1</code></li>
向右扩展 right = i + 1</code></li>
len = 1</code> 表示扩散长度默认为 1 (最少的回文字符就是 1，随便一个字符都可以认为是一个回文字符)</li>
maxLen</code> 表示最大的扩散宽度，可能从下标 3 向两边扩散了 3 次，但从下标 5 可以向左右扩散6 次，所以要记录最大的扩散宽度。</li>
maxStartIndex</code> 因为这道题不是让计算最大扩散宽度，还要返回整个回文字母，所以还要记录最大扩散的 left 值，是回文字符串的开始值。</li>
</ol>
</li>
最后返回 s.substring(maxStartIndex + 1, maxStartIndex + maxLen + 1)</code>。之所以要 +1 是因为 maxStartIndex</code> 这个索引已经不包含回文字符了，它是回文字符的左边的那个索引。</li>
</ol>
动态规划</h3>
使用 dp[l][r]</code> 表示从 l</code> 到 r</code> 这段是否是回文，如果 dp[l][r] = true</code>，那么要判断 dp[l - 1][r + 1]</code> 时，只需要判断  l - 1</code> 和 r + 1</code> 这两个位置的字符串是否是相等的即可。
例如 str = "cabac"</code>，l = 1</code>，r = 3</code>，dp[1][3]</code> 确定了是回文串时，只需要判断左右两个的 l - 1 = 0</code> 与 r + 1 = 4</code> 这两个位置的字符串是否相等。（大白话就是如果一个字符串是回文串，那么在其左右两个加一个相同的字符，那它还是回文串）。</p>
状态转移方程，dp[l][r]=true</code> 并且(l-1</code>)和（r+1</code>)两个位置为相同的字符，此时 dp[l-1][r+1]=true</code>。</p>
代码</h2>
中心扩散法</h3>
class</span> Solution</span> {</span>  </span></span>
    public</span> String</span> longestPalindrome</span>(</span>String</span> s</span>)</span> {</span>  </span></span>
        int</span> strLength</span> =</span> s</span>.</span>length</span>(</span>)</span>;</span>  </span></span>
        int</span> left</span> =</span> 0</span>;</span>  </span></span>
        int</span> right</span> =</span> 0</span>;</span>  </span></span>
  </span></span>
        int</span> len</span> =</span> 1</span>;</span>  </span></span>
        int</span> maxStartIdx</span> =</span> 0</span>;</span>  </span></span>
        int</span> maxLen</span> =</span> 0</span>;</span>  </span></span>
  </span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> strLength</span>;</span> i</span>++</span>)</span> {</span>  </span></span>
            left </span>=</span> i </span>-</span> 1</span>;</span>  </span></span>
            right </span>=</span> i </span>+</span> 1</span>;</span>  </span></span>
            while</span> (</span>left </span>>=</span> 0</span> &&</span> s</span>.</span>charAt</span>(</span>left</span>)</span> ==</span> s</span>.</span>charAt</span>(</span>i</span>)</span>)</span> {</span>  </span></span>
                left</span>--</span>;</span>  </span></span>
                len</span>++</span>;</span>  </span></span>
            }</span>  </span></span>
            while</span> (</span>right </span><</span> strLength </span>&&</span> s</span>.</span>charAt</span>(</span>right</span>)</span> ==</span> s</span>.</span>charAt</span>(</span>i</span>)</span>)</span> {</span>  </span></span>
                right</span>++</span>;</span>  </span></span>
                len</span>++</span>;</span>  </span></span>
            }</span>  </span></span>
  </span></span>
            while</span> (</span>left </span>>=</span> 0</span> &&</span> right </span><</span> strLength </span>&&</span> s</span>.</span>charAt</span>(</span>left</span>)</span> ==</span> s</span>.</span>charAt</span>(</span>right</span>)</span>)</span> {</span>  </span></span>
                left</span>--</span>;</span>  </span></span>
                right</span>++</span>;</span>  </span></span>
                len </span>+=</span> 2</span>;</span>  </span></span>
            }</span>  </span></span>
  </span></span>
            if</span> (</span>len </span>></span> maxLen</span>)</span> {</span>  </span></span>
                maxLen </span>=</span> len</span>;</span>  </span></span>
                maxStartIdx </span>=</span> left</span>;</span>  </span></span>
            }</span>  </span></span>
            len </span>=</span> 1</span>;</span>  </span></span>
        }</span>  </span></span>
  </span></span>
        return</span> s</span>.</span>substring</span>(</span>maxStartIdx </span>+</span> 1</span>,</span> maxStartIdx </span>+</span> maxLen </span>+</span> 1</span>)</span>;</span>  </span></span>
    }</span>  </span></span>
}</span></span></code></pre>动态规划</h3>
class</span> Solution</span> {</span></span>
    public</span> String</span> longestPalindrome</span>(</span>String</span> s</span>)</span> {</span></span>
        int</span> strLen</span> =</span> s</span>.</span>length</span>(</span>)</span>;</span></span>
        int</span> maxStart</span> =</span> 0</span>;</span>  //</span> 最长回文串的起点</span></span>
        int</span> maxEnd</span> =</span> 0</span>;</span>    //</span> 最长回文串的终点</span></span>
        int</span> maxLen</span> =</span> 1</span>;</span>    //</span> 最长回文串的长度</span></span>
</span>
        boolean</span>[</span>]</span>[</span>]</span> dp</span> =</span> new</span> boolean</span>[</span>strLen</span>]</span>[</span>strLen</span>]</span>;</span></span>
</span>
        for</span> (</span>int</span> r</span> =</span> 1</span>;</span> r </span><</span> strLen</span>;</span> r</span>++</span>)</span> {</span></span>
            for</span> (</span>int</span> l</span> =</span> 0</span>;</span> l </span><</span> r</span>;</span> l</span>++</span>)</span> {</span></span>
                //</span> 1. s.charAt(l) == s.charAt(r) 表示当前 left 和 right 相等</span></span>
                //</span> 2. dp[l + 1][r - 1] 如果回文字符串左右加上两个一样的字符，那它还是个回文字符串.</span></span>
                //</span>    如 aba，左右各加一个 c，那它还是回文字符串，这里的左右各加一个 c 其实就是第一个判断</span></span>
                //</span> 3. r - l <= 2 表示如果的间距小于等于 2，就不用判断 l 和 r 之间的那个子字符串是否是回文字符串了</span></span>
                //</span>    如 daac, l = 1, r = 2 时，条件 1 满足，但 r - l 为 1，这时候就不用判断条件 2 了，因为没有更小的子串了</span></span>
                //</span>       0123</span></span>
                //</span>    如 dabac, l = 1, r = 3 时，条件 1 满足，但 r - l 为 2，这时候也不用判断条件 2，因为 dp[l + 1][r - 1] 其实判断的是同一个字符(在这里 l  = 1, r = 3, l + 1 = 2, r - 1 = 2). 肯定会相等也不用判断.</span></span>
                //</span>       01234</span></span>
                if</span> (</span>s</span>.</span>charAt</span>(</span>l</span>)</span> ==</span> s</span>.</span>charAt</span>(</span>r</span>)</span> &&</span> (</span>dp</span>[</span>l </span>+</span> 1</span>]</span>[</span>r </span>-</span> 1</span>]</span> ||</span> r </span>-</span> l </span><=</span> 2</span>)</span>)</span> {</span></span>
                    dp</span>[</span>l</span>]</span>[</span>r</span>]</span> =</span> true</span>;</span></span>
                    if</span> (</span>r </span>-</span> l </span>+</span> 1</span> ></span> maxLen</span>)</span> {</span></span>
                        maxStart </span>=</span> l</span>;</span></span>
                        maxEnd </span>=</span> r</span>;</span></span>
                        maxLen </span>=</span> r </span>-</span> l </span>+</span> 1</span>;</span></span>
                    }</span></span>
                }</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> s</span>.</span>substring</span>(</span>maxStart</span>,</span> maxEnd </span>+</span> 1</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


leetcode 345 反转字符串中的元音字母
2023-01-28T21:04:00+08:00
https://leetcode.cn/problems/reverse-vowels-of-a-string/description/</p>
题目</h2>
给你一个字符串 s</code> ，仅反转字符串中的所有元音字母，并返回结果字符串。</p>
元音字母包括 'a'</code>、'e'</code>、'i'</code>、'o'</code>、'u'</code>，且可能以大小写两种形式出现不止一次。</p>
示例 1：</strong></p>
输入：</strong> s = "hello"
输出：</strong>"holle"</p>
示例 2：</strong></p>
输入：</strong> s = "leetcode"
输出：</strong>"leotcede"</p>
提示：</strong></p>

1 <= s.length <= 3 * 105</code></li>
s</code> 由 可打印的 ASCII</strong> 字符组成</li>
</ul>
思路</h2>
使用两个指针，一个从左一个从右，向中间靠拢，如果双方都处于元音字母上，则进行交换。直到两者相交。</p>
代码</h2>
class</span> Solution</span> {</span></span>
    private</span> final</span> char</span>[</span>]</span> vowels</span> =</span> new</span> char</span>[</span>]</span>{</span>'</span>a</span>'</span>,</span> '</span>e</span>'</span>,</span> '</span>i</span>'</span>,</span> '</span>o</span>'</span>,</span> '</span>u</span>'</span>,</span> '</span>A</span>'</span>,</span> '</span>E</span>'</span>,</span> '</span>I</span>'</span>,</span> '</span>O</span>'</span>,</span> '</span>U</span>'</span>}</span>;</span></span>
</span>
    public</span> String</span> reverseVowels</span>(</span>String</span> s</span>)</span> {</span></span>
        char</span>[</span>]</span> arr</span> =</span> s</span>.</span>toCharArray</span>(</span>)</span>;</span></span>
</span>
        int</span> i</span> =</span> 0</span>;</span></span>
        int</span> j</span> =</span> s</span>.</span>length</span>(</span>)</span> -</span> 1</span>;</span></span>
        while</span> (</span>i </span><</span> j</span>)</span> {</span></span>
            while</span> (</span>i </span><</span> j </span>&&</span> !</span>isVowels</span>(</span>s</span>.</span>charAt</span>(</span>i</span>)</span>)</span>)</span> {</span></span>
                i</span>++</span>;</span></span>
            }</span></span>
</span>
            while</span> (</span>i </span><</span> j </span>&&</span> !</span>isVowels</span>(</span>s</span>.</span>charAt</span>(</span>j</span>)</span>)</span>)</span> {</span></span>
                j</span>--</span>;</span></span>
            }</span></span>
</span>
            if</span> (</span>i </span><</span> j</span>)</span> {</span></span>
                arr</span>[</span>j</span>]</span> =</span> s</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
                arr</span>[</span>i</span>]</span> =</span> s</span>.</span>charAt</span>(</span>j</span>)</span>;</span></span>
                i</span>++</span>;</span></span>
                j</span>--</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> new</span> String</span>(</span>arr</span>)</span>;</span></span>
    }</span></span>
</span>
    private</span> boolean</span> isVowels</span>(</span>char</span> test</span>)</span> {</span></span>
        for</span> (</span>char</span> c</span> :</span> vowels</span>)</span> {</span></span>
            if</span> (</span>c </span>==</span> test</span>)</span> {</span></span>
                return</span> true</span>;</span></span>
            }</span></span>
        }</span></span>
        return</span> false</span>;</span></span>
    }</span></span>
    </span></span>
}</span></span></code></pre>


leetcode 303 区域和检索 - 数组不可变
2023-01-27T09:26:13+08:00
https://leetcode.cn/problems/range-sum-query-immutable/description/</p>
题目</h2>
给定一个整数数组  nums</code>，处理以下类型的多个查询:</p>

计算索引 left</code> 和 right</code> （包含 left</code> 和 right</code>）之间的 nums</code> 元素的 和</strong> ，其中 left <= right</code></li>
</ol>
实现 NumArray</code> 类：</p>

NumArray(int[] nums)</code> 使用数组 nums</code> 初始化对象</li>
int sumRange(int i, int j)</code> 返回数组 nums</code> 中索引 left</code> 和 right</code> 之间的元素的 总和</strong> ，包含 left</code> 和 right</code> 两点（也就是 nums[left] + nums[left + 1] + ... + nums[right]</code> )</li>
</ul>
示例 1：</strong></p>
输入：</strong>
["NumArray", "sumRange", "sumRange", "sumRange"]
[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
输出：</strong>
[null, 1, -1, -3]</p>
解释：</strong>
NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1))
numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))</p>
提示：</strong></p>

1 <= nums.length <= 104</code></li>
-105 <= nums[i] <= 105</code></li>
0 <= i <= j < nums.length</code></li>
最多调用 104</code> 次 sumRange</code> 方法</li>
</ul>
思路</h2>
暴力法</h3>
暴力法即将传入的 nums 赋值给成员变量，每次调用 sumRange 时，从 left 到 right 遍历取出元素进行累加。不过这样  sumRange</code> 方法的时间复杂度为 $O(n)$</p>
前缀和</h3>
可以提前算出每个位置的累计和，然后用 right 处的累计和，减去 left 左侧不需要的累计和即可。</p>
如：</p>
nums </span>=</span> [</span>1</span>,</span> 2</span>,</span> 3</span>,</span> 4</span>,</span> 5</span>]</span></span>
</span>
//</span> 累计和: sums[i - 1] 就是 nums 0 - i 的累计和。</span></span>
sums </span>=</span> [</span>0</span>,</span> 1</span>,</span> 3</span>,</span> 6</span>,</span> 10</span>,</span> 15</span>]</span></span></code></pre>代码</h2>
暴力法</h3>
class</span> NumArray</span> {</span></span>
</span>
    private</span> int</span>[</span>]</span> nums</span>;</span></span>
</span>
    public</span> NumArray</span>(</span>int</span>[</span>]</span> nums</span>)</span> {</span></span>
        this</span>.</span>nums</span> =</span> nums</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> int</span> sumRange</span>(</span>int</span> left</span>,</span> int</span> right</span>)</span> {</span></span>
        int</span> sum</span> =</span> 0</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> left</span>;</span> i </span><=</span> right</span>;</span> i</span>++</span>)</span> {</span></span>
            sum </span>+=</span> this</span>.</span>nums</span>[</span>i</span>]</span>;</span></span>
        }</span></span>
</span>
        return</span> sum</span>;</span></span>
    }</span></span>
}</span></span>
</span>
/**</span></span>
 * Your NumArray object will be instantiated and called as such:</span></span>
 * NumArray obj = new NumArray(nums);</span></span>
 * int param_1 = obj.sumRange(left,right);</span></span>
 */</span></span></code></pre>前缀和</h3>
class</span> NumArray</span> {</span></span>
</span>
    private</span> int</span>[</span>]</span> sums</span>;</span></span>
</span>
    public</span> NumArray</span>(</span>int</span>[</span>]</span> nums</span>)</span> {</span></span>
        int</span> n</span> =</span> nums</span>.</span>length</span>;</span></span>
        sums </span>=</span> new</span> int</span>[</span>n </span>+</span> 1</span>]</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> n</span>;</span> i</span>++</span>)</span> {</span></span>
            sums</span>[</span>i </span>+</span> 1</span>]</span> =</span> sums</span>[</span>i</span>]</span> +</span> nums</span>[</span>i</span>]</span>;</span></span>
        }</span></span>
    }</span></span>
    </span></span>
    public</span> int</span> sumRange</span>(</span>int</span> left</span>,</span> int</span> right</span>)</span> {</span></span>
        return</span> sums</span>[</span>right </span>+</span> 1</span>]</span> -</span> sums</span>[</span>left</span>]</span>;</span></span>
    }</span></span>
}</span></span>
</span>
/**</span></span>
 * Your NumArray object will be instantiated and called as such:</span></span>
 * NumArray obj = new NumArray(nums);</span></span>
 * int param_1 = obj.sumRange(left,right);</span></span>
 */</span></span></code></pre>


leetcode 1769 移动所有球到每个盒子所需的最小操作数
2023-01-25T12:00:00+08:00
https://leetcode.cn/problems/minimum-number-of-operations-to-move-all-balls-to-each-box/description/</p>
题目</h2>
有 n</code> 个盒子。给你一个长度为 n</code> 的二进制字符串 boxes</code> ，其中 boxes[i]</code> 的值为 '0'</code> 表示第 i</code> 个盒子是 空</strong> 的，而 boxes[i]</code> 的值为 '1'</code> 表示盒子里有 一个</strong> 小球。</p>
在一步操作中，你可以将 一个</strong> 小球从某个盒子移动到一个与之相邻的盒子中。第 i</code> 个盒子和第 j</code> 个盒子相邻需满足 abs(i - j) == 1</code> 。注意，操作执行后，某些盒子中可能会存在不止一个小球。</p>
返回一个长度为 n</code> 的数组 answer</code> ，其中 answer[i]</code> 是将所有小球移动到第 i</code> 个盒子所需的 最小</strong> 操作数。</p>
每个 answer[i]</code> 都需要根据盒子的 初始状态</strong> 进行计算。</p>
示例 1：</strong></p>
输入：</strong> boxes = "110"
输出：</strong>[1,1,3]
解释：</strong> 每个盒子对应的最小操作数如下：</p>

第 1 个盒子：将一个小球从第 2 个盒子移动到第 1 个盒子，需要 1 步操作。</li>
第 2 个盒子：将一个小球从第 1 个盒子移动到第 2 个盒子，需要 1 步操作。</li>
第 3 个盒子：将一个小球从第 1 个盒子移动到第 3 个盒子，需要 2 步操作。将一个小球从第 2 个盒子移动到第 3 个盒子，需要 1 步操作。共计 3 步操作。</li>
</ol>
示例 2：</strong></p>
输入：</strong> boxes = "001011"
输出：</strong>[11,8,5,4,3,4]</p>
提示：</strong></p>

n == boxes.length</code></li>
1 <= n <= 2000</code></li>
boxes[i]</code> 为 '0'</code> 或 '1'</code></li>
</ul>
思路</h2>
双重循环法</h3>
这个就是直觉上最简单的办法，第一次循环为目的地，第二次循环为计算所有小球转移到目的地的最小操作数，最后返回结果，不过这个方法时间复杂度为 $O(n^2)$</p>
根据前一个盒子的操作数，计算当前盒子的操作数</h3>
如盒子 [0,0,1,0,1,1]</code> ，下标为 3 时，左侧 1 的数量为 1 个，右侧 1 的数量为 2 个。总计操作数为 1 + 1 + 2 个，也就是 4。
当下标为 4 时，所有左侧 1 的盒子都要多移动 1 步才能到当前盒子，所有右侧为 1 的盒子都可以减少 1 步到当前盒子。
所有左侧盒子多移动一步，那就看多少个盒子，就加多少个。
所有右侧盒子少移动一步，那就看多少个盒子，就减多少个。
所以可以得出 answer[i] = answer[i - 1] + left - right</code></p>
图片来源： https://leetcode.cn/problems/minimum-number-of-operations-to-move-all-balls-to-each-box/solutions/2001791/-by-muse-77-ilaz/</p>
代码</h2>
双重循环法</h3>
class</span> Solution</span> {</span></span>
    public</span> int</span>[</span>]</span> minOperations</span>(</span>String</span> boxes</span>)</span> {</span></span>
        int</span>[</span>]</span> answer</span> =</span> new</span> int</span>[</span>boxes</span>.</span>length</span>(</span>)</span>]</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> boxes</span>.</span>length</span>(</span>)</span>;</span> i</span>++</span>)</span> {</span></span>
            int</span> sum</span> =</span> 0</span>;</span></span>
            for</span> (</span>int</span> j</span> =</span> 0</span>;</span> j </span><</span> boxes</span>.</span>length</span>(</span>)</span>;</span> j</span>++</span>)</span> {</span></span>
                char</span> c1</span> =</span> boxes</span>.</span>charAt</span>(</span>j</span>)</span>;</span></span>
                if</span> (</span>c1 </span>==</span> '</span>1</span>'</span>)</span> {</span></span>
                    sum </span>+=</span> Math</span>.</span>abs</span>(</span>i </span>-</span> j</span>)</span>;</span></span>
                }</span></span>
            }</span></span>
            answer</span>[</span>i</span>]</span> =</span> sum</span>;</span></span>
        }</span></span>
        return</span> answer</span>;</span></span>
    }</span></span>
}</span></span></code></pre>动态计算法</h3>
class</span> Solution</span> {</span></span>
    public</span> int</span>[</span>]</span> minOperations</span>(</span>String</span> boxes</span>)</span> {</span></span>
        int</span>[</span>]</span> answer</span> =</span> new</span> int</span>[</span>boxes</span>.</span>length</span>(</span>)</span>]</span>;</span></span>
        int</span> left</span> =</span> boxes</span>.</span>charAt</span>(</span>0</span>)</span> -</span> '</span>0</span>'</span>,</span> right </span>=</span> 0</span>,</span> n </span>=</span> boxes</span>.</span>length</span>(</span>)</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 1</span>;</span> i </span><</span> n</span>;</span> i</span>++</span>)</span> {</span></span>
            if</span> (</span>boxes</span>.</span>charAt</span>(</span>i</span>)</span> ==</span> '</span>1</span>'</span>)</span> {</span></span>
                right</span>++</span>;</span></span>
                answer</span>[</span>0</span>]</span> +=</span> i</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        for</span> (</span>int</span> i</span> =</span> 1</span>;</span> i </span><</span> n</span>;</span> i</span>++</span>)</span> {</span></span>
            answer</span>[</span>i</span>]</span> =</span> answer</span>[</span>i </span>-</span> 1</span>]</span> +</span> left </span>-</span> right</span>;</span></span>
            if</span> (</span>boxes</span>.</span>charAt</span>(</span>i</span>)</span> ==</span> '</span>1</span>'</span>)</span> {</span></span>
                left</span>++</span>;</span></span>
                right</span>--</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> answer</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


leetcode 2016 增量元素之间的最大差值
2023-01-24T08:11:00+08:00
https://leetcode.cn/problems/maximum-difference-between-increasing-elements/description/</p>
题目</h2>
给你一个下标从 0</strong> 开始的整数数组 nums</code> ，该数组的大小为 n</code> ，请你计算 nums[j] - nums[i]</code> 能求得的 最大差值</strong> ，其中 0 <= i < j < n</code> 且 nums[i] < nums[j]</code> 。</p>
返回 最大差值</strong> 。如果不存在满足要求的 i</code> 和 j</code> ，返回 -1</code> 。</p>
示例 1：</strong></p>
输入：</strong> nums = [7,1</strong></em>,5</strong></em>, 4]
输出：</strong> 4
解释：</strong>
最大差值出现在 i = 1 且 j = 2 时，nums[j] - nums[i] = 5 - 1 = 4 。
注意，尽管 i = 1 且 j = 0 时 ，nums[j] - nums[i] = 7 - 1 = 6 > 4 ，但 i > j 不满足题面要求，所以 6 不是有效的答案。</p>
示例 2：</strong></p>
输入：</strong> nums = [9, 4, 3, 2]
输出：</strong>-1
解释：</strong>
不存在同时满足 i < j 和 nums[i] < nums[j] 这两个条件的 i, j 组合。</p>
示例 3：</strong></p>
输入：</strong> nums = [1</strong></em>, 5, 2,10</strong></em>]
输出：</strong> 9
解释：</strong>
最大差值出现在 i = 0 且 j = 3 时，nums[j] - nums[i] = 10 - 1 = 9 。</p>
提示：</strong></p>

n == nums.length</code></li>
2 <= n <= 1000</code></li>
1 <= nums[i] <= 109</code></li>
</ul>
思路</h2>
从左向右遍历数字，将当前遇到的最小值存为 min，然后如果后续的元素比 min 大</strong>，则将他们的差值和之前的差值比较谁更大，最后返回最大的差值即可。</p>
代码</h2>
class</span> Solution</span> {</span></span>
    public</span> int</span> maximumDifference</span>(</span>int</span>[</span>]</span> nums</span>)</span> {</span></span>
        int</span> res</span> =</span> -</span>1</span>;</span></span>
        int</span> min</span> =</span> Integer</span>.</span>MAX_VALUE</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> nums</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
            if</span> (</span>nums</span>[</span>i</span>]</span> <</span> min</span>)</span> {</span></span>
                min </span>=</span> nums</span>[</span>i</span>]</span>;</span></span>
            }</span> else</span> if</span> (</span>nums</span>[</span>i</span>]</span> ></span> min</span>)</span> {</span></span>
                res </span>=</span> Math</span>.</span>max</span>(</span>res</span>,</span> nums</span>[</span>i</span>]</span> -</span> min</span>)</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> res</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


leetcode 290 单词规律
2023-01-23T15:16:00+08:00
https://leetcode.cn/problems/word-pattern/description/</p>
题目</h2>
给定一种规律 pattern</code> 和一个字符串 s</code> ，判断 s</code> 是否遵循相同的规律。</p>
这里的 遵循</strong> 指完全匹配，例如， pattern</code> 里的每个字母和字符串 s</code> 中的每个非空单词之间存在着双向连接的对应规律。</p>
示例1:</strong></p>
输入:</strong> pattern = "abba"</code>, s = "dog cat cat dog"</code>
输出:</strong> true</p>
示例 2:</strong></p>
输入:</strong> pattern = "abba"</code>, s = "dog cat cat fish"</code>
输出:</strong> false</p>
示例 3:</strong></p>
输入:</strong> pattern = "aaaa"</code>, s = "dog cat cat dog"</code>
输出:</strong> false</p>
提示:</strong></p>

1 <= pattern.length <= 300</code></li>
pattern</code> 只包含小写英文字母</li>
1 <= s.length <= 3000</code></li>
s</code> 只包含小写英文字母和 ' '</code></li>
s</code> 不包含</strong> 任何前导或尾随对空格</li>
s</code> 中每个单词都被 单个空格</strong> 分隔</li>
</ul>
思路</h2>
核心思路很简单，就是建立哈希表，key 为 pattern 中的每个规则字母，value 为用空格分别后的每个单词，如果 key 和 value 都不在哈希表中，则添加，如果其中一个在，则查看 key 和 value 是否匹配。</p>
代码</h2>
public</span> boolean</span> wordPattern</span>(</span>String</span> pattern</span>,</span> String</span> s</span>)</span> {</span></span>
	Map</span><</span>Character</span>,</span> String</span>></span> map</span> =</span> new</span> HashMap</span><</span>></span>(</span>)</span>;</span></span>
	String</span>[</span>]</span> words</span> =</span> s</span>.</span>split</span>(</span>"</span> "</span>)</span>;</span></span>
</span>
	if</span> (</span>pattern</span>.</span>length</span>(</span>)</span> !=</span> words</span>.</span>length</span>)</span> {</span></span>
		return</span> false</span>;</span></span>
	}</span></span>
</span>
	for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> words</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
		char</span> p</span> =</span> pattern</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
		String</span> word</span> =</span> words</span>[</span>i</span>]</span>;</span></span>
</span>
		String</span> val</span> =</span> map</span>.</span>get</span>(</span>p</span>)</span>;</span></span>
		if</span> (</span>val </span>==</span> null</span>)</span> {</span></span>
			if</span> (</span>map</span>.</span>containsValue</span>(</span>word</span>)</span>)</span> {</span></span>
				return</span> false</span>;</span></span>
			}</span></span>
			map</span>.</span>put</span>(</span>p</span>,</span> word</span>)</span>;</span></span>
		}</span> else</span> if</span> (</span>!</span>Objects</span>.</span>equals</span>(</span>word</span>,</span> val</span>)</span>)</span> {</span></span>
			return</span> false</span>;</span></span>
		}</span></span>
	}</span></span>
</span>
	return</span> true</span>;</span></span>
}</span></span></code></pre>
不过需要注意的是，上方 containsValue</code> 方法的时间复杂度是 O (n)，在 leetcode 中还见到一个极其简洁的解法：</p>
class</span> Solution</span> {</span></span>
    public</span> boolean</span> wordPattern</span>(</span>String</span> pattern</span>,</span> String</span> str</span>)</span> {</span></span>
        String</span>[</span>]</span> words</span> =</span> str</span>.</span>split</span>(</span>"</span> "</span>)</span>;</span></span>
        if</span> (</span>words</span>.</span>length</span> !=</span> pattern</span>.</span>length</span>(</span>)</span>)</span> {</span></span>
            return</span> false</span>;</span></span>
        }</span></span>
        Map</span><</span>Object</span>,</span> Integer</span>></span> map</span> =</span> new</span> HashMap</span><</span>></span>(</span>)</span>;</span></span>
        for</span> (</span>Integer</span> i</span> =</span> 0</span>;</span> i </span><</span> words</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
            if</span> (</span>map</span>.</span>put</span>(</span>words</span>[</span>i</span>]</span>,</span> i</span>)</span> !=</span> map</span>.</span>put</span>(</span>pattern</span>.</span>charAt</span>(</span>i</span>)</span>,</span> i</span>)</span>)</span> {</span></span>
                return</span> false</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> true</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
这里利用的是 map.put</code> 方法，如果 key 不存在，插入成功，返回 null；如果 key 存在，返回之前对应的 value。</p>


leetcode 258 各位相加
2023-01-22T15:10:00+08:00
https://leetcode.cn/problems/add-digits/description/</p>
题目</h2>
给定一个非负整数 num</code>，反复将各个位上的数字相加，直到结果为一位数。返回这个结果。</p>
示例 1:</strong></p>
输入:</strong> num = 38</code>
输出:</strong> 2
解释:</strong> 各位相加的过程为**：**
38 --> 3 + 8 --> 11
11 --> 1 + 1 --> 2
由于 2</code> 是一位数，所以返回 2。</p>
示例 2:</strong></p>
输入:</strong> num = 0
输出:</strong> 0</p>
提示：</strong></p>

0 <= num <= 231 - 1</code></li>
</ul>
进阶：</strong> 你可以不使用循环或者递归，在 O(1)</code> 时间复杂度内解决这个问题吗？</p>
思路</h2>
使用递归法，将每次各位相加结果递归调用当前方法，直到最终数字小于 10.</p>
代码</h2>
class</span> Solution</span> {</span></span>
    public</span> int</span> addDigits</span>(</span>int</span> num</span>)</span> {</span></span>
        if</span> (</span>num </span><</span> 10</span>)</span> {</span></span>
            return</span> num</span>;</span></span>
        }</span></span>
</span>
        int</span> n</span> =</span> 0</span>;</span></span>
        while</span> (</span>num </span>!=</span> 0</span>)</span> {</span></span>
            n </span>+=</span> num </span>%</span> 10</span>;</span></span>
            num </span>/=</span> 10</span>;</span></span>
        }</span></span>
</span>
        return</span> addDigits</span>(</span>n</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


leetcode 257 二叉树的所有路径
2023-01-21T23:00:29+08:00
https://leetcode.cn/problems/binary-tree-paths/description/</p>
题目</h2>
给你一个二叉树的根节点 root</code> ，按 任意顺序</strong> ，返回所有从根节点到叶子节点的路径。</p>
叶子节点</strong> 是指没有子节点的节点。</p>
 </p>
示例 1：</strong></p>
</p>
输入：</strong> root = [1, 2, 3, null, 5]
输出：</strong>["1->2->5","1->3"]</p>
示例 2：</strong></p>
输入：</strong> root = [1]
输出：</strong>["1"]</p>
提示：</strong></p>

树中节点的数目在范围 [1, 100]</code> 内</li>
-100 <= Node.val <= 100</code></li>
</ul>
思路</h2>
采用深度优先遍历法，从根节点开始，将当前节点已经遍历到的所有节点路径传递给子节点，直到最后的子节点为叶子节点时将整条路径添加到结果中。</p>
代码</h2>
/**</span></span>
 * Definition for a binary tree node.</span></span>
 * public class TreeNode {</span></span>
 *     int val;</span></span>
 *     TreeNode left;</span></span>
 *     TreeNode right;</span></span>
 *     TreeNode() {}</span></span>
 *     TreeNode(int val) { this.val = val; }</span></span>
 *     TreeNode(int val, TreeNode left, TreeNode right) {</span></span>
 *         this.val = val;</span></span>
 *         this.left = left;</span></span>
 *         this.right = right;</span></span>
 *     }</span></span>
 * }</span></span>
 */</span></span>
class</span> Solution</span> {</span></span>
    public</span> List</span><</span>String</span>></span> binaryTreePaths</span>(</span>TreeNode</span> root</span>)</span> {</span></span>
        List</span><</span>String</span>></span> paths</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
        constructPaths</span>(</span>root</span>,</span> "</span>"</span>,</span> paths</span>)</span>;</span></span>
        return</span> paths</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> void</span> constructPaths</span>(</span>TreeNode</span> root</span>,</span> String</span> path</span>,</span> List</span><</span>String</span>></span> paths</span>)</span> {</span></span>
        if</span> (</span>root </span>!=</span> null</span>)</span> {</span></span>
            path </span>=</span> path </span>+</span> Integer</span>.</span>toString</span>(</span>root</span>.</span>val</span>)</span>;</span></span>
            if</span> (</span>root</span>.</span>left</span> !=</span> null</span> ||</span> root</span>.</span>right</span> !=</span> null</span>)</span> {</span></span>
                path </span>=</span> path </span>+</span> "</span>-></span>"</span>;</span></span>
                constructPaths</span>(</span>root</span>.</span>left</span>,</span> path</span>,</span> paths</span>)</span>;</span></span>
                constructPaths</span>(</span>root</span>.</span>right</span>,</span> path</span>,</span> paths</span>)</span>;</span></span>
            }</span> else</span> {</span></span>
                paths</span>.</span>add</span>(</span>path</span>)</span>;</span></span>
            }</span></span>
        }</span></span>
    }</span></span>
</span>
}</span></span></code></pre>


leetcode 231 2 的幂
2023-01-20T21:34:00+08:00
https://leetcode.cn/problems/power-of-two/</p>
题目</h2>
给你一个整数 n</code>，请你判断该整数是否是 2 的幂次方。如果是，返回 true</code> ；否则，返回 false</code> 。</p>
如果存在一个整数 x</code> 使得 n == 2x</code> ，则认为 n</code> 是 2 的幂次方。</p>
示例 1：</strong></p>
输入：</strong> n = 1
输出：</strong> true
解释：</strong> 20 = 1</p>
示例 2：</strong></p>
输入：</strong> n = 16
输出：</strong> true
解释：</strong> 24 = 16</p>
示例 3：</strong></p>
输入：</strong> n = 3
输出：</strong> false</p>
示例 4：</strong></p>
输入：</strong> n = 4
输出：</strong> true</p>
示例 5：</strong></p>
输入：</strong> n = 5
输出：</strong> false</p>
提示：</strong></p>

-231 <= n <= 231 - 1</code></li>
</ul>
进阶：</strong> 你能够不使用循环/递归解决此问题吗？</p>
思路</h2>
这道题可以用位运算来解决，和 [[191. 位1的个数]] 类似，如：</p>
2^0 = 1             0001</span></span>
2^1 = 2             0010</span></span>
2^2 = 4             0100</span></span>
2^3 = 8             1000</span></span></code></pre>
可以看到，如果二进制位上，一个数是 2 的幂，那么他的二进制位只会是一个。不过这里要考虑负数的情况，-2147483648</code>，他的二进制位是第一个数为 1，后面的 31 个数为 0。</p>
代码</h2>
class</span> Solution</span> {</span></span>
    public</span> boolean</span> isPowerOfTwo</span>(</span>int</span> n</span>)</span> {</span></span>
        if</span> (</span>n </span><</span> 1</span>)</span> return</span> false</span>;</span></span>
</span>
        int</span> len</span> =</span> 0</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> 32</span>;</span> i</span>++</span>)</span> {</span></span>
            if</span> (</span>(</span>n </span>&</span> 1</span>)</span> ==</span> 1</span>)</span> {</span></span>
                len</span>++</span>;</span></span>
                if</span> (</span>len </span>></span> 1</span>)</span> {</span></span>
                    break</span>;</span></span>
                }</span></span>
            }</span></span>
            n </span>>></span>=</span> 1</span>;</span></span>
        }</span></span>
</span>
        return</span> len </span>==</span> 1</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
做完题后，我去 LeetCode 官方看题解，发现有一个最优版，本质上还是判断二进制位中 1 的个数是否只有 1 个。不过这里使用了一个技巧，即 n & (n - 1)</code> 可以去除 n 的二进制位中最低位的 1 转为 0。那么如果整个数字的二进制位中，只有一个 1 的话，结果就是 0，可以有了如下代码：</p>
class</span> Solution</span> {</span></span>
    public</span> boolean</span> isPowerOfTwo</span>(</span>int</span> n</span>)</span> {</span></span>
        return</span> n </span>></span> 0</span> &&</span> (</span>n </span>&</span> (</span>n </span>-</span> 1</span>)</span>)</span> ==</span> 0</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


2022 年终总结
2023-01-20T17:43:29+08:00
2022 已经过去大半个月了，趁着刚放假回到家，写下年终总结。</p>
首先从工作上，今年的变动很大，6 月底从待了 3 年多的公司离职了，离职原因有很多，详细可看看 谈裸辞和开源的体会</a> 。
11 月初才开始在新公司上班，是外包去国企的工作，且是降薪去的，降幅还不小，至于为什么又去了外包，从大环境上来是今年受疫情影响工作不好找，从个人身上找原因，是我的技术能力和业务水平没有核心竞争力，学历差一些，英语也不好，最终受迫于各种压力，来到了这里做外包。</p>
虽然也是外包，但整体体验还是不错的：</p>

首先有早午饭，让我这个对吃不太在意的人，饮食更健康。</li>
其次是工作上相对自由一些，工作压力也不大，不用像前公司一样处理各种各样的杂事，不过这个可能在任何一个公司待久了都会这样，只是我在新公司还处于小白、新人的属性所以才会这样。</li>
然后就是可以到点下班，最晚多待半个小时就可以走了，不用像之前一样，正常下班还要像做贼一样偷偷摸摸的，下班后我有更多的时间可以学习、提升自己，最后再投入到工作，我觉得这是一个良性循环，至少对我而言。</li>
所以根据上面的体验。我的心情好了很多，有心思学习了，更热爱生活了，这点降薪跳槽我觉得是值得的。</li>
</ul>
生活</h2>
生活上，今年没有太大变故，只是?了一次，但并没有感觉有什么后遗症，然后学会了做简单的饭菜，还是很不错的。
因为裸辞在家将近五个月的原因，今年并没有攒下钱，甚至年底手头上的钱还没有去年年底多，今年消费着实太多了，自我感觉陷入到了消费陷阱，值得警惕。</p>
学习</h2>
1-4 月学习了 HPC、slurm、jeecg boot、Prometheus、Grafana，不过是因为工作原因快速填鸭式学习，真正理解和运用的并不好。
5-6 月并没有怎么学习，主要是在处理各种工作上的琐事，心情烦躁，并没有进行学习。
7-8 月在持续输出，将我维护了两三年的项目进行了大版本开发，并尝试开始进行技术变现。中间也学习了不少支持，前端、后端、运维、产品、设计等方便都有。
9-10 月这段时间集中学习了将近两个月，学习了 netty、redis、Java 高并发/多线程。
11 月至今慢慢在学习 k8s 相关内容。</p>
今年已读完的书有：</p>

Java 高并发核心编程卷 2</a></li>
每天 5 分钟玩转 Kubernetes</a></li>
局外人</a></li>
马丁伊登</a></li>
一日三秋</a></li>
夜晚的潜水艇</a></li>
</ul>
读一半的书有：</p>

小岛经济学</a></li>
Redis 开发与运维</a></li>
黑客与画家</a></li>
每天 5 分钟玩转 Docker 容器技术</a></li>
</ul>
自评</h2>
工作上今年是在慢慢转好的状态，最起码从精神内耗走出来了。
生活上中规中矩，就是今年没攒下钱，体验很差。
学习上有待提高，今年读的很多书都半途而废了，学习的也很杂，又总感觉时间不够用，并不是很满意。</p>
展望</h2>
明年希望好好生活，好好工作，多攒点钱，多学习，减少碎片化学习，提高精读、精学能力，不要被各种言论左右，独立思想和判断每件事情，祝好，共勉。</p>


Linux 命令行工具 ncdu 磁盘占用分析利器
2023-01-17T22:11:00+08:00
前言</h2>
我们在使用 Linux 时经常会遇到这种场景，磁盘满了，但不知道哪里占用的。传统方式为：</p>

使用 df -h</code> 查看各个磁盘占用空间</li>
使用 du -h --max-depth=1 | sort -hr</code> 查看根目录或者在你认为可能磁盘占用较大的空间执行，返回了该文件夹中每个文件及文件夹的占用大小。</li>
然后根据第二步返回的结果，再去子目录执行，直到找到占用较大的文件。</li>
对占用较大的文件使用 rm xxx</code> 删除，如果是文件夹，还需要 rm -rf folder</code> ，这个命令是很危险的，万一输错就麻烦了。</li>
</ol>
现在使用 ncdu</code></a> 的话，只需要执行一次就可以，无需重复上述的 2 和 3 步骤，且删除文件也很方便，不会出错。</p>
安装</h2>
普通安装</h3>
常见操作系统的包管理中已经包含了 btop</code> 工具，直接安装即可</p>
#</span> ubuntu</span></span>
sudo</span> apt</span> install</span> ncdu</span></span>
#</span> centos</span></span>
sudo</span> yum</span> install</span> ncdu</span></span></code></pre>
不过安装后可能版本不是最新的，可以下载最新二进制文件安装。</p>
二进制安装</h3>
这里使用的版本是 2.2.1</code>，这是我写这篇文章时的最高版本，如果你想要更新的版本，或者 CPU 架构不同，可去 https://dev.yorhel.nl/ncdu</a> 查看项目主页介绍。</p>
wget</span> -</span>-no-check-certificate</span> https://dev.yorhel.nl/download/ncdu-2.2.1-linux-x86_64.tar.gz</span></span>
tar</span> -</span>zxvf</span> ncdu-2.2.1-linux-x86_64.tar.gz</span></span></code></pre>使用</h2>
使用起来就很简单了。</p>
#</span> 统计当前所在目录及子目录的文件占用情况</span></span>
ncdu</span></span>
</span>
#</span> 统计指定的 /data 目录</span></span>
ncdu</span> /data</span></span>
</span>
#</span> 将 /data 目录的情况输出到 ~/ncdu.txt</span></span>
ncdu</span> /data</span> -</span>o</span> ~/ncdu.txt</span></span>
</span>
#</span> 加载本地根据，而不是进行实时统计</span></span>
ncdu</span> -</span>f</span> ~/ncdu.txt</span> </span></span></code></pre>
如同下图所示，他还支持 vim 快捷键，或者大家习惯性的 ↑ ↓←→回车键来切换目录，还支持按文件名、文件大小、子文件数量排序，按 d 删除文件（会二次确认</strong>）</p>
</p>


设计模式 - 代理模式
2023-01-08T16:16:58+08:00
静态代理</h2>
静态代理其实代理类和被代理类实现同一个接口，然后将被代理类的实例通过构造函数传入代理类，在代理类中，调用接口上的方法时，去调用被代理类的同方法即可，在调用前、后、异常等场景可以加入你的代理逻辑。</p>
如：</p>
public</span> class</span> SimpleStaticProxyDemo</span> {</span></span>
</span>
    static</span> interface</span> IService</span> {</span></span>
        public</span> void</span> sayHello</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
    static</span> class</span> RealService</span> implements</span> IService</span> {</span></span>
</span>
        @</span>Override</span></span>
        public</span> void</span> sayHello</span>(</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>hello</span>"</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
    static</span> class</span> TraceProxy</span> implements</span> IService</span> {</span></span>
        private</span> IService</span> realService</span>;</span></span>
</span>
        public</span> TraceProxy</span>(</span>IService</span> realService</span>)</span> {</span></span>
            this</span>.</span>realService</span> =</span> realService</span>;</span></span>
        }</span></span>
</span>
        @</span>Override</span></span>
        public</span> void</span> sayHello</span>(</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>entering sayHello</span>"</span>)</span>;</span></span>
            this</span>.</span>realService</span>.</span>sayHello</span>(</span>)</span>;</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>leaving sayHello</span>"</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        IService</span> realService</span> =</span> new</span> RealService</span>(</span>)</span>;</span></span>
        IService</span> proxyService</span> =</span> new</span> TraceProxy</span>(</span>realService</span>)</span>;</span></span>
        proxyService</span>.</span>sayHello</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
在这个例子中，IService</code> 是公共接口，实际对象是 RealService</code>，代理类为 TraceProxy</code>，TraceProxy</code> 内部持有一个 IService</code> 类型的成员变量，指向实际对象，在构造函数中初始化，对于 sayHello</code> 的调用，它转发给了实际对象，在调用前后输出了一些跟踪信息。</p>
程序输出为：</p>
entering sayHello</span></span>
hello</span></span>
leaving sayHello</span></span></code></pre>
静态代理实现了代理模式的核心需求："在不修改原类的情况下增强其功能</strong>"
不过，输出跟踪日志是一个很常见的需求，可能不止 RealService</code> 需要，如果更多的类需要的话，就要为每个实际对象创建代理，代理要实现所有接口，整个过程非常繁琐。所以就有了动态代理。</p>
动态代理 -JDK</h2>
和静态代理不一样，动态代理的代理类是动态生成的，如：</p>
public</span> class</span> SimpleJDKDynamicProxyDemo</span> {</span></span>
</span>
    static</span> interface</span> IService</span> {</span></span>
        public</span> void</span> sayHello</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
    static</span> class</span> RealService</span> implements</span> IService</span> {</span></span>
</span>
        @</span>Override</span></span>
        public</span> void</span> sayHello</span>(</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>hello</span>"</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
    static</span> class</span> SimpleInvocationHandler</span> implements</span> InvocationHandler</span> {</span></span>
        private</span> Object</span> realObj</span>;</span></span>
</span>
        public</span> SimpleInvocationHandler</span>(</span>Object</span> realObj</span>)</span> {</span></span>
            this</span>.</span>realObj</span> =</span> realObj</span>;</span></span>
        }</span></span>
</span>
        @</span>Override</span></span>
        public</span> Object</span> invoke</span>(</span>Object</span> proxy</span>,</span> Method</span> method</span>,</span> Object</span>[</span>]</span> args</span>)</span> throws</span> Throwable</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>entering </span>"</span> +</span> method</span>.</span>getName</span>(</span>)</span>)</span>;</span></span>
            Object</span> result</span> =</span> method</span>.</span>invoke</span>(</span>realObj</span>,</span> args</span>)</span>;</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>leaving </span>"</span> +</span> method</span>.</span>getName</span>(</span>)</span>)</span>;</span></span>
            return</span> result</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        IService</span> realService</span> =</span> new</span> RealService</span>(</span>)</span>;</span></span>
        IService</span> proxyService</span> =</span> (</span>IService</span>)</span> Proxy</span>.</span>newProxyInstance</span>(</span>IService</span>.</span>class</span>.</span>getClassLoader</span>(</span>)</span>,</span></span>
                new</span> Class</span><</span>?</span>></span>[</span>]</span> {</span> IService</span>.</span>class</span> }</span>,</span> new</span> SimpleInvocationHandler</span>(</span>realService</span>)</span>)</span>;</span></span>
        proxyService</span>.</span>sayHello</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
只需要创建一个类，实现 InvocationHandler</code> 接口的 invoke</code> 方法即可，方法第一个参数是代理类</strong>，也就是生成的代理对象，第二个参数是调用的方法，第三个参数是方法参数。</p>
那么如何调用这个它来生成代理类呢，使用 JDK 自带的 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)</code></p>

loader</code>：类加载器，使用和实际类实现的接口的类加载器即可。</li>
interfaces</code>：实际类实现的接口</strong>列表。</li>
h</code>：就是上面我们实现 InvocationHandler</code> 接口的实现类 SimpleInvocationHandler</code>。</li>
</ul>
JDK 动态代理的原理是自动创建一个类，实现的接口为上面的 interfaces</code> 中的接口列表，也就是实际类实现的接口列表，生成的代理类代码大概如下：</p>
final</span> class</span> $Proxy0</span> extends</span> Proxy</span> implements</span> SimpleJDKDynamicProxyDemo</span>.</span>IService</span> {</span></span>
    private</span> static</span> Method</span> m1</span>;</span></span>
    private</span> static</span> Method</span> m3</span>;</span></span>
    private</span> static</span> Method</span> m2</span>;</span></span>
    private</span> static</span> Method</span> m0</span>;</span></span>
</span>
    public</span> $</span>Proxy0</span>(</span>InvocationHandler</span> paramInvocationHandler</span>)</span> {</span></span>
        super</span>(</span>paramInvocationHandler</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> final</span> boolean</span> equals</span>(</span>Object</span> paramObject</span>)</span> {</span></span>
        return</span> (</span>(</span>Boolean</span>)</span> this</span>.</span>h</span>.</span>invoke</span>(</span>this</span>,</span> m1</span>,</span></span>
                new</span> Object</span>[</span>]</span> {</span> paramObject </span>}</span>)</span>)</span>.</span>booleanValue</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> final</span> void</span> sayHello</span>(</span>)</span> {</span></span>
        this</span>.</span>h</span>.</span>invoke</span>(</span>this</span>,</span> m3</span>,</span> null</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> final</span> String</span> toString</span>(</span>)</span> {</span></span>
        return</span> (</span>String</span>)</span> this</span>.</span>h</span>.</span>invoke</span>(</span>this</span>,</span> m2</span>,</span> null</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> final</span> int</span> hashCode</span>(</span>)</span> {</span></span>
        return</span> (</span>(</span>Integer</span>)</span> this</span>.</span>h</span>.</span>invoke</span>(</span>this</span>,</span> m0</span>,</span> null</span>)</span>)</span>.</span>intValue</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
    static</span> {</span></span>
        m1 </span>=</span> Class</span>.</span>forName</span>(</span>"</span>java.lang.Object</span>"</span>)</span>.</span>getMethod</span>(</span>"</span>equals</span>"</span>,</span></span>
                new</span> Class</span>[</span>]</span> {</span> Class</span>.</span>forName</span>(</span>"</span>java.lang.Object</span>"</span>)</span> }</span>)</span>;</span></span>
        m3 </span>=</span> Class</span>.</span>forName</span>(</span>"</span>laoma.demo.proxy.SimpleJDKDynamicProxyDemo$IService</span>"</span>)</span></span>
                .</span>getMethod</span>(</span>"</span>sayHello</span>"</span>,</span>new</span> Class</span>[</span>0</span>]</span>)</span>;</span></span>
        m2 </span>=</span> Class</span>.</span>forName</span>(</span>"</span>java.lang.Object</span>"</span>)</span>.</span>getMethod</span>(</span>"</span>toString</span>"</span>,</span> new</span> Class</span>[</span>0</span>]</span>)</span>;</span></span>
        m0 </span>=</span> Class</span>.</span>forName</span>(</span>"</span>java.lang.Object</span>"</span>)</span>.</span>getMethod</span>(</span>"</span>hashCode</span>"</span>,</span> new</span> Class</span>[</span>0</span>]</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
这个类通过构造方法传入一个 InvocationHandler</code> 类型的对象，调用所有方法时，包含 Object 中的 hashCode，equals 和 toString 方法，都会调用 InvocationHandler</code> 的 invoke</code> 方法，也就是这个类其实只做转发作用。</p>
通过 JDK 的动态代理，可以不用再为每个实际类手动创建一个代理类了，上面我们是获取 IService</code> 的一个代理类：</p>
IService</span> proxyService</span> =</span> (</span>IService</span>)</span> Proxy</span>.</span>newProxyInstance</span>(</span>IService</span>.</span>class</span>.</span>getClassLoader</span>(</span>)</span>,</span></span>
                new</span> Class</span><</span>?</span>></span>[</span>]</span> {</span> IService</span>.</span>class</span> }</span>,</span> new</span> SimpleInvocationHandler</span>(</span>realService</span>)</span>)</span>;</span></span></code></pre>
实际上我们也可以获取其他接口实现的代理类，如 IServiceA</code>、IServiceB</code>：</p>
IServiceA</span> proxyService</span> =</span> (</span>IServiceA</span>)</span> Proxy</span>.</span>newProxyInstance</span>(</span>IServiceA</span>.</span>class</span>.</span>getClassLoader</span>(</span>)</span>,</span></span>
                new</span> Class</span><</span>?</span>></span>[</span>]</span> {</span> IServiceA</span>.</span>class</span> }</span>,</span> new</span> SimpleInvocationHandler</span>(</span>realService</span>)</span>)</span>;</span></span></code></pre>IServiceB</span> proxyService</span> =</span> (</span>IServiceB</span>)</span> Proxy</span>.</span>newProxyInstance</span>(</span>IServiceB</span>.</span>class</span>.</span>getClassLoader</span>(</span>)</span>,</span></span>
                new</span> Class</span><</span>?</span>></span>[</span>]</span> {</span> IServiceB</span>.</span>class</span> }</span>,</span> new</span> SimpleInvocationHandler</span>(</span>realService</span>)</span>)</span>;</span></span></code></pre>动态代理 - CGLIB</h2>
JDK 动态代理的局限是只能为接口创建代理，返回的代理类也只能转为某个接口实现类</mark>，如果一个类没有接口，或者向代理非接口中定义的方法，就没办法实现了。</p>
cglib 使用其他方式避免了这些局限，如:</p>
public</span> class</span> SimpleCGLibDemo</span> {</span></span>
    static</span> class</span> RealService</span> {</span></span>
        public</span> void</span> sayHello</span>(</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>hello</span>"</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
    static</span> class</span> SimpleInterceptor</span> implements</span> MethodInterceptor</span> {</span></span>
</span>
        @</span>Override</span></span>
        public</span> Object</span> intercept</span>(</span>Object</span> object</span>,</span> Method</span> method</span>,</span></span>
                Object</span>[</span>]</span> args</span>,</span> MethodProxy</span> proxy</span>)</span> throws</span> Throwable</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>entering </span>"</span> +</span> method</span>.</span>getName</span>(</span>)</span>)</span>;</span></span>
            Object</span> result</span> =</span> proxy</span>.</span>invokeSuper</span>(</span>object</span>,</span> args</span>)</span>;</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>"</span>leaving </span>"</span> +</span> method</span>.</span>getName</span>(</span>)</span>)</span>;</span></span>
            return</span> result</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
    @</span>SuppressWarnings</span>(</span>"</span>unchecked</span>"</span>)</span></span>
    private</span> static</span> <</span>T</span>></span> T</span> getProxy</span>(</span>Class</span><</span>T</span>></span> cls</span>)</span> {</span></span>
        Enhancer</span> enhancer</span> =</span> new</span> Enhancer</span>(</span>)</span>;</span></span>
        enhancer</span>.</span>setSuperclass</span>(</span>cls</span>)</span>;</span></span>
        enhancer</span>.</span>setCallback</span>(</span>new</span> SimpleInterceptor</span>(</span>)</span>)</span>;</span></span>
        return</span> (</span>T</span>)</span> enhancer</span>.</span>create</span>(</span>)</span>;</span></span>
    }</span></span>
</span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> throws</span> Exception</span> {</span></span>
        RealService</span> proxyService</span> =</span> getProxy</span>(</span>RealService</span>.</span>class</span>)</span>;</span></span>
        proxyService</span>.</span>sayHello</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
注：上述代码引用了 cglib 的包，以 maven 为例：</p>
<</span>dependency</span>></span>  </span></span>
    <</span>groupId</span>></span>cglib</span></</span>groupId</span>></span>  </span></span>
    <</span>artifactId</span>></span>cglib</span></</span>artifactId</span>></span>  </span></span>
    <</span>version</span>></span>3.3.0</span></</span>version</span>></span>  </span></span>
</</span>dependency</span>></span></span></code></pre>
RealService 为被代理的类，它没有接口， getProxy 方法接收一个 Class 对象，方法返回一个代理类。</p>
getProxy 方法中使用了 cglib 的 Enhancer 类，Enhancer 类的 superclass 设置成了被代理的类。setCallback 设置被代理类的 public 非 final 方法被调用时的处理类。上例用使用的处理类是 SimpleInterceptor</code> 继承 MethodInterceptor</code> 并实现 intercept</code> 方法。</p>

第一个参数是 object，是代理类对象</strong>。</li>
第二个参数是 method，是被调用的方法。</li>
第三个参数是 args，是被调用的方法参数。</li>
第四个参数是 methodProxy，方法中使用它的 invokeSuper (object, args) 来调用被代理类的方法，注意别写成了 invoke (object, args)，不然它调用的是代理类，然后又进入了这个方法，会无限循化。</li>
</ul>
与 JDK 动态代理不同的是，cglib 的用法，我们在 main 方法中也没有创建被代理类的对象，创建的对象直接就是代理对象。</p>
实现原理：</p>
cglib 不同于 jdk 动态代理，它是通过继承实现的</strong>，它是动态创建了一个类，但这个类的父类是被代理的类，代理类重写了父类的所有 public 非 final 方法，改为调用 callback 中的相关方法，在上例中，调用 SimpleInterceptor 的 intercept 方法。</p>
比较</h2>
从原理上来看：</p>

JDK 动态代理面向的是一组接口，它为这些接口创建了一个实现类，接口的具体实现是通过自定义的 InvocationHandler 实现的，也就是说，一个代理类背后都不一定有真正被代理的对象，也可能有多个实际对象，根据情况动态选择。局限性是要求被代理类必须实现了接口。</li>
CGLIB 动态代理面向的是一个具体的类，它为这个类动态创建一个子类，父类所有 public 非 final 方法，然后在这些方法中调用  MethodInterceptor 的实现，这个实现中定义了代理逻辑。不要求代理类实现接口。</li>
</ul>
从代理的角度来看：</p>

JDK 动态代理：代理的是对象，需要首先有一个实际对象，然后使用自定义 InvocationHandler 引用该对象。</li>
CGLIB：只会创建代理类，所有的操作都是针对代理类，无需手动创建实际对象。</li>
</ul>
参考链接</h2>

https://www.cnblogs.com/swiftma/p/6869790.html</li>
</ul>


日志输出最佳实践
2022-12-12T22:56:54+08:00
在动作后打日志</h2>
//</span> don't do that</span></span>
log</span>.</span>info</span>(</span>"</span>Making request to REST API</span>"</span>)</span></span>
restClient</span>.</span>makeRequest</span>(</span>)</span></span>
</span>
//</span> do that</span></span>
restClient</span>.</span>makeRequest</span>(</span>)</span></span>
log</span>.</span>info</span>(</span>"</span>Made request to REST API</span>"</span>)</span></span></code></pre>
第一个例子是反例，这个日志无法说明 REST 调用是否成功，你可能会看到日志输出，并在之后抛出了一个日志，可能会对查看日志的人造成困惑，不知道到底调用成功没。</p>
第二个例子为正例，如果业务代码运行正常会输出日志，反之会抛出异常，同时日志也不会打印。</p>

INFO 格式的日志适用此规则，DEBUG 模式还有例外，会在下面介绍。</p>
</blockquote>
分离参数和日志信息</h2>
//</span> don't do that</span></span>
restClient</span>.</span>makeRequest</span>(</span>)</span></span>
log</span>.</span>info</span>(</span>"</span>Made request to {} on REST API.</span>"</span>,</span> url</span>)</span></span>
</span>
//</span> do that</span></span>
restClient</span>.</span>makeRequest</span>(</span>)</span></span>
log</span>.</span>info</span>(</span>"</span>Made request to REST API. [url={}]</span>"</span>,</span> url</span>)</span></span></code></pre>
日志有两部分，一部分是人工写的帮助判断状态的提示信息，另一部分是实际操作中的参数。
第一个例子中，不容易区分参数到底是哪个，尤其当日志较长时，可读性会大大降低。
第二个例子中，可更清晰的查看参数信息，且便于使用一些表达式解析参数。</p>
区分 WARNING 和 ERROR</h2>
简单来说，两者的区别为：</p>

WARNING</code>：做了某些操作，但是有问题。</li>
ERROR</code>：做了某些操作，但压根没起作用或压根无法做。</li>
</ul>
如：</p>
try</span> {</span></span>
    restClient</span>.</span>makeRequest</span>(</span>)</span></span>
    log</span>.</span>info</span>(</span>"</span>Made request to REST API. [url={}]</span>"</span>,</span> url</span>)</span></span>
}</span> catch</span>(</span>e</span>: </span>UnauthorizedException</span>)</span> {</span></span>
    log</span>.</span>warn</span>(</span>"</span>Request to REST API was rejected because user is unauthorized. [url={}, result={}]</span>"</span>,</span> url</span>,</span> result</span>)</span></span>
}</span> catch</span>(</span>e</span>: </span>Exception</span>)</span> {</span></span>
    log</span>.</span>error</span>(</span>"</span>Request to REST API failed. [url={}, exception={}]</span>"</span>,</span> url</span>,</span> exception</span>)</span></span>
}</span></span></code></pre>
REST 调用可能具有以下三种结果：</p>

它可以正常工作，这是 INFO 级别的（在工作后）</li>
它可能会造成一些预期的异常，这是 WARNING 级别的。</li>
它可能因出现预期外位置的异常导致失败，这是 ERROR 级别的。</li>
</ul>

注意：当 WARNING 和 ERROR 在无需处理时，不应该记录。如 Java 中 ClientAbortException 异常，一般来说是不需要处理的</p>
</blockquote>
业务使用 INFO、技术使用 DEBUG</h2>
INFO 日志应该像一本书，它应该告诉你发生了什么：</p>
INFO  </span>|</span> User</span> registered </span>for</span> newsletter</span>.</span> [</span>user</span>=</span>"</span>Thomas</span>"</span>,</span> email</span>=</span>"</span>thomas@tuhrig.de</span>"</span>]</span></span>
INFO  </span>|</span> Newsletter</span> send to user</span>.</span> [</span>user</span>=</span>"</span>Thomas</span>"</span>]</span></span>
INFO  </span>|</span> User</span> unsubscribed from newsletter</span>.</span> [</span>user</span>=</span>"</span>Thomas</span>"</span>,</span> email</span>=</span>"</span>thomas@tuhrig.de</span>"</span>]</span></span></code></pre>
DEBUG 日志应该描述发生该过程的工作原理：</p>
DEBUG </span>|</span> Saved</span> user to newsletter list</span>.</span> [</span>user</span>=</span>"</span>Thomas</span>"</span>,</span> email</span>=</span>"</span>thomas@tuhrig.de</span>"</span>]</span></span>
DEBUG </span>|</span> Send</span> welcome mail</span>.</span> [</span>user</span>=</span>"</span>Thomas</span>"</span>,</span> email</span>=</span>"</span>thomas@tuhrig.de</span>"</span>]</span></span>
INFO  </span>|</span> User</span> registered </span>for</span> newsletter</span>.</span> [</span>user</span>=</span>"</span>Thomas</span>"</span>,</span> email</span>=</span>"</span>thomas@tuhrig.de</span>"</span>]</span></span>
DEBUG </span>|</span> Started</span> cron job to send newsletter of the day</span>.</span> [</span>subscribers</span>=</span>24332</span>]</span></span>
INFO  </span>|</span> Newsletter</span> send to user</span>.</span> [</span>user</span>=</span>"</span>Thomas</span>"</span>]</span></span>
INFO  </span>|</span> User</span> unsubscribed from newsletter</span>.</span> [</span>user</span>=</span>"</span>Thomas</span>"</span>,</span> email</span>=</span>"</span>thomas@tuhrig.de</span>"</span>]</span></span></code></pre>参考链接</h2>

https://tuhrig.de/my-logging-best-practices/</li>
</ul>


Java 实现 JavaScript 版本的 URL 编解码
2022-12-04T21:01:00+08:00
encodeURIComponent</h2>
安全字符（不会被编码的字符）为 a-z</code>、A-Z</code>、0-9</code>、~</code>、_</code>、.</code>、.</code>   （实际上 JavaScript 版本的安全字符还要更多一些，不过这些字符即使编码也不会影响使用）</p>
private</span> static</span> final</span> String</span> HEX</span> =</span> "</span>0123456789ABCDEF</span>"</span>;</span></span>
</span>
public</span> static</span> String</span> encodeURIComponent</span>(</span>String</span> str</span>)</span> {</span>  </span></span>
    if</span> (</span>str </span>==</span> null</span>)</span> return</span> null</span>;</span>  </span></span>
  </span></span>
    byte</span>[</span>]</span> bytes</span> =</span> str</span>.</span>getBytes</span>(</span>StandardCharsets</span>.</span>UTF_8</span>)</span>;</span>  </span></span>
    StringBuilder</span> builder</span> =</span> new</span> StringBuilder</span>(</span>bytes</span>.</span>length</span>)</span>;</span>  </span></span>
  </span></span>
    for</span> (</span>byte</span> c</span> :</span> bytes</span>)</span> {</span>  </span></span>
        if</span> (</span>c </span>>=</span> '</span>a</span>'</span> ?</span> c </span><=</span> '</span>z</span>'</span> ||</span> c </span>==</span> '</span>~</span>'</span> :</span>  </span></span>
                c </span>>=</span> '</span>A</span>'</span> ?</span> c </span><=</span> '</span>Z</span>'</span> ||</span> c </span>==</span> '</span>_</span>'</span> :</span>  </span></span>
                        c </span>>=</span> '</span>0</span>'</span> ?</span> c </span><=</span> '</span>9</span>'</span> :</span>  c </span>==</span> '</span>-</span>'</span> ||</span> c </span>==</span> '</span>.</span>'</span>)</span>  </span></span>
            builder</span>.</span>append</span>(</span>(</span>char</span>)</span>c</span>)</span>;</span>  </span></span>
        else</span>  </span></span>
            builder</span>.</span>append</span>(</span>'</span>%</span>'</span>)</span>  </span></span>
                    .</span>append</span>(</span>HEX</span>.</span>charAt</span>(</span>c </span>>></span> 4</span> &</span> 0xf</span>)</span>)</span>  </span></span>
                    .</span>append</span>(</span>HEX</span>.</span>charAt</span>(</span>c </span>&</span> 0xf</span>)</span>)</span>;</span>  </span></span>
    }</span>  </span></span>
  </span></span>
    return</span> builder</span>.</span>toString</span>(</span>)</span>;</span>  </span></span>
}</span></span></code></pre>decodeURIComponent</h2>
public</span> static</span> String</span> decodeURIComponent</span>(</span>String</span> str</span>)</span> {</span></span>
    if</span> (</span>str </span>==</span> null</span>)</span> return</span> null</span>;</span></span>
</span>
    int</span> length</span> =</span> str</span>.</span>length</span>(</span>)</span>;</span></span>
    byte</span>[</span>]</span> bytes</span> =</span> new</span> byte</span>[</span>length </span>/</span> 3</span>]</span>;</span></span>
    StringBuilder</span> builder</span> =</span> new</span> StringBuilder</span>(</span>length</span>)</span>;</span></span>
</span>
    for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> length</span>;</span> )</span> {</span></span>
        char</span> c</span> =</span> str</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
        if</span> (</span>c </span>!=</span> '</span>%</span>'</span>)</span> {</span></span>
            builder</span>.</span>append</span>(</span>c</span>)</span>;</span></span>
            i </span>+=</span> 1</span>;</span></span>
        }</span> else</span> {</span></span>
            int</span> j</span> =</span> 0</span>;</span></span>
            do</span> {</span></span>
                char</span> h</span> =</span> str</span>.</span>charAt</span>(</span>i </span>+</span> 1</span>)</span>;</span></span>
                char</span> l</span> =</span> str</span>.</span>charAt</span>(</span>i </span>+</span> 2</span>)</span>;</span></span>
                i </span>+=</span> 3</span>;</span></span>
</span>
                h </span>-=</span> '</span>0</span>'</span>;</span></span>
                if</span> (</span>h </span>>=</span> 10</span>)</span> {</span></span>
                    h </span>|=</span> '</span> '</span>;</span></span>
                    h </span>-=</span> '</span>a</span>'</span> -</span> '</span>0</span>'</span>;</span></span>
                    if</span> (</span>h </span>>=</span> 6</span>)</span> throw</span> new</span> IllegalArgumentException</span>(</span>)</span>;</span></span>
                    h </span>+=</span> 10</span>;</span></span>
                }</span></span>
</span>
                l </span>-=</span> '</span>0</span>'</span>;</span></span>
                if</span> (</span>l </span>>=</span> 10</span>)</span> {</span></span>
                    l </span>|=</span> '</span> '</span>;</span></span>
                    l </span>-=</span> '</span>a</span>'</span> -</span> '</span>0</span>'</span>;</span></span>
                    if</span> (</span>l </span>>=</span> 6</span>)</span> throw</span> new</span> IllegalArgumentException</span>(</span>)</span>;</span></span>
                    l </span>+=</span> 10</span>;</span></span>
                }</span></span>
</span>
                bytes</span>[</span>j</span>++</span>]</span> =</span> (</span>byte</span>)</span>(</span>h </span><<</span> 4</span> |</span> l</span>)</span>;</span></span>
                if</span> (</span>i </span>>=</span> length</span>)</span> break</span>;</span></span>
                c </span>=</span> str</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
            }</span> while</span> (</span>c </span>==</span> '</span>%</span>'</span>)</span>;</span></span>
            builder</span>.</span>append</span>(</span>new</span> String</span>(</span>bytes</span>,</span> 0</span>,</span> j</span>,</span> UTF_8</span>)</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
</span>
    return</span> builder</span>.</span>toString</span>(</span>)</span>;</span></span>
}</span></span></code></pre>参考链接</h2>

https://stackoverflow.com/questions/607176/java-equivalent-to-javascripts-encodeuricomponent-that-produces-identical-outpu</li>
https://www.rfc-editor.org/rfc/rfc3986#section-2.2</li>
https://guava.dev/releases/19.0/api/docs/com/google/common/net/PercentEscaper.html</a></li>
</ul>


浅谈如何在大陆服务器加速访问 github 和 k8s.gcr.io 等资源 - sniproxy
2022-11-15T20:03:00+08:00
前言</h2>
开发时，常在大陆服务器上部署或测试项目，因网络环境原因，当访问 github、k8s.gcr.io、quay.io 等资源时，速度会非常慢，甚至无法访问。</p>
其他解决方案弊端</h2>
网上的解决访问也有很多，因 github 使用了 cdn，通过找到大陆可访问的 cdn 节点填写到 hosts 中的方式来加速，一是不太稳定，二是速度也不一定快。</p>
且对于 k8s.gcr.io、quay.io 这种，可能连可用的 ip 都找不到。</p>
本文提出的解决访问，无需修改 docker 镜像源，配置加速无需重启使用者任何服务，即用即配。</p>
安装步骤（在海外服务器上）</h2>
前提条件</h3>
本文提出的解决访问也是 hosts 映射的方式，不过使用了自建服务器代理来解决。</p>
要求条件：</p>

非大陆服务器一台</li>
需占用服务器 443 端口</li>
ubuntu/debian 服务器（centos 未测试成功）</li>
</ul>
安装 sniproxy</h3>
apt-get</span> install</span> -</span>y</span> git</span> autotools-dev</span> cdbs</span> debhelper</span> dh-autoreconf</span> dpkg-dev</span> gettext</span> libev-dev</span> libpcre3-dev</span> libudns-dev</span> pkg-config</span> fakeroot</span> devscripts</span></span>
git</span> clone</span> https://github.com/dlundquist/sniproxy.git</span></span>
cd</span> sniproxy</span></span>
./autogen.sh</span> &&</span> dpkg-buildpackage</span></span>
dpkg</span> -</span>i</span> ../sniproxy_</span>*</span>_</span>*</span>.deb</span></span>
apt-get</span> install</span> -</span>y</span> sniproxy</span></span></code></pre>配置 sniproxy</h3>
修改 /etc/sniproxy.conf</code> 配置文件为如下内容：</p>
# sniproxy example configuration file</span></span>
# lines that start with # are comments</span></span>
# lines with only white space are ignored</span></span>
</span>
user</span> daemon</span></span>
</span>
# PID file</span></span>
pidfile /var/run/sniproxy.pid</span></span>
</span>
error_log {</span></span>
    # Log to the daemon syslog facility</span></span>
    syslog daemon</span></span>
</span>
    # Alternatively we could log to file</span></span>
    #filename /var/log/sniproxy/sniproxy.log</span></span>
</span>
    # Control the verbosity of the log</span></span>
    priority notice</span></span>
}</span></span>
</span>
# blocks are delimited with {...}</span></span>
listen </span>80</span> {</span></span>
    proto http</span></span>
    table http_hosts</span></span>
    # Fallback backend server to use if we can not parse the client request</span></span>
    fallback localhost:8080</span></span>
</span>
    access_log {</span></span>
        filename /var/log/sniproxy/http_access.log</span></span>
        priority notice</span></span>
    }</span></span>
}</span></span>
</span>
listen </span>443</span> {</span></span>
    proto tls</span></span>
    table https_hosts</span></span>
</span>
    access_log {</span></span>
        filename /var/log/sniproxy/https_access.log</span></span>
        priority notice</span></span>
    }</span></span>
}</span></span>
</span>
# named tables are defined with the table directive</span></span>
table http_hosts {</span></span>
    example.com 192.0.2.10:8001</span></span>
    example.net 192.0.2.10:8002</span></span>
    example.org 192.0.2.10:8003</span></span>
</span>
# pattern:</span></span>
#       valid Perl-compatible Regular Expression that matches the</span></span>
#       hostname</span></span>
#</span></span>
# target:</span></span>
#       - a DNS name</span></span>
#       - an IP address (with optional port)</span></span>
#       - '*' to use the hostname that the client requested</span></span>
#</span></span>
# pattern       target</span></span>
#.*\.itunes\.apple\.com$        *:443</span></span>
#.*     127.0.0.1:4443</span></span>
}</span></span>
</span>
# named tables are defined with the table directive</span></span>
table https_hosts {</span></span>
    # When proxying to local sockets you should use different tables since the</span></span>
    # local socket server most likely will not autodetect which protocol is</span></span>
    # being used</span></span>
    example.org unix:/var/run/server.sock</span></span>
    github.com$ *</span></span>
    (.*.|)github.com$ *</span></span>
    (.*.|)githubusercontent.com$ *</span></span>
    translate.googleapis.com$ *</span></span>
    gcr.io$ *</span></span>
    k8s.gcr.io$ *</span></span>
    quay.io$ *</span></span>
}</span></span>
</span>
# if no table specified the default 'default' table is defined</span></span>
table {</span></span>
    # if no port is specified default HTTP (80) and HTTPS (443) ports are</span></span>
    # assumed based on the protocol of the listen block using this table</span></span>
    example.com 192.0.2.10</span></span>
    example.net 192.0.2.20</span></span>
}</span></span></code></pre>
上述配置中包含了代理 github、谷歌翻译、quay.io、k8s.gcr.io、gcr.io、可自行调整。</p>
启动 sniproxy 服务</h3>
sniproxy</span> -</span>c</span> /etc/sniproxy.conf</span></span></code></pre>停止 sniproxy 服务</h3>
pkill</span> sniproxy</span></span></code></pre>测试（在大陆服务器上）</h2>
配置 github hosts</h3>
将下方的 x.x.x.x 修改为你服务器的公网 ip，然后就可以加速访问国内</p>
sudo sed -i '/github/d' /etc/hosts</span></span>
sudo echo 'x.x.x.x              github.githubassets.com</span></span>
x.x.x.x              central.github.com</span></span>
x.x.x.x              desktop.githubusercontent.com</span></span>
x.x.x.x              assets-cdn.github.com</span></span>
x.x.x.x              camo.githubusercontent.com</span></span>
x.x.x.x              github.map.fastly.net</span></span>
x.x.x.x              github.global.ssl.fastly.net</span></span>
x.x.x.x              gist.github.com</span></span>
x.x.x.x              github.io</span></span>
x.x.x.x              github.com</span></span>
x.x.x.x              api.github.com</span></span>
x.x.x.x              raw.githubusercontent.com</span></span>
x.x.x.x              user-images.githubusercontent.com</span></span>
x.x.x.x              favicons.githubusercontent.com</span></span>
x.x.x.x              avatars5.githubusercontent.com</span></span>
x.x.x.x              avatars4.githubusercontent.com</span></span>
x.x.x.x              avatars3.githubusercontent.com</span></span>
x.x.x.x              avatars2.githubusercontent.com</span></span>
x.x.x.x              avatars1.githubusercontent.com</span></span>
x.x.x.x              avatars0.githubusercontent.com</span></span>
x.x.x.x              avatars.githubusercontent.com</span></span>
x.x.x.x              codeload.github.com</span></span>
x.x.x.x              github-cloud.s3.amazonaws.com</span></span>
x.x.x.x              github-com.s3.amazonaws.com</span></span>
x.x.x.x              github-production-release-asset-2e65be.s3.amazonaws.com</span></span>
x.x.x.x              github-production-user-asset-6210df.s3.amazonaws.com</span></span>
x.x.x.x              github-production-repository-file-5c1aeb.s3.amazonaws.com</span></span>
x.x.x.x              githubstatus.com</span></span>
x.x.x.x              github.community</span></span>
x.x.x.x              media.githubusercontent.com</span></span>
x.x.x.x              objects.githubusercontent.com</span></span>
x.x.x.x              raw.github.com</span></span>
x.x.x.x              copilot-proxy.githubusercontent.com</span></span>
' >> /etc/hosts</span></span></code></pre>测试 github 加速情况</h3>
curl -I https://github.com</span></span></code></pre>
如返回类似以下内容，则为正常</p>
HTTP/1.1 200 OK</span></span>
Server: GitHub.com</span></span>
Date: Mon, 14 Nov 2022 01:58:28 GMT</span></span>
Content-Type: text/html; charset=utf-8</span></span>
Vary: X-PJAX, X-PJAX-Container, Turbo-Visit, Turbo-Frame, Accept-Language, Accept-Encoding, Accept, X-Requested-With</span></span>
content-language: en-US</span></span>
ETag: W/"52722faad6b1b0ee103e6d83982f005c"</span></span>
Cache-Control: max-age=0, private, must-revalidate</span></span>
Strict-Transport-Security: max-age=31536000; includeSubdomains; preload</span></span>
X-Frame-Options: deny</span></span>
X-Content-Type-Options: nosniff</span></span>
X-XSS-Protection: 0</span></span>
......</span></span></code></pre>配置 k8s hosts</h3>
同理，见下方的 x.x.x.x 修改为你服务器的公网 ip，然后就可以加速访问了</p>
sudo echo 'x.x.x.x              k8s.gcr.io</span></span>
x.x.x.x              gcr.io</span></span>
x.x.x.x              quay.io</span></span>
' >> /etc/hosts</span></span></code></pre>测试 k8s 加速情况</h3>
可尝试拉取此镜像，能拉取成功，表示没问题</p>
docker pull k8s.gcr.io/etcd:3.4.3-0</span></span></code></pre>总结</h2>
通过此办法，可加速很多开发资源，看你自己怎么发挥了，但一定要遵纪守法，不要通过技术作恶。</p>


剑指 Offer 04. 二维数组中的查找
2022-10-07T17:29:54+08:00
剑指 Offer 04. 二维数组中的查找</a></h1>
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。</p>
示例:</p>
现有矩阵 matrix 如下：</p>
[</span></span>
  [</span>1</span>,</span>   4</span>,</span>  7</span>,</span> 11</span>,</span> 15</span>]</span>,</span></span>
  [</span>2</span>,</span>   5</span>,</span>  8</span>,</span> 12</span>,</span> 19</span>]</span>,</span></span>
  [</span>3</span>,</span>   6</span>,</span>  9</span>,</span> 16</span>,</span> 22</span>]</span>,</span></span>
  [</span>10</span>,</span> 13</span>,</span> 14</span>,</span> 17</span>,</span> 24</span>]</span>,</span></span>
  [</span>18</span>,</span> 21</span>,</span> 23</span>,</span> 26</span>,</span> 30</span>]</span></span>
]</span></span>
给定 target </span>=</span> 5</span>，返回 </span>true</span>。</span></span></code></pre>
给定 target = 5</code>，返回 true</code>。</p>
给定 target = 20</code>，返回 false</code>。</p>
限制：</strong></p>
0 <= n <= 1000</code></p>
0 <= m <= 1000</code></p>
题解 1 - 从左下角找</h2>
从左下角看，上方的数据都比下方的小，右侧的数据都比左侧的大。</p>
设行数为 rows</code>，列数为 columns</code>，</p>
从左下角找，所以 x</code> 设为 columns -  1</code>，y</code> 设置为 0，如果元素等于 target</code> 直接返会 true</code>，如果元素大小 target</code> 则 x—</code>，如果元素小于 taget</code> 则 y++</code>，直到越数组边界未找到，返回 false.</p>
class</span> Solution</span> {</span></span>
</span>
    public</span> boolean</span> findNumberIn2DArray</span>(</span>int</span>[</span>]</span>[</span>]</span> matrix</span>,</span> int</span> target</span>)</span> {</span></span>
        int</span> rows</span> =</span> matrix</span>.</span>length</span>;</span></span>
        if</span> (</span>rows </span>==</span> 0</span>)</span> {</span></span>
            return</span> false</span>;</span></span>
        }</span></span>
</span>
        int</span> columns</span> =</span> matrix</span>[</span>0</span>]</span>.</span>length</span>;</span></span>
</span>
        int</span> x</span> =</span> rows </span>-</span> 1</span>,</span> y </span>=</span> 0</span>;</span></span>
</span>
        while</span> (</span>x </span>>=</span> 0</span> &&</span> y </span><=</span> columns </span>-</span> 1</span>)</span> {</span></span>
            int</span> n</span> =</span> matrix</span>[</span>x</span>]</span>[</span>y</span>]</span>;</span></span>
</span>
            if</span> (</span>n </span>==</span> target</span>)</span> {</span></span>
                return</span> true</span>;</span></span>
            }</span> else</span> if</span> (</span>n </span>></span> target</span>)</span> {</span></span>
                x</span>--</span>;</span></span>
            }</span> else</span> {</span></span>
                y</span>++</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> false</span>;</span></span>
    }</span></span>
}</span></span></code></pre>题解 2 — 从右上角找</h2>
和题解 1 思路差不多，只是反过来而已</p>
class</span> Solution</span> {</span></span>
</span>
    public</span> boolean</span> findNumberIn2DArray</span>(</span>int</span>[</span>]</span>[</span>]</span> matrix</span>,</span> int</span> target</span>)</span> {</span></span>
        int</span> rows</span> =</span> matrix</span>.</span>length</span>;</span></span>
        if</span> (</span>rows </span>==</span> 0</span>)</span> {</span></span>
            return</span> false</span>;</span></span>
        }</span></span>
</span>
        int</span> columns</span> =</span> matrix</span>[</span>0</span>]</span>.</span>length</span>;</span></span>
</span>
        int</span> x</span> =</span> 0</span>,</span> y </span>=</span> columns </span>-</span> 1</span>;</span></span>
</span>
        while</span> (</span>x </span><=</span> rows </span>-</span> 1</span> &&</span> y </span>>=</span> 0</span>)</span> {</span></span>
            int</span> n</span> =</span> matrix</span>[</span>x</span>]</span>[</span>y</span>]</span>;</span></span>
</span>
            if</span> (</span>n </span>==</span> target</span>)</span> {</span></span>
                return</span> true</span>;</span></span>
            }</span> else</span> if</span> (</span>n </span>></span> target</span>)</span> {</span></span>
                y</span>--</span>;</span></span>
            }</span> else</span> {</span></span>
                x</span>++</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> false</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


宝塔 nginx 增加编译模块
2022-09-27T10:27:29+08:00
修改配置文件</h2>
vi</span> /www/server/panel/install/nginx.sh</span></span></code></pre>
找到第 250-300 行之间 ./configure</code> 开头如下字样的配置，我这里是在安装 ngx-fancyindex</code> 模块，所以增加 --add-module=/usr/local/src/ngx-fancyindex</code>：</p>
./configure --add-module=/usr/local/src/ngx-fancyindex --user=www --group=www --prefix=${Setup_Path} ${ENABLE_LUA} --add-module=${Setup_Path}/src/ngx_cache_purge --add-module=${Setup_Path}/src/nginx-sticky-module --with-openssl=${Setup_Path}/src/openssl --with-pcre=pcre-${pcre_version} ${ENABLE_HTTP2} --with-http_stub_status_module --with-http_ssl_module --with-http_image_filter_module --with-http_gzip_static_module --with-http_gunzip_module --with-ipv6 --with-http_sub_module --with-http_flv_module --with-http_addition_module --with-http_realip_module --with-http_mp4_module --with-ld-opt="-Wl,-E" --with-cc-opt="-Wno-error" ${jemallocLD} ${ENABLE_WEBDAV} ${ENABLE_NGX_PAGESPEED} ${ADD_EXTENSION} ${i_make_args}</span></span>
    make -j${cpuCore}</span></span></code></pre>重新编译安装</h2>
执行以下命令重新编译安装，后面的 2.3.3</code> 是你安装的 nginx</code> 版本号，可通过 nginx -v</code> 查看：</p>
sh</span> /www/server/panel/install/nginx.sh</span> install</span> 2.3.3</span></span></code></pre>检查是否正确安装</h2>
编译根据你机器配置需要几分钟到十几分钟，编译完后执行 nginx -V</code> 查看，如果包含 --add-module=/usr/local/src/ngx-fancyindex</code> 就是成功了。</p>
Tengine</span> version:</span> Tengine/2.3.3</span></span>
nginx</span> version:</span> nginx/1.18.0</span></span>
built</span> by</span> gcc</span> 9.4.0</span> (Ubuntu</span> 9.4.0-1ubuntu1~20.04.1</span>) </span></span>
built</span> with</span> OpenSSL</span> 1.1.1m</span>  14</span> Dec</span> 2021</span></span>
TLS</span> SNI</span> support</span> enabled</span></span>
configure</span> arguments:</span> -</span>-add-module=/usr/local/src/ngx-fancyindex</span> -</span>-user=www</span> -</span>-group=www</span> -</span>-prefix=/www/server/nginx</span> -</span>-add-module=/www/server/nginx/src/ngx_cache_purge</span> -</span>-add-module=/www/server/nginx/src/nginx-sticky-module</span> -</span>-with-openssl=/www/server/nginx/src/openssl</span> -</span>-with-pcre=pcre-8.43</span> -</span>-with-http_v2_module</span> -</span>-with-stream</span> -</span>-with-stream_ssl_module</span> -</span>-with-stream_ssl_preread_module</span> -</span>-with-http_stub_status_module</span> -</span>-with-http_ssl_module</span> -</span>-with-http_image_filter_module</span> -</span>-with-http_gzip_static_module</span> -</span>-with-http_gunzip_module</span> -</span>-with-ipv6</span> -</span>-with-http_sub_module</span> -</span>-with-http_flv_module</span> -</span>-with-http_addition_module</span> -</span>-with-http_realip_module</span> -</span>-with-http_mp4_module</span> -</span>-with-ld-opt=-Wl,-E</span> -</span>-with-cc-opt=-Wno-error</span> -</span>-with-http_dav_module</span> -</span>-add-module=/www/server/nginx/src/nginx-dav-ext-module</span></span></code></pre>


leetcode 面试题 03.05. 栈排序
2022-09-26T10:10:52+08:00
面试题 03.05. 栈排序</a></h1>
题目</h2>
栈排序。 编写程序，对栈进行排序使最小元素位于栈顶。最多只能使用一个其他的临时栈存放数据，但不得将元素复制到别的数据结构（如数组）中。该栈支持如下操作：push</code>、pop</code>、peek</code> 和 isEmpty</code>。当栈为空时，peek</code> 返回 -1。</p>
示例1:</strong></p>
 输入：</span></span>
["SortedStack", "push", "push", "peek", "pop", "peek"]</span></span>
[[], [1], [2], [], [], []]</span></span>
 输出：</span></span>
[null,null,null,1,null,2]</span></span></code></pre>
示例2:</strong></p>
 输入： </span></span>
["SortedStack", "pop", "pop", "push", "pop", "isEmpty"]</span></span>
[[], [], [], [1], [], []]</span></span>
 输出：</span></span>
[null,null,null,null,null,true]</span></span></code></pre>
说明:</strong></p>

栈中的元素数目在[0, 5000]范围内。</li>
</ol>
题解</h2>
解题思路，将数据栈命名为 dataStack, 辅助栈命名为 helperStack.</p>

push: 永远 push 到 dataStack 中.</li>
pop: sort() 后, 如果 helperStack 不为空则 pop();</li>
peek: sort() 后, 如果 helperStack 不为空则 peek(), 为空返回 -1;</li>
isEmpty: 判断 dataStack 和 helperStack 是否都不为空.</li>
sort: 排序操作，将 dataStack 排序后压入到 helperStack
5.1 取 dataStack 中栈顶元素即为 dataTopItem
5.2 如果 dataTopItem 小于等于 helperStack 栈顶元素，则将 dataTopItem 压入到 helperStack 栈顶.
5.3 如果 dataTopItem 大于 helperStack 栈顶元素，则依次将 helperStack 栈顶元素压回 dataStack, 然后比较 helperStack 新的栈顶元素和 dataTopItem 的大小，参考 5.2 的逻辑。 直到最后 dataStack 中的元素全部压入到 helperStack 中.</li>
</ol>
import</span> java</span>.</span>util</span>.</span>Stack</span>;</span></span>
</span>
//</span>leetcode submit region begin(Prohibit modification and deletion)</span></span>
class</span> SortedStack</span> {</span></span>
    </span></span>
    private</span> Stack</span><</span>Integer</span>></span> dataStack</span>;</span></span>
    </span></span>
    private</span> Stack</span><</span>Integer</span>></span> helperStack</span>;</span></span>
    </span></span>
    public</span> SortedStack</span>(</span>)</span> {</span></span>
        dataStack </span>=</span> new</span> Stack</span><</span>></span>(</span>)</span>;</span></span>
        helperStack </span>=</span> new</span> Stack</span><</span>></span>(</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> void</span> push</span>(</span>int</span> val</span>)</span> {</span></span>
        dataStack</span>.</span>push</span>(</span>val</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> void</span> pop</span>(</span>)</span> {</span></span>
        sort</span>(</span>)</span>;</span></span>
        if</span> (</span>!</span>helperStack</span>.</span>isEmpty</span>(</span>)</span>)</span> {</span></span>
            helperStack</span>.</span>pop</span>(</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
    </span></span>
    public</span> int</span> peek</span>(</span>)</span> {</span></span>
        sort</span>(</span>)</span>;</span></span>
        if</span> (</span>helperStack</span>.</span>isEmpty</span>(</span>)</span>)</span> {</span></span>
            return</span> -</span>1</span>;</span></span>
        }</span> else</span> {</span></span>
            return</span> helperStack</span>.</span>peek</span>(</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
    </span></span>
    public</span> boolean</span> isEmpty</span>(</span>)</span> {</span></span>
        return</span> dataStack</span>.</span>isEmpty</span>(</span>)</span> &&</span> helperStack</span>.</span>isEmpty</span>(</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    private</span> void</span> sort</span>(</span>)</span> {</span></span>
        if</span> (</span>dataStack</span>.</span>isEmpty</span>(</span>)</span>)</span> {</span></span>
            return</span>;</span></span>
        }</span></span>
        </span></span>
        while</span> (</span>!</span>dataStack</span>.</span>isEmpty</span>(</span>)</span>)</span> {</span></span>
            //</span> 取数据栈栈顶元素</span></span>
            Integer</span> dataTopItem</span> =</span> dataStack</span>.</span>pop</span>(</span>)</span>;</span></span>
    </span></span>
            //</span> 判断只要辅助栈有元素小于数据栈栈顶元素，则取出并压回数据栈.</span></span>
            while</span> (</span>!</span>helperStack</span>.</span>isEmpty</span>(</span>)</span> &&</span> helperStack</span>.</span>peek</span>(</span>)</span> <</span> dataTopItem</span>)</span> {</span></span>
                dataStack</span>.</span>push</span>(</span>helperStack</span>.</span>pop</span>(</span>)</span>)</span>;</span></span>
            }</span></span>
            //</span> 确保辅助栈没有比数据栈顶元素小的元素，则压入到辅助栈</span></span>
            helperStack</span>.</span>push</span>(</span>dataTopItem</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
}</span></span></code></pre>


leetcode 面试题 03.06. 动物收容所
2022-09-26T09:31:00+08:00
面试题 03.06. 动物收容所</a></h1>
题目</p>
动物收容所。有家动物收容所只收容狗与猫，且严格遵守“先进先出”的原则。在收养该收容所的动物时，收养人只能收养所有动物中“最老”（由其进入收容所的时间长短而定）的动物，或者可以挑选猫或狗（同时必须收养此类动物中“最老”的）。换言之，收养人不能自由挑选想收养的对象。请创建适用于这个系统的数据结构，实现各种操作方法，比如enqueue</code>、dequeueAny</code>、dequeueDog</code>和dequeueCat</code>。允许使用Java内置的LinkedList数据结构。</p>
enqueue</code>方法有一个animal</code>参数，animal[0]</code>代表动物编号，animal[1]</code>代表动物种类，其中 0 代表猫，1 代表狗。</p>
dequeue*</code>方法返回一个列表[动物编号, 动物种类]</code>，若没有可以收养的动物，则返回[-1,-1]</code>。</p>
示例1:</strong></p>
 输入：</span></span>
["AnimalShelf", "enqueue", "enqueue", "dequeueCat", "dequeueDog", "dequeueAny"]</span></span>
[[], [[0, 0]], [[1, 0]], [], [], []]</span></span>
 输出：</span></span>
[null,null,null,[0,0],[-1,-1],[1,0]]</span></span></code></pre>
示例2:</strong></p>
 输入：</span></span>
["AnimalShelf", "enqueue", "enqueue", "enqueue", "dequeueDog", "dequeueCat", "dequeueAny"]</span></span>
[[], [[0, 0]], [[1, 0]], [[2, 1]], [], [], []]</span></span>
 输出：</span></span>
[null,null,null,null,[2,1],[0,0],[1,0]]</span></span></code></pre>
说明:</strong></p>

收纳所的最大容量为20000</li>
</ol>
题解</h2>
采用双队列实现，猫和狗分开存储，取任意一个时，则判断哪个的序号最小进行返回。</p>
import</span> java</span>.</span>util</span>.</span>LinkedList</span>;</span></span>
</span>
class</span> AnimalShelf</span> {</span></span>
</span>
    private</span> LinkedList</span><</span>int</span>[</span>]</span>></span> dogList</span>;</span></span>
    </span></span>
    private</span> LinkedList</span><</span>int</span>[</span>]</span>></span> catList</span>;</span></span>
    </span></span>
    private</span> int</span>[</span>]</span> emptyAnimal</span> =</span> new</span> int</span>[</span>]</span>{</span>-</span>1</span>,</span> -</span>1</span>}</span>;</span></span>
    </span></span>
    public</span> AnimalShelf</span>(</span>)</span> {</span></span>
        dogList </span>=</span> new</span> LinkedList</span><</span>></span>(</span>)</span>;</span></span>
        catList </span>=</span> new</span> LinkedList</span><</span>></span>(</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> void</span> enqueue</span>(</span>int</span>[</span>]</span> animal</span>)</span> {</span></span>
        switch</span> (</span>animal</span>[</span>1</span>]</span>)</span> {</span></span>
            case</span> 0</span>:</span> catList</span>.</span>addLast</span>(</span>animal</span>)</span>;</span> break</span>;</span></span>
            case</span> 1</span>:</span> dogList</span>.</span>addLast</span>(</span>animal</span>)</span>;</span> break</span>;</span></span>
        }</span></span>
    }</span></span>
    </span></span>
    public</span> int</span>[</span>]</span> dequeueAny</span>(</span>)</span> {</span></span>
        if</span> (</span>dogList</span>.</span>isEmpty</span>(</span>)</span> &&</span> catList</span>.</span>isEmpty</span>(</span>)</span>)</span> {</span></span>
            return</span> emptyAnimal</span>;</span></span>
        }</span></span>
        </span></span>
        if</span> (</span>dogList</span>.</span>isEmpty</span>(</span>)</span> ||</span> catList</span>.</span>isEmpty</span>(</span>)</span>)</span> {</span></span>
            return</span> dogList</span>.</span>isEmpty</span>(</span>)</span> ?</span> catList</span>.</span>pop</span>(</span>)</span> :</span> dogList</span>.</span>pop</span>(</span>)</span>;</span></span>
        }</span></span>
</span>
        int</span> dogOrder</span> =</span> dogList</span>.</span>peek</span>(</span>)</span>[</span>0</span>]</span>;</span></span>
        int</span> catOrder</span> =</span> catList</span>.</span>peek</span>(</span>)</span>[</span>0</span>]</span>;</span></span>
        return</span> dogOrder </span><</span> catOrder </span>?</span> dogList</span>.</span>pop</span>(</span>)</span> :</span> catList</span>.</span>pop</span>(</span>)</span>;</span></span>
    </span></span>
        </span></span>
    }</span></span>
    </span></span>
    public</span> int</span>[</span>]</span> dequeueDog</span>(</span>)</span> {</span></span>
        return</span> dogList</span>.</span>isEmpty</span>(</span>)</span> ?</span> emptyAnimal </span>:</span> dogList</span>.</span>pop</span>(</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> int</span>[</span>]</span> dequeueCat</span>(</span>)</span> {</span></span>
        return</span> catList</span>.</span>isEmpty</span>(</span>)</span> ?</span> emptyAnimal </span>:</span> catList</span>.</span>pop</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span>
</span>
/**</span></span>
 * Your AnimalShelf object will be instantiated and called as such:</span></span>
 * AnimalShelf obj = new AnimalShelf();</span></span>
 * obj.enqueue(animal);</span></span>
 * int[] param_2 = obj.dequeueAny();</span></span>
 * int[] param_3 = obj.dequeueDog();</span></span>
 * int[] param_4 = obj.dequeueCat();</span></span>
 */</span></span>
//</span>leetcode submit region end(Prohibit modification and deletion)</span></span></code></pre>


leetcode 232 用栈实现队列
2022-09-24T10:44:44+08:00
232. 用栈实现队列</a></h1>
题目</h2>
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push</code>、pop</code>、peek</code>、empty</code>）：</p>
实现 MyQueue</code> 类：</p>

void push(int x)</code> 将元素 x 推到队列的末尾</li>
int pop()</code> 从队列的开头移除并返回元素</li>
int peek()</code> 返回队列开头的元素</li>
boolean empty()</code> 如果队列为空，返回 true</code> ；否则，返回 false</code></li>
</ul>
说明：</strong></p>

你 只能</strong> 使用标准的栈操作 —— 也就是只有 push to top</code>, peek/pop from top</code>, size</code>, 和 is empty</code> 操作是合法的。</li>
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。</li>
</ul>
示例 1：</strong></p>
输入：</span></span>
["MyQueue", "push", "push", "peek", "pop", "empty"]</span></span>
[[], [1], [2], [], [], []]</span></span>
输出：</span></span>
[null, null, null, 1, 1, false]</span></span>
</span>
解释：</span></span>
MyQueue myQueue = new MyQueue();</span></span>
myQueue.push(1); // queue is: [1]</span></span>
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)</span></span>
myQueue.peek(); // return 1</span></span>
myQueue.pop(); // return 1, queue is [2]</span></span>
myQueue.empty(); // return false</span></span></code></pre>
提示：</strong></p>

1 <= x <= 9</code></li>
最多调用 100</code> 次 push</code>、pop</code>、peek</code> 和 empty</code></li>
假设所有操作都是有效的 （例如，一个空的队列不会调用 pop</code> 或者 peek</code> 操作）</li>
</ul>
进阶：</strong></p>

你能否实现每个操作均摊时间复杂度为 O(1)</code> 的队列？换句话说，执行 n</code> 个操作的总时间复杂度为 O(n)</code> ，即使其中一个操作可能花费较长时间。</li>
</ul>
思路</h2>
可使用一个栈作为压入栈，一个作为弹出栈，称为 pushStack，在弹出数据时只从这个栈弹出，称为 popStack.</p>

如果 pushStack 要向 popStack 压入数据，则必须一次全部压入。</li>
如果 popStack 不为空，pushStack 决不能向 popStack 压入数据。</li>
</ol>
违反上述两点就会出错。</p>
题解</h2>
import</span> java</span>.</span>util</span>.</span>Stack</span>;</span></span>
</span>
class</span> MyQueue</span> {</span></span>
    </span></span>
    private</span> Stack</span><</span>Integer</span>></span> pushStack</span>;</span></span>
    private</span> Stack</span><</span>Integer</span>></span> popStack</span>;</span></span>
</span>
    public</span> MyQueue</span>(</span>)</span> {</span></span>
        pushStack </span>=</span> new</span> Stack</span><</span>></span>(</span>)</span>;</span></span>
        popStack </span>=</span> new</span> Stack</span><</span>></span>(</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> void</span> push</span>(</span>int</span> x</span>)</span> {</span></span>
        pushStack</span>.</span>push</span>(</span>x</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> int</span> pop</span>(</span>)</span> {</span></span>
        peek</span>(</span>)</span>;</span></span>
        return</span> popStack</span>.</span>pop</span>(</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> int</span> peek</span>(</span>)</span> {</span></span>
        if</span> (</span>popStack</span>.</span>isEmpty</span>(</span>)</span>)</span> {</span></span>
            while</span> (</span>!</span>pushStack</span>.</span>isEmpty</span>(</span>)</span>)</span> {</span></span>
                popStack</span>.</span>push</span>(</span>pushStack</span>.</span>pop</span>(</span>)</span>)</span>;</span></span>
            }</span></span>
        }</span></span>
        </span></span>
        return</span> popStack</span>.</span>peek</span>(</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> boolean</span> empty</span>(</span>)</span> {</span></span>
        return</span> popStack</span>.</span>isEmpty</span>(</span>)</span> &&</span> pushStack</span>.</span>isEmpty</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span>
</span>
/**</span></span>
 * Your MyQueue object will be instantiated and called as such:</span></span>
 * MyQueue obj = new MyQueue();</span></span>
 * obj.push(x);</span></span>
 * int param_2 = obj.pop();</span></span>
 * int param_3 = obj.peek();</span></span>
 * boolean param_4 = obj.empty();</span></span>
 */</span></span>
//</span>leetcode submit region end(Prohibit modification and deletion)</span></span></code></pre>


leetcode 155 最小栈
2022-09-24T10:22:00+08:00
155. 最小栈</a></h1>
题目</h2>
设计一个支持 push</code> ，pop</code> ，top</code> 操作，并能在常数时间内检索到最小元素的栈。</p>
实现 MinStack</code> 类:</p>

MinStack()</code> 初始化堆栈对象。</li>
void push(int val)</code> 将元素val推入堆栈。</li>
void pop()</code> 删除堆栈顶部的元素。</li>
int top()</code> 获取堆栈顶部的元素。</li>
int getMin()</code> 获取堆栈中的最小元素。</li>
</ul>
示例 1:</strong></p>
输入：</span></span>
["MinStack","push","push","push","getMin","pop","top","getMin"]</span></span>
[[],[-2],[0],[-3],[],[],[],[]]</span></span>
</span>
输出：</span></span>
[null,null,null,null,-3,null,0,-2]</span></span>
</span>
解释：</span></span>
MinStack minStack = new MinStack();</span></span>
minStack.push(-2);</span></span>
minStack.push(0);</span></span>
minStack.push(-3);</span></span>
minStack.getMin();   --> 返回 -3.</span></span>
minStack.pop();</span></span>
minStack.top();      --> 返回 0.</span></span>
minStack.getMin();   --> 返回 -2.</span></span></code></pre>
提示：</strong></p>

-231 <= val <= 231 - 1</code></li>
pop</code>、top</code> 和 getMin</code> 操作总是在 非空栈</strong> 上调用</li>
push</code>, pop</code>, top</code>, and getMin</code>最多被调用 3 * 104</code> 次</li>
</ul>
解题思路</h2>
可使用双栈实现，一个正常存储数据（stackData），一个每次将最小值压到栈顶（stackMin）。如依次将 3、4、5、1、2、1 压入</p>
</p>
题解</h2>
因题目描述了 pop</code>、top</code> 和 getMin</code> 操作总是在 非空栈</strong> 上调用，所以这里没有进行非空判断。</p>
import</span> java</span>.</span>util</span>.</span>Stack</span>;</span></span>
</span>
class</span> MinStack</span> {</span></span>
</span>
    private</span> Stack</span><</span>Integer</span>></span> stackData</span>;</span></span>
    private</span> Stack</span><</span>Integer</span>></span> stackMin</span>;</span></span>
    </span></span>
    public</span> MinStack</span>(</span>)</span> {</span></span>
        stackData </span>=</span> new</span> Stack</span><</span>></span>(</span>)</span>;</span></span>
        stackMin </span>=</span> new</span> Stack</span><</span>></span>(</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> void</span> push</span>(</span>int</span> val</span>)</span> {</span></span>
        stackData</span>.</span>push</span>(</span>val</span>)</span>;</span></span>
</span>
        if</span> (</span>stackMin</span>.</span>isEmpty</span>(</span>)</span> ||</span> val </span><=</span> stackMin</span>.</span>peek</span>(</span>)</span>)</span> {</span></span>
            stackMin</span>.</span>push</span>(</span>val</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
    </span></span>
    public</span> void</span> pop</span>(</span>)</span> {</span></span>
        Integer</span> data</span> =</span> stackData</span>.</span>pop</span>(</span>)</span>;</span></span>
      </span></span>
        //</span> 此处注意用 equals 而不是 ==</span></span>
        if</span> (</span>stackMin</span>.</span>peek</span>(</span>)</span>.</span>equals</span>(</span>data</span>)</span>)</span> {</span></span>
            stackMin</span>.</span>pop</span>(</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
    </span></span>
    public</span> int</span> top</span>(</span>)</span> {</span></span>
        return</span> stackData</span>.</span>peek</span>(</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    public</span> int</span> getMin</span>(</span>)</span> {</span></span>
        return</span> stackMin</span>.</span>peek</span>(</span>)</span>;</span></span>
    }</span></span>
}</span></span>
</span></code></pre>


谈裸辞和开源的体会
2022-09-01T21:01:00+08:00
分享下最近几个月裸辞或做开源项目的经历和感悟。</p>
个人情况</h2>
我是 98 年，专科学历，学的 Java 。今年六月底从上家公司离职了，前公司是基于一套半低代码平台做外包的小公司，从 18 年毕业后 9 月份入职至今年六月，已经成了公司算"厉害"的人了，前端、后端、运维、售前等各种工作都做过。</p>
不过一直埋着一些心思，一是公司的技术栈太老了（ struts2 、spring 3.x 、hibernate 、...），二是我才这个年龄，在公司竟然已经是技术算很好的了，对我来说没有更多的上升空间了，每天就是处理各个项目上的杂事，实在是不甘心。虽说可以自学，但自学和项目实战还是有很大差别的。</p>
也和公司老板谈过离职，说起来可笑，共提了三次离职，前两次都被饼给填下了，最后的导火索是在一个耗了好几年的项目上，每天处于极度的负面情绪中，实在心理防线绷不住了，就毅然的提了离职，说什么也不留下了，直到六月底正式离职。</p>
开源</h2>
我还有一个从 19 年底开始写的开源项目，平时因为工作繁忙，有不少问题没改，还有鸽了大半年的需求。就决定离职后休息四个月，前两个月写开源项目，并写出一个捐赠版来维持基本生活。后两个月突击学习刷题，国庆后开始找工作。</p>
项目用时两个月完全重构并正式发版，期间申请了软著，捐赠版也随之一起发售，并提供了较为宽松的授权绑定方式，正式发布后就开始有大量用户使用，也提出了很多问题，修改 bug 修改了一两周。</p>
心得（仅代表个人观点，欢迎指正）：</p>

开源的项目要尽可能减少初始化配置，并提供引导性的设计来避免用户首次使用的成功率，这很重要。</li>
文档要完善，并及时更新并发现错误，因为可能你文档上你的一个小小的错误，就会错误的额外消耗使用者很多的时间。</li>
虽然文档要完善，但引用《黑客与画家》里的一句话: "你要明白，用户第一次使用你的软件的时候，不会预先做好功课，他们没有任何准备就开始用了，所以软件使用方式最好能符合用户的直觉，别指望用户去读操作手册"</li>
要提供程序的自动化程度，包括编码，编译或其他工作，一旦发现有多次重复且繁琐的动作，就应当考虑是否可以自动化处理，人总是会犯错的，自动化可以减少犯错的几率</li>
开源不易，绝大多数的开源项目都是没有任何收入且长期维护的，这需要很多耐心和坚持。有一次听《开源面对面</a>》里的一个开源作者，对我影响深刻的的是说：小白很多，很多人的开源项目使用者甚至都不是计算机相关领域的，所以也不能对他们要求太多，比如必须使用英文提 issue ；提供完整的错误信息，环境信息，操作步骤等；且这位作者还会去主动使用社工手段找提 issues 的人的联系方式，使用远程操作或远程会议的形式帮使用者解答和处理问题。</li>
谈谈收入，捐赠版已经发售正好一个月，除去支付平台手续费，服务器费用，净收入只有 7k+，这相对于工作的收入来说很少，而且和正式工作占用的时间差不多，从早上九点起床开始写到晚上九点休息。</li>
</ol>
原本计划两个月做开源，两个月学习，到今天为止已经做了开源整三个月，计划有点超出预期，但并不后悔，如果再选择一次，还是会选择离职并这么做，甚至会更早的提出离职。</p>
裸辞和生活</h2>

身体：在辞职前，有两三个月吃中药的经历，气阴两虚证，医生说这是操心太多，想太多导致的，这也是选择裸辞的原因之一吧。离职后中药也断了，身体感觉也好多了。</li>
焦虑：前两个月没有对裸辞或找工作这件事干到焦虑，不过最近开始有些焦虑了，因为时间上有点超出了计划，而且后年有结婚的打算，要赚钱买房，虽然女朋友很支持我的这些选择，但我还是不愿拖太久。</li>
技能：离职后有时间，学会了做饭，虽然做的不好，但也算一个傍身的技能。</li>
裸辞：如果你是顶梁柱，或者是家里的主要收入来源，还是不建议裸辞，风险很大。如果你是个还没成家立业且有自己想法，不甘于现状的，认真权衡利弊后可以选择裸辞，但要做好计划，准备好生活所需的钱。</li>
</ul>
说了很多，又好像什么都没说。希望大家都可以有机会脱离自己的小世界去外面看看</p>


leetcode 205 同构字符串
2022-08-30T19:00:12+08:00
205. 同构字符串</a></h1>
题目</h2>
给定两个字符串 s</code> 和 t</code> ，判断它们是否是同构的。</p>
如果 s</code> 中的字符可以按某种映射关系替换得到 t</code> ，那么这两个字符串是同构的。</p>
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。</p>
示例 1:</strong></p>
输入：s = "egg", t = "add"</span></span>
输出：true</span></span></code></pre>
示例 2：</strong></p>
输入：s = "foo", t = "bar"</span></span>
输出：false</span></span></code></pre>
示例 3：</strong></p>
输入：s = "paper", t = "title"</span></span>
输出：true</span></span></code></pre>
提示：</strong></p>

1 <= s.length <= 5 * 104</code></li>
t.length == s.length</code></li>
s</code> 和 t</code> 由任意有效的 ASCII 字符组成</li>
</ul>
题解1</h2>
自己想的解法，就是一个 map，存储映射关系，循环遍历每个元素，分别设 s 和 t 的每个元素为 a 和 b</p>

如果映射表里 key 中不包含 a，且 value 中不包含 b，则写入映射表。</li>
如果映射表里 key 中包含 a，则将映射值赋值为 a，并比较是否一致，如果不一致，直接返回 false。</li>
如果映射表里 key 中不包含 a，但 value 中包含 b，则说明 a 之前映射为 b，现在又映射成其他的了，直接返回 false。</li>
</ul>
时间复杂度 O(n)，空间复杂度 O(n).</p>
class</span> Solution</span> {</span></span>
    public</span> boolean</span> isIsomorphic</span>(</span>String</span> s</span>,</span> String</span> t</span>)</span> {</span></span>
        Map</span><</span>Character</span>,</span> Character</span>></span> mapping</span> =</span> new</span> HashMap</span><</span>></span>(</span>)</span>;</span></span>
</span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> s</span>.</span>length</span>(</span>)</span>;</span> i</span>++</span>)</span> {</span></span>
            char</span> a</span> =</span> s</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
            char</span> b</span> =</span> t</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
    </span></span>
            if</span> (</span>mapping</span>.</span>containsKey</span>(</span>a</span>)</span>)</span> {</span></span>
                if</span> (</span>mapping</span>.</span>get</span>(</span>a</span>)</span> !=</span> b</span>)</span> {</span></span>
                    return</span> false</span>;</span></span>
                }</span></span>
            }</span> else</span> if</span> (</span>mapping</span>.</span>containsValue</span>(</span>b</span>)</span>)</span> {</span></span>
                return</span> false</span>;</span></span>
            }</span> else</span> {</span></span>
                mapping</span>.</span>put</span>(</span>a</span>,</span> b</span>)</span>;</span></span>
                continue</span>;</span></span>
            }</span></span>
</span>
        }</span></span>
</span>
        return</span> true</span>;</span></span>
    }</span></span>
}</span></span></code></pre>题解 2</h2>
这个题解是在评论区找的，非常简洁的代码，另人敬佩。</p>
思路就是，获取当前元素所在的第一个 index 是否一样，如果不一样，则说明一定有某一个元素映射此处超过 1 次。精妙绝伦。 因每次都要 indexOf 从头遍历找，故时间复杂度为 O(n²)（实际情况没有这么差，且可以利用缓存避免每次都查），空间复杂度 O(1)</p>
class</span> Solution</span> {</span></span>
    public</span> boolean</span> isIsomorphic</span>(</span>String</span> s</span>,</span> String</span> t</span>)</span> {</span></span>
          for</span>(</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> s</span>.</span>length</span>(</span>)</span>;</span> i</span>++</span>)</span>{</span></span>
              if</span>(</span>s</span>.</span>indexOf</span>(</span>s</span>.</span>charAt</span>(</span>i</span>)</span>)</span> !=</span> t</span>.</span>indexOf</span>(</span>t</span>.</span>charAt</span>(</span>i</span>)</span>)</span>)</span>{</span></span>
                  return</span> false</span>;</span></span>
              }</span></span>
          }</span>  </span></span>
          return</span> true</span>;</span></span>
    }</span></span>
}</span></span></code></pre>题解 3</h2>
对题解 2 优化后（缓存了 index）时间复杂度 O(n)，空间复杂度 O(1)：</p>
class</span> Solution</span> {</span></span>
    public</span> boolean</span> isIsomorphic</span>(</span>String</span> s</span>,</span> String</span> t</span>)</span> {</span></span>
      int</span>[</span>]</span> cnt1</span> =</span> new</span> int</span>[</span>127</span>]</span>;</span></span>
      int</span>[</span>]</span> cnt2</span> =</span> new</span> int</span>[</span>127</span>]</span>;</span></span>
      for</span>(</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> s</span>.</span>length</span>(</span>)</span>;</span> i</span>++</span>)</span> {</span></span>
        char</span> a</span> =</span> s</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
        char</span> b</span> =</span> t</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
        int</span> aa</span> =</span> cnt1</span>[</span>a</span>]</span>;</span></span>
        int</span> bb</span> =</span> cnt2</span>[</span>b</span>]</span>;</span></span>
</span>
        if</span> (</span>aa </span>==</span> 0</span> &&</span> bb </span>==</span> 0</span>)</span> {</span></span>
          cnt1</span>[</span>a</span>]</span> =</span> i</span>;</span></span>
          cnt2</span>[</span>b</span>]</span> =</span> i</span>;</span></span>
          aa </span>=</span> s</span>.</span>indexOf</span>(</span>a</span>)</span>;</span></span>
          bb </span>=</span> t</span>.</span>indexOf</span>(</span>b</span>)</span>;</span></span>
        }</span></span>
        if</span> (</span>aa </span>!=</span> bb</span>)</span> {</span></span>
          return</span> false</span>;</span></span>
        }</span></span>
      }</span></span>
      return</span> true</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


leetcode 392 判断子序列
2022-08-30T18:58:00+08:00
392. 判断子序列</a></h1>
题目</h2>
给定字符串 s</strong> 和 t</strong> ，判断 s</strong> 是否为 t</strong> 的子序列。</p>
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"</code>是"abcde"</code>的一个子序列，而"aec"</code>不是）。</p>
进阶：</strong></p>
如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？</p>
致谢：</strong></p>
特别感谢 @pbrother </a>添加此问题并且创建所有测试用例。</p>
示例 1：</strong></p>
输入：s = "abc", t = "ahbgdc"</span></span>
输出：true</span></span></code></pre>
示例 2：</strong></p>
输入：s = "axc", t = "ahbgdc"</span></span>
输出：false</span></span></code></pre>
提示：</strong></p>

0 <= s.length <= 100</code></li>
0 <= t.length <= 10^4</code></li>
两个字符串都只由小写字符组成。</li>
</ul>
题解 1</h2>
声明 lastIndex 为最后一个存在的元素，遍历 s 的每个元素计为 a</p>

从 lastIndex 开始从 t 中找，包含 a 时，则继续循环。</li>
不包含，则表示不是子序列，直接返回。</li>
</ul>
时间复杂度 O(n)，空间复杂度 O(1)</p>
class</span> Solution</span> {</span></span>
    public</span> boolean</span> isSubsequence</span>(</span>String</span> s</span>,</span> String</span> t</span>)</span> {</span></span>
        int</span> lastIndex</span> =</span> 0</span>;</span></span>
        </span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> s</span>.</span>length</span>(</span>)</span>;</span> i</span>++</span>)</span> {</span></span>
            char</span> a</span> =</span> s</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
            int</span> index</span> =</span> t</span>.</span>indexOf</span>(</span>a</span>,</span> lastIndex</span>)</span>;</span></span>
            if</span> (</span>index </span>==</span> -</span>1</span>)</span> {</span></span>
                return</span> false</span>;</span></span>
            }</span> else</span> {</span></span>
                lastIndex </span>=</span> index </span>+</span> 1</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> true</span>;</span></span>
    }</span></span>
}</span></span></code></pre>题解 2</h2>
这是动态规划的解法，等学到动态规划再看。 https://leetcode.cn/problems/is-subsequence/solution/pan-duan-zi-xu-lie-by-leetcode-solution/</p>
class</span> Solution</span> {</span></span>
    public</span> boolean</span> isSubsequence</span>(</span>String</span> s</span>,</span> String</span> t</span>)</span> {</span></span>
        int</span> n</span> =</span> s</span>.</span>length</span>(</span>)</span>,</span> m </span>=</span> t</span>.</span>length</span>(</span>)</span>;</span></span>
</span>
        int</span>[</span>]</span>[</span>]</span> f</span> =</span> new</span> int</span>[</span>m </span>+</span> 1</span>]</span>[</span>26</span>]</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> 26</span>;</span> i</span>++</span>)</span> {</span></span>
            f</span>[</span>m</span>]</span>[</span>i</span>]</span> =</span> m</span>;</span></span>
        }</span></span>
</span>
        for</span> (</span>int</span> i</span> =</span> m </span>-</span> 1</span>;</span> i </span>>=</span> 0</span>;</span> i</span>--</span>)</span> {</span></span>
            for</span> (</span>int</span> j</span> =</span> 0</span>;</span> j </span><</span> 26</span>;</span> j</span>++</span>)</span> {</span></span>
                if</span> (</span>t</span>.</span>charAt</span>(</span>i</span>)</span> ==</span> j </span>+</span> '</span>a</span>'</span>)</span></span>
                    f</span>[</span>i</span>]</span>[</span>j</span>]</span> =</span> i</span>;</span></span>
                else</span></span>
                    f</span>[</span>i</span>]</span>[</span>j</span>]</span> =</span> f</span>[</span>i </span>+</span> 1</span>]</span>[</span>j</span>]</span>;</span></span>
            }</span></span>
        }</span></span>
        int</span> add</span> =</span> 0</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> n</span>;</span> i</span>++</span>)</span> {</span></span>
            if</span> (</span>f</span>[</span>add</span>]</span>[</span>s</span>.</span>charAt</span>(</span>i</span>)</span> -</span> '</span>a</span>'</span>]</span> ==</span> m</span>)</span> {</span></span>
                return</span> false</span>;</span></span>
            }</span></span>
            add </span>=</span> f</span>[</span>add</span>]</span>[</span>s</span>.</span>charAt</span>(</span>i</span>)</span> -</span> '</span>a</span>'</span>]</span> +</span> 1</span>;</span></span>
        }</span></span>
        return</span> true</span>;</span></span>
    }</span></span>
}</span></span></code></pre>题解 3</h2>
二分法  https://labuladong.github.io/algo/4/33/133/</p>
boolean</span> isSubsequence</span>(</span>String</span> s</span>,</span> String</span> t</span>)</span> {</span></span>
    int</span> m</span> =</span> s</span>.</span>length</span>(</span>)</span>,</span> n </span>=</span> t</span>.</span>length</span>(</span>)</span>;</span></span>
    //</span> 对 t 进行预处理</span></span>
    ArrayList</span><</span>Integer</span>></span>[</span>]</span> index</span> =</span> new</span> ArrayList</span>[</span>256</span>]</span>;</span></span>
    for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> n</span>;</span> i</span>++</span>)</span> {</span></span>
        char</span> c</span> =</span> t</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
        if</span> (</span>index</span>[</span>c</span>]</span> ==</span> null</span>)</span> </span></span>
            index</span>[</span>c</span>]</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
        index</span>[</span>c</span>]</span>.</span>add</span>(</span>i</span>)</span>;</span></span>
    }</span></span>
    </span></span>
    //</span> 串 t 上的指针</span></span>
    int</span> j</span> =</span> 0</span>;</span></span>
    //</span> 借助 index 查找 s[i]</span></span>
    for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> m</span>;</span> i</span>++</span>)</span> {</span></span>
        char</span> c</span> =</span> s</span>.</span>charAt</span>(</span>i</span>)</span>;</span></span>
        //</span> 整个 t 压根儿没有字符 c</span></span>
        if</span> (</span>index</span>[</span>c</span>]</span> ==</span> null</span>)</span> return</span> false</span>;</span></span>
        int</span> pos</span> =</span> left_bound</span>(</span>index</span>[</span>c</span>]</span>,</span> j</span>)</span>;</span></span>
        //</span> 二分搜索区间中没有找到字符 c</span></span>
        if</span> (</span>pos </span>==</span> -</span>1</span>)</span> return</span> false</span>;</span></span>
        //</span> 向前移动指针 j</span></span>
        j </span>=</span> index</span>[</span>c</span>]</span>.</span>get</span>(</span>pos</span>)</span> +</span> 1</span>;</span></span>
    }</span></span>
    return</span> true</span>;</span></span>
}</span></span></code></pre>


leetcode 724 寻找数组的中心下标
2022-08-17T17:23:37+08:00
724. 寻找数组的中心下标</a></h1>
题目</h2>
给你一个整数数组 nums</code> ，请计算数组的 中心下标</strong> 。</p>
数组 中心下标</strong> 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。</p>
如果中心下标位于数组最左端，那么左侧数之和视为 0</code> ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。</p>
如果数组有多个中心下标，应该返回 最靠近左边</strong> 的那一个。如果数组不存在中心下标，返回 -1</code> 。</p>
示例 1：</strong></p>
输入：nums = [1, 7, 3, 6, 5, 6]</span></span>
输出：3</span></span>
解释：</span></span>
中心下标是 3 。</span></span>
左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，</span></span>
右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。</span></span></code></pre>
示例 2：</strong></p>
输入：nums = [1, 2, 3]</span></span>
输出：-1</span></span>
解释：</span></span>
数组中不存在满足此条件的中心下标。</span></span></code></pre>
示例 3：</strong></p>
输入：nums = [2, 1, -1]</span></span>
输出：0</span></span>
解释：</span></span>
中心下标是 0 。</span></span>
左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），</span></span>
右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。</span></span></code></pre>
提示：</strong></p>

1 <= nums.length <= 104</code></li>
-1000 <= nums[i] <= 1000</code></li>
</ul>
解题思路</h2>
设所有数字总和 total</code>，然后从左侧开始累加，设累加值为 sum</code>，如果 sum  * 2 + nums[i] === total</code> 则说明如果 i</code> 左右两侧值都是 sum</code></p>
题解1</h2>
时间复杂度 O(n)</code>，空间复杂度 O(1)</code></p>
class</span> Solution</span> {</span></span>
    public</span> int</span> pivotIndex</span>(</span>int</span>[</span>]</span> nums</span>)</span> {</span></span>
        int</span> total</span> =</span> 0</span>;</span></span>
        for</span>(</span>int</span> num</span> :</span> nums</span>)</span> {</span></span>
            total </span>+=</span> num</span>;</span></span>
        }</span></span>
</span>
        int</span> sum</span> =</span> 0</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> nums</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
            if</span> (</span>sum </span>*</span> 2</span> +</span> nums</span>[</span>i</span>]</span> ==</span> total</span>)</span> {</span></span>
                return</span> i</span>;</span></span>
            }</span></span>
            sum </span>+=</span> nums</span>[</span>i</span>]</span>;</span></span>
        }</span></span>
</span>
        return</span> -</span>1</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


leetcode 1480 一维数组的动态和
2022-08-17T17:22:57+08:00
1480. 一维数组的动态和</a></h1>
题目</h2>
给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。</p>
请返回 nums 的动态和。</p>
示例 1：</p>
输入：nums = [1,2,3,4]</span></span>
输出：[1,3,6,10]</span></span>
解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。</span></span></code></pre>
示例 2：</p>
输入：nums = [1,1,1,1,1]</span></span>
输出：[1,2,3,4,5]</span></span>
解释：动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。</span></span></code></pre>
示例 3：</p>
输入：nums = [3,1,2,10,1]</span></span>
输出：[3,4,6,16,17]</span></span></code></pre>解题思路</h2>
这道题和斐波那契数列有点像，数组 nums</code>，返回的动态和 result</code>，当前数组下标为 i</code>，那么当 i == 0</code> 时 result[0] = nums[0]</code>，当 i >= 1</code> 时 result[i] = nums[i] + result[i + 1]</code></p>
题解1 （自实现）</h2>
时间复杂度 O(n)</code>，空间复杂度 O(n)</code></p>
class</span> Solution</span> {</span></span>
    public</span> int</span>[</span>]</span> runningSum</span>(</span>int</span>[</span>]</span> nums</span>)</span> {</span></span>
        int</span>[</span>]</span> result</span> =</span> new</span> int</span>[</span>nums</span>.</span>length</span>]</span>;</span></span>
        for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> nums</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
            int</span> item</span> =</span> nums</span>[</span>i</span>]</span>;</span></span>
            if</span> (</span>i </span>==</span> 0</span>)</span> {</span></span>
                result</span>[</span>i</span>]</span> =</span> item</span>;</span></span>
            }</span> else</span> {</span></span>
                result</span>[</span>i</span>]</span> =</span> item </span>+</span> result</span>[</span>i </span>-</span> 1</span>]</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        return</span> result</span>;</span></span>
    }</span></span>
}</span></span></code></pre>题解 2 （官方示例）</h2>
时间复杂度 O(n)</code>，空间复杂度 O(1)</code>，这个解法是对输入数组进行原地操作，虽然节省了空间，但破坏了输入数值，实际开发中该方法不一定可行.</p>
class</span> Solution</span> {</span></span>
    public</span> int</span>[</span>]</span> runningSum</span>(</span>int</span>[</span>]</span> nums</span>)</span> {</span></span>
        for</span> (</span>int</span> i</span> =</span> 1</span>;</span> i </span><</span> nums</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
            nums</span>[</span>i</span>]</span> =</span> nums</span>[</span>i</span>]</span> +</span> nums</span>[</span>i </span>-</span> 1</span>]</span>;</span></span>
        }</span></span>
        return</span> nums</span>;</span></span>
    }</span></span>
}</span></span></code></pre>


ZFile 4.0.0 Bate 版本宝塔部署教程
2022-06-30T21:08:41+08:00
0. 前言</h2>
基础部署方式和之前一样，无变化，还是参考： https://docs.zfile.vip/#/install</p>
1. 安装 JDK</h2>
此处摘抄自 ZFile 文档</a>，如系统已安装 JDK</code> 可跳过此步骤.</p>
# CentOS系统</span></span>
yum install -y java-1.8.0-openjdk unzip</span></span>
</span>
# Debian/Ubuntu系统</span></span>
apt update</span></span>
apt install -y openjdk-8-jre-headless unzip</span></span></code></pre>2. 宝塔操作</h2>
</p>
3. 完成</h2>
如果填写了域名，访问域名即可（记得将域名指向服务），如果使用的是端口，则使用端口访问.</p>


通过 Github Actions 自动构建 ZFile 镜像并推送到 Docker Hub
2022-05-22T11:15:54+08:00
前言</h2>
上文</a> 提到 ZFile</code> 的 Docker</code> 镜像构建过程，不过需要手动在服务器上执行命令构建并推送，对服务器网络和配置都有一定要求。</p>
本文来介绍如何使用 Github Actions</code> 来自动构建并推送。</p>
创建 Github Actions 配置文件</h2>
在 github</code> 项目中 /.github/workflows/</code> 目录下创建文件 build.yml</code>，yml</code> 文件名称可以随意输入。</p>
n</span>ame</span>:</span> B</span>uild ZFile Docker Image And Push To Docker Hub</span>  #</span> workflow 的名字</span></span>
</span>
#</span>on: [push, pull_request] # push 和 pull_request 时会触发</span></span>
on</span>:</span></span>
  w</span>orkflow_dispatch</span>:</span>  #</span> 手动触发</span></span>
</span>
j</span>obs</span>:</span></span>
  d</span>ocker</span>:</span></span>
    n</span>ame</span>:</span> P</span>ublish Docker Image</span>   #</span> 任务名称</span></span>
    r</span>uns-on</span>:</span> u</span>buntu-18.04</span>        #</span> 执行环境</span></span>
    e</span>nv</span>:</span></span>
      R</span>EPO</span>:</span> $</span>{{ secrets.ENTITY_DOMAIN_REPO }}</span>   #</span> 推送到哪个 docker hub 仓库, 如 zhaojun1998/zfile</span></span>
</span>
    s</span>teps</span>:</span></span>
      -</span> n</span>ame</span>:</span> C</span>heckout</span>                  #</span> 检出代码</span></span>
        u</span>ses</span>:</span> a</span>ctions/checkout@v2</span></span>
</span>
      -</span> n</span>ame</span>:</span> S</span>et up QEMU</span>               #</span> 设置 QEMU 环境，用来模拟操作系统，用来编译 arm64 镜像和 amd64 镜像</span></span>
        u</span>ses</span>:</span> d</span>ocker/setup-qemu-action@v2</span></span>
        w</span>ith</span>:</span></span>
          p</span>latforms</span>:</span> a</span>ll</span></span>
</span>
      -</span> n</span>ame</span>:</span> S</span>et up Docker Buildx</span>      #</span> 设置 Docker Buildx 环境</span></span>
        i</span>d</span>:</span> b</span>uildx</span></span>
        u</span>ses</span>:</span> d</span>ocker/setup-buildx-action@v2</span></span>
        w</span>ith</span>:</span></span>
          v</span>ersion</span>:</span> l</span>atest</span></span>
</span>
      -</span> n</span>ame</span>:</span> I</span>nspect builder</span>           #</span> 查看 builder 状态</span></span>
        r</span>un</span>:</span> |</span></span>
          echo "Name:      ${{ steps.buildx.outputs.name }}"</span></span>
          echo "Endpoint:  ${{ steps.buildx.outputs.endpoint }}"</span></span>
          echo "Status:    ${{ steps.buildx.outputs.status }}"</span></span>
          echo "Flags:     ${{ steps.buildx.outputs.flags }}"</span></span>
          echo "Platforms: ${{ steps.buildx.outputs.platforms }}"</span></span>
</span>
      -</span> n</span>ame</span>:</span> L</span>ogin to Docker Registry</span>   #</span> 登录到 Docker Registry</span></span>
        r</span>un</span>:</span> e</span>cho '${{ secrets.DOCKERHUB_PASS }}' | docker login -u ${{ secrets.DOCKERHUB_USER }} --password-stdin</span></span>
</span>
      -</span> n</span>ame</span>:</span> B</span>uild Docker Image</span>         #</span> 编译镜像并推送，在--platform后面指定需要兼容的平台列表</span></span>
        r</span>un</span>:</span> d</span>ocker buildx build -t $REPO:latest --platform linux/amd64,linux/arm64 --push .</span></span></code></pre>配置变量</h2>
上方配置文件中所有 ${{ secrets.xxxx }}</code> 都是变量，这个需要在 Github</code> 仓库设置中配置，这样敏感信息，如账号密码，不用写在配置文件中，可以避免信息泄露。</p>
配置方式如图所示：</p>
</p>
触发 Actions</h2>
推送上方配置文件到登陆 Github</code> 仓库后，点击 Run workflow</code> 即可运行。
</p>
然后经过一两分钟等待后，查看日志，已经运行完成了，在 DockerHub</code> 上也能看生成的结果。</p>
</p>
</p>


ZFile Docker 镜像构建过程
2022-05-21T19:10:06+08:00
前言</h2>
下文提供 ZFile 镜像构建过程，供大家参考。</p>
Dockerfile</h2>
FROM</span> ibm-semeru-runtimes:open-8-jre</span></span>
</span>
WORKDIR</span> /root</span></span>
</span>
RUN</span> ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime</span></span>
RUN</span> echo </span>'</span>Asia/Shanghai</span>'</span> >/etc/timezone</span></span>
</span>
RUN</span> curl -o app.jar https://c.jun6.net/ZFILE/zfile-release.jar</span></span>
</span>
EXPOSE</span> 8080</span></span>
</span>
ENTRYPOINT</span> java $JAVA_OPTS -Xshareclasses -Xquickstart -jar /root/app.jar</span></span></code></pre>

FROM ibm-semeru-runtimes:open-8-jre</code> 表示使用的基础镜像，这里选中的这个是 ibm</code> 的 openj9</code> jdk8</code> 版本的 jre</code>，这个版本的 jdk 具有内存占用小，启动速度快等优势，且针对 docker</code>环境做过特殊优化。</li>
WORKDIR /root</code> 表示工作目录在 /root</code>，下方所有命令将在这个目录下执行</li>
RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime</code> 和 RUN echo 'Asia/Shanghai' >/etc/timezone</code> 表示设置时区为上海时间，这两个设置的区别参考：https://unix.stackexchange.com/questions/384971/whats-the-difference-between-localtime-and-timezone-files</li>
RUN curl -o app.jar https://c.jun6.net/ZFILE/zfile-release.jar</code> 表示下载 zfile</code> 最新版 jar</code> 包，并命名为 app.jar</code>，因为上方工作目录为 /root</code>，所以实际下载到了 /root/app.jar</code></li>
EXPOSE 8080</code> 表示容器可能会使用这个端口，这个只是声明或备注式的，不会实际影响端口情况。</li>
ENTRYPOINT java $JAVA_OPTS -Xshareclasses -Xquickstart -jar /root/app.jar</code> 表示启动 /root/app.jar</code>，其中 -Xshareclasses -Xquickstart</code> 是 ibm</code> 的 openj9 jvm</code> 的参数，用来优化内存占用。</li>
</ul>
build</h2>
由于需要同时支持 arm64</code> 架构和 amd64</code> 架构，所以使用的 docker</code> 的 多平台构建</a>，即同时 build</code> 多个架构的镜像。</p>

由于 Docker</code> 默认的 builder</code> 实例不支持同时指定多个 --platform</code>，我们必须首先创建一个新的 builder</code> 实例。</li>
</ol>
docker</span> buildx</span> create</span> -</span>-name</span> zfile-builder</span> -</span>-driver</span> docker-container</span></span></code></pre>

使用新创建好的 builder</code> 实例</li>
</ol>
docker</span> buildx</span> use</span> zfile-builder</span></span></code></pre>

查看已有的 builder</code> 支持构建的架构类型</li>
</ol>
docker</span> buildx</span> ls</span></span></code></pre>

安装模拟器（用于模拟其他平台的构建）</li>
</ol>
docker</span> run</span> -</span>-privileged</span> -</span>-rm</span> tonistiigi/binfmt</span> -</span>-install</span> all</span></span></code></pre>

在 Dockerfile</code> 所在目录执行构建命令并 push</code> 到 docker hub</code> (需提前 docker login</code> 账号)</li>
</ol>
docker</span> buildx</span> build</span> -</span>-platform</span> linux/arm64,linux/amd64</span> -</span>t</span> zhaojun1998/zfile:latest</span> -</span>-push</span> .</span></span></code></pre>结语</h2>
然后在 docker hub</code> 就可以看到推送的镜像了。</p>
</p>
后续还会更新如何使用 CI</code> 工具自动化构建镜像的方式。</p>


优化 Java 项目 Docker 镜像内存占用从 500 M 到 100M
2022-05-19T22:51:14+08:00
前言</h2>
因开发了一个开源项目 ZFile</a>，提供 Docker 版本，最初构建镜像时，使用的是 alpine</a> 因为大小只有 5MB</code>，然后在此基础上，添加了 jdk</code>、wget</code>、unzip</code> 等包，最终打包为 alpine-java</a> 大小为 108MB</code>，但实际运行内存占用会在 400m</code> - 600m</code> 之间，还挺占内存的。</p>
经过搜索发现 openj9</code> 比较省内存，下面是 Dockerfile</code>示例 和运行内存占用对比。</p>
Dockerfile</h2>
alpine-java</h3>
FROM</span> zhaojun1998/alpine-java</span></span>
</span>
WORKDIR</span> /root</span></span>
</span>
RUN</span> ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime</span></span>
RUN</span> echo </span>'</span>Asia/Shanghai</span>'</span> >/etc/timezone</span></span>
</span>
RUN</span> wget -O app.jar https://c.jun6.net/ZFILE/zfile-release.jar</span></span>
</span>
EXPOSE</span> 8080</span></span>
</span>
ENTRYPOINT</span> java $JAVA_OPTS -jar /root/app.jar</span></span></code></pre>openj9</h3>
FROM</span> ibm-semeru-runtimes:open-8-jre</span></span>
</span>
WORKDIR</span> /root</span></span>
</span>
RUN</span> ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime</span></span>
RUN</span> echo </span>'</span>Asia/Shanghai</span>'</span> >/etc/timezone</span></span>
</span>
RUN</span> curl -o app.jar https://c.jun6.net/ZFILE/zfile-release.jar</span></span>
</span>
EXPOSE</span> 8080</span></span>
</span>
ENTRYPOINT</span> java $JAVA_OPTS -Xshareclasses -Xquickstart -jar /root/app.jar</span></span></code></pre>镜像大小比较</h2>
根据上方的 Dockerfile</code> 进行构建，通过 docker images</code> 命令查看镜像大小，对比结果如下：</p>
alpine-java</code> 版本镜像大小为: 108MB</code></p>
openj9</code> 版本镜像大小为: 321MB</code></p>
可以看出 alpine</code> 系列镜像在镜像大小上还是占绝对优势的。</p>
内存占用比较</h2>
通过 docker stats</code> 命令查看运行中的 docker</code> 容器内存占用情况如下：</p>
alpine-java</code> 版本镜像：刚运行占用内存 350m-450m</code>左右，过一会能占用到 520m</code>，我的演示站因运行时间比较长，占用到了 663m</code> 内存。</p>
openj9</code> 版本镜像：刚运行占用内存在 90m-100m</code> 左右，过一会能占用 110m-120m</code> 左右，较长时间的运行还没来得及测试。</p>
由此可以看出 openj9</code> 在内存占用上占用降低了好几倍。</p>
openj9 介绍</h2>
对比完，我们来看看 openj9</code> 到底是什么来头，其实他是 IBM J9 JVM</code> 贡献给 Eclipse</code> 基金会后改名为 OpenJ9</code> ，现继续由 IBM</code> 接管，可以从 openj9</code> 官网查看详细信息：https://www.eclipse.org/openj9/</p>
openj9</code> 针对云环境和 Docker</code> 运行环境进行了优化，并提升了启动速度，降低内存占用。详细性能对比见官方示例：https://www.eclipse.org/openj9/performance</p>


Spring 如何获取 AOP 代理类的实际对象 Class
2022-05-17T08:52:40+08:00
在使用 Spring</code> 时，如果对某个 Spring Bean</code> (下文简称 Bean</code></em>) 使用了 AOP，那么调用 bean.getClass()</code>时获取到的是代理对象，当我们想对 Bean</code> 做一些反射操作时，使用代理对象是会出错的。Spring AOP</code> 包中提供了一个工具类可以获取到原始对象的 Class: AopUtils.getTargetClass</code></p>
如有 Bean</code>:</p>
@</span>Service</span></span>
public</span> class</span> UserService</span> {</span></span>
</span>
	public</span> void</span> test</span>(</span>)</span> {</span></span>
		System</span>.</span>out</span>.</span>println</span>(</span>"</span>test</span>"</span>)</span>;</span></span>
	}</span></span>
</span>
}</span></span></code></pre>
AOP 切面：</p>
@</span>Aspect</span></span>
@</span>Component</span></span>
public</span> class</span> MyAop</span> {</span></span>
</span>
    /**</span></span>
     * 切入点</span></span>
     */</span></span>
    @</span>Pointcut</span>(</span>"</span>execution(public * im.zhaojun.blog.code.service.*.*(..))</span>"</span>)</span></span>
    public</span> void</span> pointcut</span>(</span>)</span>{</span></span>
    }</span></span>
</span>
    /**</span></span>
     * 前置通知</span></span>
     */</span></span>
    @</span>Before</span>(</span>"</span>pointcut()</span>"</span>)</span></span>
    public</span> void</span> deBefore</span>(</span>JoinPoint</span> jp</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>before</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
}</span></span></code></pre>
测试类：</p>
@</span>SpringBootTest</span></span>
class</span> BlogCodeDemoApplicationTests</span> {</span></span>
</span>
	@</span>Resource</span></span>
	private</span> UserService</span> userService</span>;</span></span>
</span>
	@</span>Test</span></span>
	void</span> contextLoads</span>(</span>)</span> {</span></span>
		Class</span><</span>?</span> extends</span> UserService</span>></span> proxyServiceClass</span> =</span> userService</span>.</span>getClass</span>(</span>)</span>;</span></span>
		Class</span><</span>?</span>></span> serviceClass</span> =</span> AopUtils</span>.</span>getTargetClass</span>(</span>userService</span>)</span>;</span></span>
		System</span>.</span>out</span>.</span>println</span>(</span>"</span>代理类：</span>"</span> +</span> proxyServiceClass</span>)</span>;</span></span>
		System</span>.</span>out</span>.</span>println</span>(</span>"</span>实际类：</span>"</span> +</span> serviceClass</span>)</span>;</span></span>
</span>
		System</span>.</span>out</span>.</span>println</span>(</span>"</span>代理类方法个数：</span>"</span> +</span> proxyServiceClass</span>.</span>getMethods</span>(</span>)</span>.</span>length</span>)</span>;</span></span>
		System</span>.</span>out</span>.</span>println</span>(</span>"</span>实际类方法个数：</span>"</span> +</span> serviceClass</span>.</span>getMethods</span>(</span>)</span>.</span>length</span>)</span>;</span></span>
	}</span></span>
</span>
}</span></span></code></pre>
输出为, 经测试结果可见，如果想要对 AOP</code> 后的 Bean</code> 进行反射，需要使用原始对象:</p>
代理类：class im.zhaojun.blog.code.service.UserService$$EnhancerBySpringCGLIB$$a0f386db</span></span>
实际类：class im.zhaojun.blog.code.service.UserService</span></span>
代理类方法个数：44</span></span>
实际类方法个数：10</span></span></code></pre>
</p>


页面动态添加 JS，并监听加载完毕事件
2022-05-02T14:55:00+08:00
有时会遇到一些需要动态引入 js</code> 
                }</span>    }</span>                }</span>         }</span>    }</span></s  }</span></span> </span> </span> }</span>)< 
  MySQL 学习 04 - 索引
 2022-05-02T14:52:02+08:00

的情况，且加载完毕后，需要使用 js</code> 中的方法或变量，但因为加载需要时间，需要等加载 js</code> 脚本加载完毕后才能使用，故找到以下方法，可以动态加载 js</code> 脚本，并监听加载完毕事件。</p> class="giallo-l">function</span> loadScript</span>(</span>src</span>,</span> callback</span>)</span> {</span></span> var</span> script</span> =</span> document</span>.</span>createElement</span>(</span>'</span>script</span>'</span>)</span>,</span></span> head</span> =</span> document</span>.</span>getElementsByTagName</span>(</span>'</span>head</span>'</span>)</span>[</span>0</span>]</span>;</span></span> script</span>.</span>type</span> =</span> '</span>text/javascript</span>'</span>;</span></span> script</span>.</span>charset</span> =</span> '</span>UTF-8</span>'</span>;</span></span> script</span>.</span>src</span> =</span> src</span>;</span></span> if</span> (</span>script</span>.</span>addEventListener</span>)</span> {</span></span> script</span>.</span>addEventListener</span>(</span>'</span>load</span>'</span>,</span> function</span> (</span>)</span> {</span></span> callback</span>(</span>)</span>;</span></span> n>,</span> false</span>)</span>;</span></span> class="z-keyword"> else</span> if</span> (</span>script</span>.</span>attachEvent</span>)</span> {</span></span> script</span>.</span>attachEvent</span>(</span>'</span>onreadystatechange</span>'</span>,</span> function</span> (</span>)</span> {</span></span> var</span> target</span> =</span> window</span>.</span>event</span>.</span>srcElement</span>;</span></span> if</span> (</span>target</span>.</span>readyState</span> ==</span> '</span>loaded</span>'</span>)</span> {</span></span> callback</span>(</span>)</span>;</span></span> </span> n>)</span>;</span></span> pan> head</span>.</span>appendChild</span>(</span>script</span>)</span>;</span></span> z-name">loadScript</span>(</span>'</span>https://xxx.example.com/jquery.js</span>'</span>,</span> function</span> (</span>)</span> {</span></span> F;span>;</span></span></code></pre>

索引</h1>
数据库的索引是一个要点, 无论是面试还是在工作中, 这个知识点都很常会用到, 你可能只是用过索引, 知道加了索引可以提高查询的性能, 但不知道为什么这样, 今天我们一起来详细了解下吧.</p>
索引模型</h2>
索引有很多种存储结构, 称之为索引模型, 不同类型的模型分别对应不同的适用场景.</p>
哈希表</h3>
哈希表是一种以键值对存储数据的结构 KEY - VALUE</code>. 查找时输入 key</code> 来查找对应点 value</code>.</p>
哈希表的思路很简单, 将值放置到数组中. 如定义一个长度为 16 的数组, 输入 key</code>: user1</code>, 对 user1</code> 做哈希运算 (利用哈希函数), 返回一个整数, 如 2156648</code>, 用这个数对 16 取余, 返回值为 8. 那么就将他放到数组的第 8 个位置.</p>
你可能会有下面的疑惑:</p>

哈希函数又是什么: 哈希函数的意图就是把任何长度输入值, 变化成固定长度的输出, 一般为整数.</li>
哈希值会冲突么, 冲突了怎么办: 会冲突, 冲突了有许多中解决方式, 今天我讲一种比较常用的, 即在数组中不直接存放数据值, 而是存放一个链表, 当冲突时, 就把多个值通过链表串联起来. 类似于 Java 中 HashMap</code> 的存储方式.</li>
</ul>

总结: 适合用于等值查询</strong>, 不适用于范围查询. 出现大量哈希冲突的情况后, 查询效率会很低.</p>
</blockquote>
有序数组</h3>
这个就更简单了, 将所有值从小到大排序, 这样查找时, 可以采用二分法, 时间复杂度只有 O(logN)</code>. 而且对范围查询的支持也非常好, 先根据二分法, 找到范围查询的左值, 然后依次遍历数组到范围查询的右值即可.</p>
但这仅仅是查询效率很好, 但向数组中心插入值就麻烦了, 如现有数据 [1, 5, 8, 10, 11, 13]</code>, 现在要插入数据值 3</code>, 那么就要将 5, 8, 10, 11, 13</code> 这些值都向后移动一位, 插入操作的效率为 O(N)</code>, 这并不是一个理想的效率.</p>

适用于范围查询. 等值查询的效率也较高, 但插入操作效率较低.</p>
</blockquote>
搜索树</h3>
二叉搜索树</h4>
二叉搜索树的特点是: 每个节点的左儿子小于父节点, 父节点又小于右儿子. 如:</p>
</span></code></pre>5</span></span>
  / \</span></span>
3    6</span></span></code></pre>
/ \

2   4    8
/        / 

1        7   9</p>
这是如果你找值 7, 先从根节点 5 开始找, 比 5 大, 那肯定在右边, 所以找到第二层的 6, 比 6 还大, 找到第三次的 8, 比 8 小, 最后找到第四层的 7, 这样最坏的情况也就数据在树的最后一层, 即**平均时间复杂度**为 `O(logN)`.</span></span>
</span>
#### 平衡二叉树 (红黑树)</span></span>
</span>
但是二叉搜索树还可能会出现一个问题是树不平衡, 如:</span></span></code></pre>
1
2
3
4
5
6
7
8
9</p>
上面我们提高二叉搜索树的查询性能取决于树的高度, 现在这个数查询的性能变成了 O(N), 性能大打折扣. 为了解决这个问题, 提出了 `红黑树` 的概念. 他是一种自平衡的二叉搜索树, 即在插入节点时, 判断整个树是否是平衡的, 如果不平衡, 通过一系列旋转操作来达到平衡的目的, 在更新时维持树的平衡需要的时间复杂度也是 `O(logN)`.</span></span>
</span>
> 红黑树的篇幅有点长, 不太适合放到这里, 需要详细了解的朋友, 可自行查阅相关知识.</span></span>
</span>
#### N 叉树 (B 树, B+ 树)</span></span>
</span>
同样的, 平衡二叉树也有一个问题, 如当数据有 100 条时, 此时树的高度为 20, 那么一次查询可能需要访问 20 个数据块, 也就是访问 20 次磁盘, 这是不能被接受的, 尤其是在机械硬盘下, 为了让一个查询更少的读取磁盘, 我们就不应该使用二叉树, 而是 N 叉树, 这个 N 取决于数据块的大小.</span></span>
</span>
以 InnoDB 的一个整数字段索引为例, 这个 N 差不多是 1200, 当树高为 4 时, 可以存储 1200 的三次方个值, 大约为 17 亿, 那么这样访问磁盘的次数就大大减少了.</span></span>
</span>
> InnoDB 中的 B+ 树, 就是 N 叉树的一种实现.</span></span>
</span>
## InnoDB 存储模型</span></span>
</span>
在 InnoDB 中, 表是根据主键顺序以索引的形式存放的, InnoDB 存储模型采用了 B+ 树索引模型, **在 InnoDB 中每一个索引都对应着一颗 B+ 树**, 每棵非主键索引树的叶子节点存储的是主键的值, 每棵主键树的叶子节点存储的是整行数据值.</span></span>
</span>
假如, 我们有一个主键列为 ID 的表, 表中有字段 K, 并且在 K 上有索引, 建表语句如下:</span></span>
</span>
```sql</span></span>
create table T</span></span>
(</span></span>
    id int primary key, </span></span>
    k int not null, </span></span>
    name varchar(16),</span></span>
    index (k)</span></span>
) engine = InnoDB;</span></span></code></pre>
然后插入数据:</p>
insert into</span> T(id, k, </span>name</span>) </span>values</span>(</span>100</span>, </span>1</span>, </span>"</span>A</span>"</span>);</span></span>
insert into</span> T(id, k, </span>name</span>) </span>values</span>(</span>200</span>, </span>2</span>, </span>"</span>B</span>"</span>);</span></span>
insert into</span> T(id, k, </span>name</span>) </span>values</span>(</span>300</span>, </span>3</span>, </span>"</span>C</span>"</span>);</span></span>
insert into</span> T(id, k, </span>name</span>) </span>values</span>(</span>400</span>, </span>4</span>, </span>"</span>D</span>"</span>);</span></span>
insert into</span> T(id, k, </span>name</span>) </span>values</span>(</span>500</span>, </span>5</span>, </span>"</span>E</span>"</span>);</span></span>
insert into</span> T(id, k, </span>name</span>) </span>values</span>(</span>600</span>, </span>6</span>, </span>"</span>F</span>"</span>);</span></span></code></pre>
两个树的示意图如下:</p>
</p>
那么对于 主键索引和普通索引的查询有什么区别呢?</strong></p>
如查询语句 select * from T where ID = 500</code>, 即根据主键进行查询, 则只需要搜索 ID 索引树.</p>
如查询语句 select * from T where K = 5</code>, 即根据普通索引进行查询, 则需要先搜索 K 索引树, 得到 ID 值 500, 再到 ID 索引树搜索. 这个过程称之为回表</strong>.</p>
由于普通索引的叶子节点存储的是主键, 那么很显然, 主键长度越小越好, 所以自增主键是一个很好的选择.</p>
当然, 如果你自己有业务字段是唯一的, 且不需要其他索引, 那么使用业务字段来做主键会适合.</p>
覆盖索引</h2>
还是上面那个查询语句: select * from T where K = 5</code>, 上面我们他会进行 回表</strong> 操作.</p>
那么有没有可能经过索引优化, 不回表呢?</p>
如果执行的语句是: select ID from T where K = 5</code>, 这时只需要查找 ID 值, 而 ID 值已经在 k 索引树的叶子节点中了, 这样已经得到了需要的数据, 就不用进行 回表</strong> 操作了.</p>
在这个查询中, 索引 k 覆盖了我们需要查询的字段,  我们称之为 覆盖索引</strong>.</p>

由于覆盖索引可以减少树的搜索次数，显著提升查询性能，所以使用覆盖索引是一个常用的性能优化手段。</p>
</blockquote>
最左前缀索引</h2>
当然, 我们不能为所有需要查询的字段都建立上 索引</strong>, 那索引就太多了, 并且索引的维护成本也很大, 其实 B+ 树</strong> 这种索引结构, 支持最左前缀匹配, 来定位记录.</p>
如现在我们有 (name, age)</code> 这个联合索引 :</p>
</p>
可以看到, 索引已经按照定义中的顺序排序好了, name 在前, age 在后, 如果 name 一致, 按照 age 排序.</p>
此时我们需要查找所有姓名等于 "张三" 的人, 可以快速定位到 ID4, 然后向后遍历直到姓名不等于张三.</p>
那么如果你要查找的是所有姓名的第一个字等于 "张" 的人, 也可以快速定位到 ID3, 然后向后遍历直到不符合条件.</p>
同理, 如现在有联合索引 (name, age, score)</code>, 那么我们查询 where name = '%张' and age = 10</code> 也是用到了索引的, 但查询 where name = '%张' and score = 60</code>, 就没有完全用到这个索引.</p>
由此可知, 我们只要满足索引的最左前缀, 就可以用索引来加速检索, 这个最左前缀可以是联合索引的最左 N</code> 个字段, 也可以是字符串索引的前 M</code> 个字符.</p>
索引下推</h2>
上一段我们提到了最左前缀可以用来在索引中定位记录, 但如果不符合最左前缀的部分, 应该怎么办呢?</p>
还是以 (name, age)</code> 联合索引为例. 现在需要查询 "名字第一个字是张, 年龄为 10 的男孩", sql 示意如下:</p>
select</span> *</span> from</span> tuser </span>where</span> name</span> like</span> '</span>张%</span>'</span> and</span> age </span>=</span> 10</span> and</span> ismale </span>=</span> 1</span>;</span></span></code></pre>
再次附上索引结构图:</p>
</p>
这个索引只能用到 name 的前缀索引, 找到第一个满足条件的记录 ID3, 然后, 如何判断后面两个条件是否满足呢?</p>
在 MySQL 5.6 之前, 只能从 ID3 开始一个一个的回表, 到主键索引上找出数据行, 再比对字段值.</p>
而在 MySQL 5.6 引入了索引下推优化, 即在索引遍历过程中, 对索引中包含的字段</strong>先做判断, 先过滤到不符合条件的记录, 避免回表:</p>
无索引下推执行流程:
</p>
有索引下推执行流程:</p>
</p>
每个虚线表示回表一次, 在无索引下推图中, 我特意去掉了 age 值, 因为他不会看 age 的值, 只是按顺序把 name 第一个字是 "张" 的所有数据一个一个回表, 因此回表了 4 次.</p>
而在有索引下推时, InnoDB 在 (name, age)</code> 索引内部就判断了 age 是否等于 10, 对于不等于的, 直接跳过, 所以这里只回表了 2 次.</p>


MySQL 学习 03 - 初识 redo log 和 binlog
2022-05-02T14:51:31+08:00
redo log</h2>
InnoDB</code> 存储引擎是以页为单位</strong>来管理存储空间的, 我们的增删改查操作本质上都是在访问页面</strong>, 如读取一条数据, 会把这个数据所在的页</strong>加载到内存中, 而不仅仅是这条数据本身, 这个页的默认大小是 16KB</code>.</p>
在事务中, 我们有一个特性: 持久性</strong>, 指对于一个已提交的事务, 在事务提交后, 即使系统崩溃, 也要保证这个事务对数据库做的更改不会丢失, 那么我们如何保证这一点呢, 有一个简单粗暴的做法就是: 在事务提交之前, 将事务所修改的所有页面都刷新到磁盘</strong>, 但这种做法有几个问题:</p>

刷新一个数据页太浪费了, 可能我们只修改了这个数据页中的一个字节, 但 InnoDB</code> 所有操作都是基于页面的, 我们只修改一个字节就要刷新一个 16KB 的页到磁盘上台浪费了.</li>
随机 IO 刷起来比较慢, 一个事务可能包含了很多语句, 即使一条语句, 也可能修改了许多页面, 有可能修改的这些页面并不相邻, 那么这就需要进行很多次随机 IO, 这相对顺序 IO 来说很慢, 尤其对机械硬盘来说.</li>
</ul>
那么如何解决这个问题呢, InnoDB</code> 采用了 redo log</strong> 机制来解决:</p>


MySQL 学习 02 - 查询缓存
2022-05-02T14:51:07+08:00
MySQL 拿到一个查询请求后，会先看看之前有没有执行过这条语句，如果执行过，则直接从查询缓存中取之前查询的结果即可，但大多情况不建议使用 MySQL 的查询缓存，因为弊大于利</strong>。</p>
因为查询缓存的失效非常频繁，只要对一个表进行更新，那么这个表的所有查询缓存将会全部被清除，所以命中率并不会很好，除非你有一张静态的表，不会改变他的数据，或者很久才会更新一次。比如系统配置表，才适合使用这个查询缓存。</p>
还有一个原因是因为，现在有 Redis</code>, MemoryCache</code> 等专门用来做缓存的应用，他们对缓存的处理会更优，而且 MySQL 服务器的资源通常都比较宝贵，所以不推荐使用 MySQL 的查询缓存。</p>
查看查询缓存状态:</p>
show variables </span>like</span> '</span>%query_cache_type%</span>'</span>;</span></span></code></pre>
显式指定使用查询缓存:</p>
select</span> SQL_CACHE </span>*</span> FROM</span> user </span>where</span> ID </span>=</span> 10</span>;</span></span></code></pre>


MySQL 学习 01 - 连接
2022-05-02T14:50:47+08:00
进行连接</h2>
使用数据库的第一步是连接，连接命令为:</p>
mysql </span>-</span>u$username </span>-</span>h$host </span>-</span>P$port </span>-</span>p</span></span></code></pre>
然后输入密码就行了，不推荐在 -p</code> 的后面输入密码，会有安全问题。</p>


MySQL InnoDB 事务隔离级别的实现原理
2022-05-02T14:49:56+08:00
今天介绍下，在 MySQL</code> 的 InnoDB</code> 存储引擎中，事务隔离是如何实现的。</p>
InnoDB</code> 里面每个事务有一个唯一的事务 ID</code>，叫作 transaction id</code>。它是在事务开始的时候向 InnoDB</code> 的事务系统申请的，是按申请顺序严格递增的。</p>
对于数据库的每行记录，都会有三个隐藏字段：db_trx_id (事务 id)</code>、db_roll_pt (回滚指针)</code>、delete_flag(删除标记)</code>。— 有懂的朋友，还望别细纠，其实 delete_flag</code> 是在头信息中，这里是为了方便理解</em></p>
对于 DML</code> 操作来说：</p>

INSERT</strong>：创建一条数据，db_trx_id</code> 的值为当前事务 id</code>, db_roll_pt</code> 为 null</code> 。</li>
UPDATE</strong>：复制一行数据，将当前复制后这一行的 db_trx_id</code> 置为当前事务的 id</code>，db_roll_pt</code> 是一个指针，指向复制前的那一条的。</li>
DELETE</strong>：复制一行数据，将当前复制后这一行的 db_trx_id</code> 置为当前事务的 id</code>，db_roll_pt</code> 是一个指针，指向复制前的那一条的。并把 delete_flag</code> 置为 true</code> 。</li>
</ul>


巧用 MyBatis 构建树形结构
2022-05-02T14:48:49+08:00
在项目中我们经常会碰到这种格式的数据, 需要将其转化为树形结构:</p>
menu_id</th> parent_id</th> menu_name</th> url</th></tr></thead>

1</td> 0</td> 权限管理</td> #</td></tr>
2</td> 1</td> 用户管理</td> /user/index</td></tr>
3</td> 1</td> 角色管理</td> /role/index</td></tr>
4</td> 1</td> 菜单权限</td> /menu/index</td></tr>
11</td> 0</td> 系统监控</td> #</td></tr>
12</td> 11</td> 登录日志</td> /log/login/index</td></tr>
19</td> 11</td> 操作日志</td> /log/sys/index</td></tr>
20</td> 11</td> 在线用户</td> /online/index</td></tr>
27</td> 1</td> 操作权限</td> /operator/index</td></tr>
28</td> 1</td> 部门管理</td> /dept/index</td></tr>
29</td> 11</td> 系统管理</td> /system/index</td></tr>
30</td> 0</td> 账号关联</td> /oauth2/index</td></tr>
</tbody></table>
一般的做法是查询出所有, 然后递归构建树形结构, 但其实可以巧用 MyBatis 在查询时就进行转换, 这用到了 MyBatis 的 resultMap</code> 功能.</p>
首先由以下表结构定义:</p>


手撸 Java Web RBAC 权限管理
2022-05-02T14:47:45+08:00
前言</h2>
权限管理是在项目中经常要使用到的模块，有着极其重要的功能。 在 Java 帝国中有两个比较出名的权限框架，分别为 Shiro</a> 和 Spring Security</a>，两者各有优缺，但这不是本篇要讨论的重点，这次我们不用任何权限框架来实现 RBAC 权限管理。</p>

本文所有代码下载地址：https://github.com/zhaojun1998/Premission-Study</a></p>
</blockquote>


面试有感
2022-05-02T14:46:59+08:00
前言</h2>
因为公司项目的拓展，最近要招一些 Java</code> 开发，我作为一面面试官来谈一下面试的感受。</p>
我会从以下几个方面来聊聊面试这点事：</p>


Git 常用命令
2022-05-02T14:42:59+08:00
安装&配置</h2>
install</h3>
安装这里就不再多讲了，网上有许多教程，可以参考：</p>

廖雪峰-安装Git</a></li>
Git 官方教程</a></li>
</ul>


使用 Docker 快速安装 HTML5-Based Speedtest，可以准确的测试本地到 VPS 的网络速度
2022-05-02T14:42:16+08:00
前言</h2>
经常会搞一些小鸡玩，但想测试速度，总是比较麻烦，而在 VPS</code> 服务器上跑 speedtest-cli</code> 却感觉测试结果不靠谱，因为它只跑了距离服务器最近的节点的速度。</p>
现在，有了HTML5-Based Speedtest</code>，这一切都迎刃而解！</p>
应用已经Docker</code>化了，很简单即可部署测速环境！</p>
截图</h2>
</p>


阿里云 Centos7.x 安装 Oracle 11g 详细过程
2022-05-02T14:30:20+08:00
建立 swap 分区</h2>
dd</span> if=/dev/zero</span> of=/home/swap</span> bs=</span>1024</span> count=</span>2097152</span>  #</span> bs 为单位，count 为设置的大小 2048 * 1024 = 2G</span></span>
mkswap</span> /home/swap</span>                                    #</span> 格式化交换文件</span></span>
swapon</span> /home/swap</span>                                    #</span> 立即启用交换分区文件, 要停止使用新创建的swap文件,只要执行 swapoff/home/swap命令即可</span></span></code></pre>
建立完后, 执行 free -m</code> 查看结果:
</p>
然后在 /etc/fstab</code> 添加一行, 用来防止重启机器后 swap 分区会失效的问题:</p>
/home/swap             swap          swap    defaults        0 0</span></span></code></pre>


中文文案排版指北「转载」
2022-05-02T14:30:00+08:00
前言</h2>
作为一个博主，我认为文章的排版还是很重要的，一份好的排版的文章也是对读者的一份尊重，就好像在博客中代码要用代码块高亮起来一样。</p>
我也经常遇到问题时去看别人的博客，但是好多博主的排版甚是难看，有些甚至连最基本的代码块都没有，看起来很是不舒服，所以今天发布一篇关于排版的文章，希望其他的博主看到以后，可以重视起来，养成一个良好的排版习惯，方便自己也方便他人。</p>
本文摘自 GitHub 上的 中文文案排版指北</a>。</p>


SLF4J MDC ☞ 将用户信息添加到日志信息中
2022-05-02T14:29:33+08:00
前言</h2>
你是否有过排查某个用户的操作出现 BUG 时, 从茫茫日志中寻找这个用户操作的痛苦经历, SLF4J 为我们提供了一种基于 ThreadLocal</code> 来实现的 MDC</code> 功能, 用来将自定义信息放入到日志中.</p>
你可能没太明白啥意思, 那么先来看看效果把:</p>
普通日志:
</p>
加上MDC的日志:
</p>


Spring Boot 统一异常处理最佳实践 -- 拓展篇
2022-05-02T14:28:49+08:00
前言</h2>
之前一篇文章介绍了基本的统一异常处理思路: Spring MVC/Boot 统一异常处理最佳实践</a>.</p>
上篇文章也有许多人提出了一些问题:</p>

如何区分 Ajax 请求和普通页面请求, 以分别返回 JSON 错误信息和错误页面.</li>
如何结合 HTTP 状态码进行统一异常处理.</li>
</ul>
今天这篇文章就主要来讲讲这些, 以及其他的一些拓展点.</p>


Spring MVC/Boot 统一异常处理最佳实践
2022-05-02T14:28:32+08:00
前言</h2>
在 Web</code> 开发中, 我们经常会需要处理各种异常, 这是一件棘手的事情, 对于很多人来说, 可能对异常处理有以下几个问题:</p>

什么时候需要捕获(try-catch</code>)异常, 什么时候需要抛出(throws</code>)异常到上层.</li>
在 dao</code> 层捕获还是在 service</code> 捕获, 还是在 controller</code> 层捕获.</li>
抛出异常后要怎么处理. 怎么返回给页面错误信息.</li>
</ul>


Shiro 拓展之 Restful URL 鉴权
2022-05-02T14:27:38+08:00
前言</h2>
在使用 Shiro 的过程中，遇到一个痛点，就是对 restful 支持不太好，也查了很多资料，各种各样的方法都有，要不就是功能不完整，要不就是解释不清楚，还有一些对原有功能的侵入性太强，经过一番探索，算是最简的配置下完成了需要的功能，这里给大家分享下。大家如果又更好的方案，也可以在评论区留言，互相探讨下。</p>

虽然深入到了源码进行分析，但过程并不复杂，希望大家可以跟着我的思路捋顺了耐心看下去，而不是看见源码贴就抵触。</p>
</blockquote>


一款基于 Shiro 的权限管理系统，支持 restful 风格 URL.
2022-05-02T14:27:04+08:00
Shiro-Action</h1>
本项目使用 Spring Boot 搭建, 用于加深对 Spring Boot 与 Shiro 的学习, 项目特色是支持 restful 风格权限控制, 支持对同一 URL, 不同 HTTP Mehtod 的权限控制, 适用于更多的场景.</p>
预览地址: http://shiro.zhaojun.im/</a>
项目地址: https://github.com/zhaojun1998/Shiro-Action</a>
默认管理员账号: admin</code>, 密码: 123456</code>.
普通用户账号: user</code>, 密码: 123456</code>.</p>

为了不影响其他人的浏览体验, 请尽量不要进行删除类的敏感操作.  admin</code> 为超级管理员, 自动拥有全部权限.</p>
</blockquote>


Shiro 学习 12 - 从数据库读取过滤器链
2022-05-02T14:26:27+08:00
我们之前使用过滤器链都是在 XML 中手动添加和维护的，本章我们来介绍下如何从数据库读取这些过滤器配置，这样做的好处是便于维护，且可以通过程序来添加过滤器配置，因为我们只需要添加一条记录到数据库即可。</p>


Shiro 学习 11 - 集成 Spring 之记住我
2022-05-02T14:25:59+08:00
我们经常在登陆网站时看到一个选项，就是 记住我</strong>、 n天内自动登陆</strong>。本章我们使用 Shiro 来实现这个功能。</p>


Shiro 学习 10 - 集成 Spring 之注解
2022-05-02T14:25:36+08:00
前言</h2>
集成 Spring 后我们通过过滤器链来配置每个 URL 需要的权限，但当配置多了以后就会不方便，而且只支持 URL 级别的配置。</p>
好在 Shiro 提供了相应的注解用于权限控制，此处使用了 Spring MVC 来测试Shiro注解，当然 Shiro 注解不仅仅可以在 web 环境使用，在独立的JavaSE 中也是可以用的，此处只是以 web 为例了。</p>


Shiro 学习 09 - 集成 Spring 之会话管理
2022-05-02T14:25:08+08:00
前言</h2>
Shiro 提供了完整的会话管理功能，可以在不依赖底层容器，不仅可以在 WEB 环境下使用 Session，还可以在 JavaSE 环境下使用，且提供了会话管理，会话事件监听，会话持久化，过期支持。</p>


Shiro 学习 08 - 集成 Spring 之授权缓存
2022-05-02T14:24:30+08:00
前言</h2>
在 手撸 Java Web RBAC 权限管理</a> 中，我们自己实现了一个简易的 RBAC 权限管理框架，且我们也提到了一些缺陷，其中一点就是 :  每次请求需要授权的页面都会去数据库查询此用户对应的权限数据和角色数据，太耗费资源，应该进行缓存。</strong></p>
本章我们就来讲讲如何将 Shiro 中的授权数据缓存到 Redis 中。</p>


Shiro 学习 07 - 集成 Spring 之过滤器
2022-05-02T14:23:59+08:00
前言</h2>
在之前 Shiro 集成 Spring</a> 这一章中我们简单使用了 shiroFilter</code> 中的 filterChainDefinitions</code> 来做 认证</code> 和 授权</code> 的拦截，其实还有许多过滤器，可以做各种各样的拦截，并且 Shiro 还提供了接口来让我们自定义过滤器。</p>


Shiro 学习 06 - 集成 Spring 加密
2022-05-02T14:23:00+08:00
本章我们来讲解，如果使用 Shiro 集成 Spring 后，使用加密功能。本章基础代码为上一章 : Shiro 集成 Spring</a> 中的代码。</p>
我们这里演示使用 md5</code> 散列算法进行加密, 并用 TestSalt</code> 作为盐。</p>
首先导入上一章的代码，然后修改 spring-shiro.xml</code> ，添加内容:</p>
<</span>bean</span> id</span>=</span>"</span>credentialsMatcher</span>"</span> class</span>=</span>"</span>org.apache.shiro.authc.credential.HashedCredentialsMatcher</span>"</span>></span></span>
    <</span>property</span> name</span>=</span>"</span>hashAlgorithmName</span>"</span> value</span>=</span>"</span>md5</span>"</span> /></span></span>
</</span>bean</span>></span></span></code></pre>
然后将此凭证匹配器 credentialsMatcher</code> 注入到 Realm</code> 中 :</p>
<</span>bean</span> id</span>=</span>"</span>myRealm</span>"</span> class</span>=</span>"</span>im.zhaojun.realm.MyRealm</span>"</span>></span></span>
    <</span>property</span> name</span>=</span>"</span>credentialsMatcher</span>"</span> ref</span>=</span>"</span>credentialsMatcher</span>"</span>/></span></span>
</</span>bean</span>></span></span></code></pre>
并在 Realm 中的 doGetAuthenticationInfo</code> 方法里添加盐的配置 :</p>
@</span>Override</span></span>
protected</span> AuthenticationInfo</span> doGetAuthenticationInfo</span>(</span>AuthenticationToken</span> authenticationToken</span>)</span></span>
        throws AuthenticationException </span>{</span></span>
</span>
    System</span>.</span>out</span>.</span>println</span>(</span>"</span>MyRealm doGetAuthenticationInfo...</span>"</span>)</span>;</span></span>
</span>
    String</span> username</span> =</span> (</span>String</span>)</span> authenticationToken</span>.</span>getPrincipal</span>(</span>)</span>;</span></span>
    User</span> user</span> =</span> selectUserByUserName</span>(</span>username</span>)</span>;</span></span>
    if</span> (</span>user </span>==</span> null</span>)</span> {</span></span>
        throw</span> new</span> UnknownAccountException</span>(</span>"</span>当前账户不存在</span>"</span>)</span>;</span></span>
    }</span></span>
    return</span> new</span> SimpleAuthenticationInfo</span>(</span>user</span>.</span>getUsername</span>(</span>)</span>,</span> user</span>.</span>getPassword</span>(</span>)</span>,</span> ByteSource</span>.</span>Util</span>.</span>bytes</span>(</span>"</span>TestSalt</span>"</span>)</span>,</span> super</span>.</span>getName</span>(</span>)</span>)</span>;</span></span>
}</span></span></code></pre>
既然为 Relam 配置了凭证匹配器，那么就应该把我们存储的密码也进行加密，原始我们的密码为 123456</code>，这里我们使用 md5</code> 散列算法进行加密，并使用 TestSalt</code> 作为盐</strong> :</p>
public</span> class</span> GenerateHash</span> {</span></span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        Md5Hash</span> md5Hash</span> =</span> new</span> Md5Hash</span>(</span>"</span>123456</span>"</span>,</span> ByteSource</span>.</span>Util</span>.</span>bytes</span>(</span>"</span>TestSalt</span>"</span>)</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>md5Hash</span>.</span>toString</span>(</span>)</span>)</span>;</span></span>
    }</span></span>
}</span></span>
</span>
//</span> 输出结果为 e5f728a966d050296c428290c9160dda</span></span></code></pre>
然后我们将 Realm</code> 中获取的密码改为加密后的值 e5f728a966d050296c428290c9160dda</code> :</p>
private</span> User</span> selectUserByUserName</span>(</span>String</span> username</span>)</span> {</span></span>
    if</span> (</span>"</span>zhao</span>"</span>.</span>equals</span>(</span>username</span>)</span>)</span> {</span></span>
        return</span> new</span> User</span>(</span>username</span>,</span> "</span>e5f728a966d050296c428290c9160dda</span>"</span>)</span>;</span></span>
    }</span></span>
    return</span> null</span>;</span></span>
}</span></span></code></pre>
同上一章，运行项目，进行登陆测试，即可检验结果。</p>
本章代码地址 : https://github.com/zhaojun1998/Premission-Study/tree/master/Permission-Shiro-06/</p>


Shiro 学习 05 - 集成 Spring
2022-05-02T14:22:22+08:00
前言</h2>
本章我们来学习 Shiro 集成 Spring，即在 Web 环境下如何使用 Shiro 来进行权限控制。</p>
本章所需知识：</p>

Shiro 认证 && 授权</li>
Spring、SpringMVC</li>
</ul>


Shiro 学习 04 - 加密
2022-05-02T14:15:13+08:00
加密</h2>
安全总是最重要的，对于用户的数据，我们一般都不会以原密码明文保存，而是经过加密后保存。</p>
比较常见的是，当注册时使用 MD5</code> 散列算法对初始密码处理后存入数据库，而后每次登陆请求，对用户输入的密码也进行 MD5</code> 散列后与数据库中的散列后的密码进行匹配，已达到加密的目的。</p>


Shiro 学习 03 - Realm
2022-05-02T14:14:27+08:00
Realm 是什么</h2>
Realm: 域，Shiro 从 Realm 中获取用户，角色，权限信息。可以把 Relam 看成 DataSource，即安全数据源。</p>

在前两章的认证和授权中，我们也使用到了 SimpleAccountRealm</code>，并通过其 addAccount(username, password, roles)</code> 来预设用户和角色信息。</p>
</blockquote>


Shiro 学习 02 - 授权
2022-05-02T13:51:00+08:00
授权在 Shiro 中被称为 Authorization</strong>，用来验证用户是否具备某个角色或权限</strong>。</h3>


Shiro 学习 01 - 认证
2022-05-02T13:50:00+08:00
认证在 Shiro 中被称为 Authentication</strong>，用来验证用户是不是拥有相应的身份，也可以理解为登陆时校验登陆凭证的过程。</h3>
首先需要导包，这里我们通过 maven 坐标的方式进行引用, 导入 shrio 和 junit 的包:</p>
<</span>dependency</span>></span></span>
    <</span>groupId</span>></span>org.apache.shiro</span></</span>groupId</span>></span></span>
    <</span>artifactId</span>></span>shiro-all</span></</span>artifactId</span>></span></span>
    <</span>version</span>></span>1.4.0</span></</span>version</span>></span></span>
</</span>dependency</span>></span></span>
<</span>dependency</span>></span></span>
    <</span>groupId</span>></span>junit</span></</span>groupId</span>></span></span>
    <</span>artifactId</span>></span>junit</span></</span>artifactId</span>></span></span>
    <</span>version</span>></span>4.12</span></</span>version</span>></span></span>
</</span>dependency</span>></span></span></code></pre>
然后创建一个测试类来简单认识一下 Shiro 的认证流程:</p>
import</span> org</span>.</span>apache</span>.</span>shiro</span>.</span>SecurityUtils</span>;</span></span>
import</span> org</span>.</span>apache</span>.</span>shiro</span>.</span>authc</span>.</span>UsernamePasswordToken</span>;</span></span>
import</span> org</span>.</span>apache</span>.</span>shiro</span>.</span>mgt</span>.</span>DefaultSecurityManager</span>;</span></span>
import</span> org</span>.</span>apache</span>.</span>shiro</span>.</span>realm</span>.</span>SimpleAccountRealm</span>;</span></span>
import</span> org</span>.</span>apache</span>.</span>shiro</span>.</span>subject</span>.</span>Subject</span>;</span></span>
import</span> org</span>.</span>junit</span>.</span>Before</span>;</span></span>
import</span> org</span>.</span>junit</span>.</span>Test</span>;</span></span>
</span>
public</span> class</span> AuthenticateTest</span> {</span></span>
    //</span> 创建一个 Realm</span></span>
    private</span> SimpleAccountRealm</span> simpleAccountRealm</span> =</span> new</span> SimpleAccountRealm</span>(</span>)</span>;</span></span>
</span>
    /**</span></span>
     * 为 Realm 添加一个账户</span></span>
     */</span></span>
    @</span>Before</span></span>
    public</span> void</span> before</span>(</span>)</span> {</span></span>
        simpleAccountRealm</span>.</span>addAccount</span>(</span>"</span>zhao</span>"</span>,</span> "</span>123456</span>"</span>)</span>;</span></span>
    }</span></span>
</span>
    /**</span></span>
     * 测试用户认证(登陆)</span></span>
     */</span></span>
    @</span>Test</span></span>
    public</span> void</span> testAuthenticate</span>(</span>)</span> {</span></span>
        //</span> 构建 SecurityManager 环境</span></span>
        DefaultSecurityManager</span> defaultSecurityManager</span> =</span> new</span> DefaultSecurityManager</span>(</span>)</span>;</span></span>
</span>
        //</span> 为 SecurityManager 设置 Realm</span></span>
        defaultSecurityManager</span>.</span>setRealm</span>(</span>simpleAccountRealm</span>)</span>;</span></span>
</span>
        //</span> 将 SecurityManager 放入 SecurityUtils 这个工具类中</span></span>
        SecurityUtils</span>.</span>setSecurityManager</span>(</span>defaultSecurityManager</span>)</span>;</span></span>
</span>
        //</span> 获取一个 Subject</span></span>
        Subject</span> subject</span> =</span> SecurityUtils</span>.</span>getSubject</span>(</span>)</span>;</span></span>
</span>
        //</span> 创建一个账号密码, 在 web 应用中一般为表单上填写并传入后台.</span></span>
        UsernamePasswordToken</span> token</span> =</span> new</span> UsernamePasswordToken</span>(</span>"</span>zhao</span>"</span>,</span> "</span>123456</span>"</span>)</span>;</span></span>
</span>
        //</span> 进行登陆操作</span></span>
        subject</span>.</span>login</span>(</span>token</span>)</span>;</span></span>
</span>
        //</span> 验证是否为登陆状态</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>"</span>是否登陆: </span>"</span> +</span> subject</span>.</span>isAuthenticated</span>(</span>)</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
登陆成功的话，subject.isAuthenticated()</code>会返回 true</code> 。</p>
登陆失败的话，会抛出相应的异常，如：</p>
UnknownAccountException             # 未知账户/没找到帐号</span></span>
IncorrectCredentialsException       # 错误的凭证(密码)异常</span></span></code></pre>
本章代码地址 : https://github.com/zhaojun1998/Premission-Study/tree/master/Permission-Shiro-01/</p>


留言板
2022-05-02T12:53:54+08:00
原留言板依赖 Typecho 评论系统；历史留言仍保留在旧站数据库中。</p>


时光机
2022-05-02T12:44:00+08:00
原页面依赖 Typecho 动态数据，数据库中没有可迁移的静态正文。</p>


归档
2022-05-01T13:26:00+08:00
全部历史文章已迁移，请查看 文章列表</a>。</p>


github
2022-05-01T13:23:58+08:00
我的 GitHub：https://github.com/zhaojun1998</a></p>


关于
2022-05-01T12:05:00+08:00
一个努力学习的 Java 开发者，开源项目 ZFile</a> 作者。</p>
主语言 Java，会一些 Vue，目前在北京从事 Java 开发工作。</p>

赵俊

nginx 禁止直接访问 http 端口

修复 docker buildx 编译后，manifest 包含 unknown 的问题

已有镜像修复</h2> 上面的可以在新推送镜像时避免产生问题，但是对于已有镜像有时候不方便重新制作，可以通过以下办法修复已有镜像：</p>

去除 unknown 部分</h3> 可以用以下脚本 fix-image.sh</code> 来解决：</p>

leetcode 3152. 特殊数组 II

leetcode 3132. 找出与数组相加的整数 II

代码命名之 Spring

执行器 Executor</h2> 执行器一般是用来执行某个任务的，多和线程池有关，Spring 中的执行器一般都是以 Executor</code> 结尾，如 TaskExecutor</code>, AsyncTaskExecutor</code>, AsyncListenableTaskExecutor</code> 等。</p>

工具类 Utils</h2> 工具类一般包含一些静态方法，用于提供一些工具方法，Spring 中的工具类一般都是以 Utils</code> 结尾，如 ClassUtils</code>, BeanUtils</code>, StringUtils</code> 等。</p>

Git 笔记

2. 暂存区 stage</h2>

9. 分支管理 branch</h2>

9.1. 创建, 查看, 切换, 合并, 删除分支</h3>

使用 Gost 来实现 sniproxy

参考</h2> gost github</a></li> gost 文档</a></li> </ul>

Linux 窗口管理器 Tmux 使用教程

1. 安装</h2>

2. 启动和退出</h2>

4. 会话管理 session</h2>

6. 窗口管理 window</h2>

8. 状态栏</h2>

Percona XtraDB Cluster 集群搭建

集群搭建 (单机多节点)</h2>

集群搭建 (多机多节点)</h2> 前面我们是在一台机器上创建了多个节点，如果我们想在多台机器上创建多个节点就要先解决跨机器之间容器的通信问题。</p>

PXC 集群原理</h2>

Linux 三剑客之 awk 命令

总结</h2>

Percona Monitoring and Management (PMM) 安装与配置

5. 向 pmm-client 注册 MySQL 服务</h2> 添加专有用户</h3> 在你要被监控的 MySQL 服务上创建一个专用的用户：</p>

添加专有用户</h3> 在你要被监控的 MySQL 服务上创建一个专用的用户：</p>

使用 Nginx Stream 模块来实现 sniproxy

已有镜像修复</h2>
上面的可以在新推送镜像时避免产生问题，但是对于已有镜像有时候不方便重新制作，可以通过以下办法修复已有镜像：</p>

执行器 Executor</h2>
执行器一般是用来执行某个任务的，多和线程池有关，Spring 中的执行器一般都是以 `Executor</code> 结尾，如 TaskExecutor</code>, AsyncTaskExecutor</code>, AsyncListenableTaskExecutor</code> 等。</p>`

`工具类 Utils</h2> 工具类一般包含一些静态方法，用于提供一些工具方法，Spring 中的工具类一般都是以 Utils</code> 结尾，如 ClassUtils</code>, BeanUtils</code>, StringUtils</code> 等。</p>`

`参考</h2>gost github</a></li> gost 文档</a></li> </ul>`