baofeidyz's blog api 工具 apifox postman bruno insomnia reqable hoppscotch yaak Wed, 15 Apr 2026 08:15:28 GMT 2026年主流API调试工具对比

在经历了apifox的投毒事件以后，我就一直在寻找一个相对完美的替代品，终于我找到了一款叫yaak的开源神器！
关于apifox投毒事件可见：Apifox 供应链投毒攻击 — 完整技术分析

一、工具对比总览

说明：

• ✅：完全支持 / 优秀
• ❌：不支持 / 明显不足
• ⚠️：部分支持 / 存在限制

二、核心能力对比

1. 架构与数据控制

2. 协作能力

3. 功能与体验

4. 安全性

三、结论与选择

从对比可以看出：

• 云工具（Apifox / Postman）在功能和协作上占优，但存在数据与安全风险
• 本地工具（Bruno / Yaak）在安全与可控性上更有优势
• 轻量工具（Hoppscotch / Reqable）适合辅助使用（Reqable非常适合用于https协议抓包）

四、为什么最终选择 Yaak

最终选择 Yaak，主要基于以下几点：

1. 完全本地优先

• 数据不经过云端
• 不依赖远程资源
• 风险可控

2. Git 原生协作

• 使用 Git 进行团队同步
• 支持版本管理、回滚、审计
• 不依赖平台

3. 多 Workspace 免费

• 不限制项目数量
• 无额外收费
• 不锁功能

4. 性能与体验

• 启动速度快
• 界面简洁
• 无冗余功能

5. 开源与可控性

• 可审计代码
• 可自托管或 fork
• 无商业绑定风险

五、总结

API 工具的选择，本质取决于：

• 是否需要云协作
• 是否关注数据安全
• 是否需要高度可控

在安全性、性能、协作方式和成本之间权衡后：

👉 Yaak 是当前更均衡且更可控的选择

baofeidyz's blog AI RAG Fri, 27 Feb 2026 08:55:21 GMT

概述

PageIndex是无向量模型依赖的RAG解决方案，通过推理模型将PDF或者markdown文档转换为JSON文件来实现检索

基本信息

1. 官网地址：https://pageindex.ai
2. GitHub地址：https://github.com/VectifyAI

适用场景

1. 基于特定资料库的问答

注意事项

1. 部分开源

PDF/markdown转换为JSON有做开源（https://github.com/VectifyAI/PageIndex），但核心服务是闭源的，只能通过服务调用（sdk/http rest api/mcp http/mcp stdio）完成。
如果需要私有化部署需要单独联系采购

MCP没有支持文档转换

基于http的mcp不支持PDF/markdown转换为JSON。需要自己在后台页面中上传，操作较为繁琐

PDF/markdown转换为JSON效果不稳定

我上传了一份20+页的PDF，在后台看到的结果中只有2页。
因为无法直接上传我通过PageIndex生成好的json文件，只能使用云端默认的模型

评价

就我自己本身的应用场景来看，目前基于向量模型的方案没有遇到瓶颈，暂不考虑PageIndex

另外PageIndex这个服务只是作者引流的一个开源仓库，实际服务与这个开源仓库关系不大

baofeidyz's blog AI Claude Code MCP Wed, 11 Feb 2026 08:12:37 GMT

本地依赖

python + uv

安装步骤

1. 从GitHub仓库中clone源码到本地

1

git clone https://github.com/oceanbase/awesome-oceanbase-mcp.git

2. 使用uv安装python依赖

1
2
3
4

cd awesome-oceanbase-mcp && \
uv venv && \
source .venv/bin/activate && \
uv pip install .

3. 使用claude命令添加MCP Server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

claude mcp add-json oceanbase '{
"type":"stdio",
"command": "uv",
"args": [
 "--directory", 
 "你的本地路径/awesome-oceanbase-mcp/src/oceanbase_mcp_server",
 "run",
 "oceanbase_mcp_server"
 ],
"env": {
 "OB_HOST": "***",
 "OB_PORT": "***",
 "OB_USER": "***",
 "OB_PASSWORD": "***",
 "OB_DATABASE": "***"
 }
}'

验证方法

1

claude mcp list

没有报错信息或者提示Connected即为成功

注意事项

1. 整个仓库中不止有oceanbase数据库的mcp server，所以你在写本地路径时一定要仔细看。
2. 如果claude报错了，你可以选择让claude自己修复
3. 一定要有"type":"stdio"的声明

FAQ

暂无

参考资料

• OceanBase MCP Server 与 Claude Code 集成
• 从 JSON 配置添加 MCP 服务器

baofeidyz's blog AI AI Prompt 提示词工程 Mon, 09 Feb 2026 08:46:00 GMT

原因

根本原因是大模型没有正确识别“输入”和“示例”的区别，ta会把你给出的“示例”当成了”输入“从而导致生成的结果和输入不符合出现幻觉

解决思路

需要加强模型对于”输入“和”示例“的理解，可以设定一个逻辑步骤，要求ta按照第一步、第二步…这样去生成

然后针对GPT模型可以考虑使用xml标签来隔离“输入”和“示例”

比如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

你是xxx，你的任务是xxx

**处理逻辑**
请严格遵守以下信息处理逻辑：
1. 浏览 <reference_cases> 中的内容，仅用于xxx。
2. 绝对禁止提取 <reference_cases> 中的任何xxx。
3. 仅针对 <current_session> 标签中的xxx进行xxx。

...

<reference_cases>
...
</reference_cases>

<current_session>
...
</current_session>

需要安装好OpenClaw和Claude，并且配置相应的模型或者账号权限

baofeidyz's blog AI AI OpenClaw Claude Mon, 09 Feb 2026 08:33:13 GMT 前提

需要安装好OpenClaw和Claude，并且配置相应的模型或者账号权限

问题集锦

1. OpenClaw一直提示需要/login

原因

我本地使用的Claude是使用litellm本地服务启动的，我有设置环境变量，是通过~/.zshrc文件维护。
OpenClaw一直报这个错，就是因为ta没有使用我的~/.zshrc文件

解决方案

告诉OpenClaw尝试先执行source ~/.zshrc再调用Claude

2. OpenClaw会因为Claude超时而失败

原因

OpenClaw在调用Claude时，不会使用Claude的交互模式，一般都是直接运行Claude -p "具体任务"，而OpenClaw默认等待时间是60s左右，当你Claude超过这个时间响应时，就会导致OpenClaw因Claude超时失败

解决方案

让OpenClaw异步调用Claude，把Claude输出的日志放到一个临时文件中，然后定时轮询这个临时文件查看日志即可

感觉3月没有听到啥好听的新歌，选来选去还是把封面给王力宏的《在梅边》，后面的rap很不错。
今天才听到路虎3月发的新歌《流行歌手》，好听！

最近做了一个小需求，需要解析js文件，获取一些配置项信息，并转存为properteis的格式。
目前技术栈是JDK15，并且因为这个版本踩了不少坑，记录一下。

简称CA，属于是Unraid OS必装应用，推荐指数爆表。其功能就是提供了应用安装方式。

Tailscale (Plugin)

• 推荐指数：🌟🌟🌟🌟🌟
• 功能介绍：tailscale是一款非常出色且免费的网络软件，多个设备登录并使用tailscale后，可以在多个设备之间建立内网连接。

• Boolean objects
• Numeric objects
• String objects
• Name objects
• Array objects
• Dictionary objects
• Stream objects
• Null object
• Indirect objects
  这篇博客主要是介绍一下Stream objects在PDF ISO标准文件中的信息以及itext core代码实现。

依赖于ffmpeg，允许传递起始时间、截图间隔、截图数量、视频文件地址等四个参数，其中时间单位为秒。

我在Linux Alpine中使用，可能部分依赖在其它Linux环境中会遇到问题，欢迎评论告知。

示例

1
2
3

sh snapshot.sh 600 800 6 Dune.Part.Two.2024.2160p.WEB-DL.DV.HDR10+.DDP5.1.Atmos.H265.mkv

你会得到六个文件，文件命名如下：

1
2
3
4
5
6

Dune.Part.Two.2024.2160p.WEB-DL.DV.HDR10+.DDP5.1.Atmos.H265_frame_001.jpg
Dune.Part.Two.2024.2160p.WEB-DL.DV.HDR10+.DDP5.1.Atmos.H265_frame_002.jpg
Dune.Part.Two.2024.2160p.WEB-DL.DV.HDR10+.DDP5.1.Atmos.H265_frame_003.jpg
Dune.Part.Two.2024.2160p.WEB-DL.DV.HDR10+.DDP5.1.Atmos.H265_frame_004.jpg
Dune.Part.Two.2024.2160p.WEB-DL.DV.HDR10+.DDP5.1.Atmos.H265_frame_005.jpg
Dune.Part.Two.2024.2160p.WEB-DL.DV.HDR10+.DDP5.1.Atmos.H265_frame_006.jpg

需求点分析

1. 是否支持多类数据库以及脚本区分？
2. 如何撤销变更？
3. 版本是如何管理的？
4. 费用问题？是否开源？开源协议是什么？

现象描述

正常启动服务时，突然遇到栈溢出异常，日志输出内容如下：

1
2
3
4
5
6
7
8
9
10
11
12

java.lang.StackOverflowError: null
  at org.springframework.data.util.TypeDiscoverer.createInfo(TypeDiscoverer.java:113) ~[spring-data-commons-2.5.1.jar:2.5.1]
  at org.springframework.data.util.TypeDiscoverer.getSuperTypeInformation(TypeDiscoverer.java:443) ~[spring-data-commons-2.5.1.jar:2.5.1]
  at org.springframework.data.util.ClassTypeInformation.getSuperTypeInformation(ClassTypeInformation.java:42) ~[spring-data-commons-2.5.1.jar:2.5.1]
  at org.springframework.data.util.TypeDiscoverer.getSuperTypeInformation(TypeDiscoverer.java:449) ~[spring-data-commons-2.5.1.jar:2.5.1]
  at org.springframework.data.util.ClassTypeInformation.getSuperTypeInformation(ClassTypeInformation.java:42) ~[spring-data-commons-2.5.1.jar:2.5.1]
  at org.springframework.data.util.TypeDiscoverer.getSuperTypeInformation(TypeDiscoverer.java:449) ~[spring-data-commons-2.5.1.jar:2.5.1]
  at org.springframework.data.util.ClassTypeInformation.getSuperTypeInformation(ClassTypeInformation.java:42) ~[spring-data-commons-2.5.1.jar:2.5.1]
  at org.springframework.data.util.TypeDiscoverer.getSuperTypeInformation(TypeDiscoverer.java:449) ~[spring-data-commons-2.5.1.jar:2.5.1]
  at org.springframework.data.util.ClassTypeInformation.getSuperTypeInformation(ClassTypeInformation.java:42) ~[spring-data-commons-2.5.1.jar:2.5.1]
  at org.springframework.data.util.TypeDiscoverer.getSuperTypeInformation(TypeDiscoverer.java:449) ~[spring-data-commons-2.5.1.jar:2.5.1]
  ...

• baofeidyz's blog Windows 周报 Thu, 12 Sep 2024 16:00:00 GMT
  • Windows查看快捷键占用程序
  • 解决Windows平台 IDEA Shift+F6 快捷键冲突
  • 发布了博客：银联银行卡号校验

  Windows查看快捷键占用程序

  使用openark即可

  实际并不是很准确，我就没找到占用Shift+F6的程序是哪个。

  解决Windows平台 IDEA Shift+F6 快捷键冲突

  实际是因为微软拼音输入法占用了，需要开启兼容模式

  

  参考：微软拼音输入法占用Shift+F6快捷键

  ]]> https://baofeidyz.com/2024/282bbd18bc13/ 这个话题还是很有意思的，银行卡号有点类似于身份证号的设计。

  银行卡的卡号长度及结构符合ISO 7812-1]]> baofeidyz's blog 技术 银联 银行卡号 Mon, 09 Sep 2024 16:00:00 GMT 这个话题还是很有意思的，银行卡号有点类似于身份证号的设计。

  银行卡的卡号长度及结构符合ISO 7812-1 有关规定，由13-19位数字表示，具体由以下几部分组成：

  发卡行标识代码	自定义位	校验位
  XXXXX	X……X	X

  其中校验位是通过一个名为Luhn的校验算法得出的。

  然而实际上一些商业银行不遵守这个规范，所以导致Luhn设计被废弃了，具体可以见这个Github Issue的讨论。

  现在更推荐使用一些开放平台提供的API接口来实现，比如支付宝开放平台以及中国银联开放平台。

  中国银联开放平台有准入门槛，需要先申请，如果只是做银行卡是否有效的验证，不校验对应所有人身份信息的话可以直接用支付宝提供的接口。

  接口请求示例：

  1	curl "https://ccdcapi.alipay.com/validateAndCacheCardInfo.json?_input_charset=utf-8&cardNo=银行卡卡号&cardBinCheck=true"

  比如我们请求：

  1	curl https://ccdcapi.alipay.com/validateAndCacheCardInfo.json?_input_charset=utf-8&cardNo=6214832018989180&cardBinCheck=true

  我们可以拿到请求结果为：

  1 2 3 4 5 6 7 8

  { cardType: "DC", bank: "CMB", key: "6214832018989180", messages: [ ], validated: true, stat: "ok" }

  • bank字段返回的CMB则可以通过支付宝开放平台-文档中心：银行简码——混合渠道查阅得知这是招行银行的卡
  • cardType字段则用于区分是借记卡（DC）还是贷计卡（CC）

  这里需要注意的是支付宝开放平台-文档中心：银行简码——混合渠道这篇文章是2015年所写的，一直也没有更新，只是个局部参考，如果真的要相对稳定的接口，还是建议使用中国银联开放平台。

  注：

  1. 支付宝开放平台-文档中心：银行简码——混合渠道这篇文章是2015年所写的，一直也没有更新，只是个局部参考，如果真的要相对稳定的接口，还是建议使用中国银联开放平台；
  2. 支付宝的这个接口其实也支持其他卡组织的卡号校验（境外卡号我没有试过）；

  本文参考：

  • 中国人民银行：银行卡发卡行标识代码及卡号
  • 中华人民共和国金融行业标准-银行卡发卡行标识代码及卡号-JR/T 0008-2000
  • Github Issue:【建议】新增银行卡号真伪校验
  • 支付宝开放平台：validateAndCacheCardInfo
  • 支付宝开放平台-文档中心：银行简码——混合渠道
  • 中国银联开放平台-银行卡信息验证
  • Github：cnbankcard

  ]]> https://baofeidyz.com/2024/a8a68375145d/
  • 发布了两篇博客：Windows 安装 oh-my-zsh、oh-my-zsh安装方法以及插件主题推荐
  • Server-Sent Events
  • Windows查看文件占用
  • fastfds：分布式文件存储
  • 微信公众号获取openId
  ]]> baofeidyz's blog Java 技术选型 Windows 周报 微信公众号 Thu, 05 Sep 2024 16:00:00 GMT
  • 发布了两篇博客：Windows 安装 oh-my-zsh、oh-my-zsh安装方法以及插件主题推荐
  • Server-Sent Events
  • Windows查看文件占用
  • fastfds：分布式文件存储
  • 微信公众号获取openId

  Server-Sent Events

  简称为SSE，基于http协议实现的推流操作，服务端向客户端推流，流信息可以是多条信息。

  其他详细的内容推荐阅读阮一峰博客：Server-Sent Events 教程

  Windows查看文件占用

  在删除一些文件的时候，发现删除不了，提示busy，简单找了一下，有一个微软自己官方的工具，在网站最后有下载地址，下载以后通过cmd使用即可。

  官网地址：https://learn.microsoft.com/en-us/sysinternals/downloads/handle

  命令行参考：

  1	handler c:\xxx\xxx

  但我感觉没啥太大用处，还是不如macOS好用

  fastfds

  内容摘自：https://github.com/happyfish100/fastdfs/blob/master/README_zh.md

  FastDFS是一款开源的分布式文件系统，功能主要包括：文件存储、文件同步、文件访问（文件上传、文件下载）等，解决了文件大容量存储和高性能访问的问题。FastDFS特别适合以文件为载体的在线服务，如图片、视频、文档等等服务。

  FastDFS作为一款轻量级分布式文件系统，版本V6.01代码量6.3万行。FastDFS用C语言实现，支持Linux、FreeBSD、MacOS等类UNIX系统。FastDFS类似google FS，属于应用级文件系统，不是通用的文件系统，只能通过专有API访问，目前提供了C客户端和Java SDK，以及PHP扩展SDK。

  FastDFS为互联网应用量身定做，解决大容量文件存储问题，实现高性能和高扩展性。FastDFS可以看做是基于文件的key value存储系统，key为文件ID，value为文件本身，因此称作分布式文件存储服务更为合适。

  FastDFS的架构比较简单，如下图所示：

  

  • GitHub地址：https://github.com/happyfish100/fastdfs
  • 中文介绍：https://github.com/happyfish100/fastdfs/blob/master/README_zh.md

  需要注意的是作者使用的GPL 3.0协议

  但是我更好奇为啥不选择minio，在掘金上看到一篇博客MinIO 介绍 与 FastDFS 对比，感觉像是翻译来的，内容也不是很硬核

  我又找到一篇博客：MinIO很强-让我放弃FastDFS拥抱MinIO的8个理由

  我觉得好像fastfds确实不太行？

  微信公众号获取openId

  其实这活我读书那会儿就做过微信公众号网页开发，但是我早就忘记了得是服务号类型才可以调用api。
  微信这个获取openId的流程文档也没有先声明要求，有点恶心到我了。

  相关文档：

  • 微信公众号获取openId流程
  • 微信公众号必须是服务号才可以获取openId
  ]]> https://baofeidyz.com/2024/415dd5c7b8b3/ Windows 是有方案可以实现类似于Linux的终端环境，比如cygwin。

  我很久以前有用过，但是我在尝试安装SDKMan的时候发现cygwin不受支持了。然后SDKMan推荐了msys

  

  ]]> baofeidyz's blog 技术 Windows Wed, 04 Sep 2024 01:55:24 GMT Windows 是有方案可以实现类似于Linux的终端环境，比如cygwin。

  我很久以前有用过，但是我在尝试安装SDKMan的时候发现cygwin不受支持了。然后SDKMan推荐了msys

  

  查了一下，我找到了MSYS2

  安装MSYS2以后，有一个叫MSYS2 UCRT64.exe程序，打开以后就是我们熟悉的bash环境

  最后基于MSYS2安装oh-my-zsh即可。

  首先我们需要安装zsh

  1	pacman -S zsh

  pacman是MSYS2提供的包管理工具

  关于oh-my-zsh的安装以及插件和主题的推荐我有单独发博客，请点这里查看

  插件和主题都可以在msys2中正常运行。

  至于SDKMan的安装，则可以完全按照官网的脚本运行即可。你可能会遇到一些组件不存在的错误提示，比如git、zip、unzip等，可以使用msys2提供的包管理工具pacman安装

  1 2 3

  pacman -S git pacman -S zip pacman -S unzip

  即可搞定

  Windows idea terminal切换终端为msys2

  在idea的设置中，tools-terminal下有一个路径，我们输入

  C:\msys64\usr\bin\bash.exe --login -i

  即可

  

  如果你没有选择安装在C盘或者是第一级目录名称不叫msys64，那么你需要自己调整一下，不要完全照抄

  Windows vscode 终端切换为msys2

  vscode其实本身就支持切换终端，只是入口可能大家找不到，如下图所示，用心找找就解决问题了

  

  ]]> https://baofeidyz.com/2024/38514a82b6d7/ oh-my-zsh的Github仓库地址：https://github.com/ohmyzsh/ohmyzsh

  baofeidyz's blog 技术 macOS Shell Linux Wed, 04 Sep 2024 01:22:53 GMT oh-my-zsh的Github仓库地址：https://github.com/ohmyzsh/ohmyzsh

  安装zsh

  oh-my-zsh安装之前必须要先将shell环境切换成zsh

  https://github.com/ohmyzsh/ohmyzsh/wiki/Installing-ZSH

  for centos

  1 2	sudo yum update && sudo yum -y install zsh && \ chsh -s $(which zsh)

  for debian

  1 2	sudo apt install -y zsh && \ chsh -s $(which zsh)

  安装 on-my-zsh

  1	sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

  或者

  1	sh -c "$(wget -O- https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

  国内安装特别慢，建议使用魔法

  插件安装

  一键安装脚本：

  第五行中是针对第一次安装oh-my-zsh的的内容做文本替换，如果不是第一次安装会替换失败，需要自己手动维护plugins和ZSH_THEME

  1 2 3 4 5 6

  git clone --depth=1 https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions && \ git clone --depth=1 https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting && \ git clone --depth=1 https://github.com/paulirish/git-open.git $ZSH_CUSTOM/plugins/git-open && \ git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/themes/powerlevel10k && \ [ -f ~/.zshrc ] && { grep -q '^plugins=(git)$' ~/.zshrc && sed -i '' 's/^plugins=(git)$/plugins=(git zsh-autosuggestions extract zsh-syntax-highlighting)/' ~/.zshrc || echo "⚠️ 未找到 plugins=(git)，未进行替换。"; grep -q '^ZSH_THEME="robbyrussell"$' ~/.zshrc && sed -i '' 's/^ZSH_THEME="robbyrussell"/ZSH_THEME="powerlevel10k\/powerlevel10k"/' ~/.zshrc || echo "⚠️ 未找到 ZSH_THEME=\"robbyrussell\"，未进行替换。"; echo "✅ 操作完成，如未生效请重新打开终端或执行 source ~/.zshrc"; } || echo "❌ 文件 ~/.zshrc 不存在，无法进行修改。" && \ source ~/.zshrc

  zsh-autosuggestions

  介绍: 可以根据历史记录提供提示命令
  github地址: https://github.com/zsh-users/zsh-autosuggestions
  安装教程: https://github.com/zsh-users/zsh-autosuggestions/blob/master/INSTALL.md

  1	git clone --depth=1 https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

  1	plugins=(zsh-autosuggestions)

  extract

  介绍: 一键解压,不用再去记tar各种命令
  github地址: https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/extract

  不需要安装直接在plugins中增加extract即可

  zsh-syntax-highlighting

  介绍: 命令高亮提示
  github地址: https://github.com/zsh-users/zsh-syntax-highlighting

  1	git clone --depth=1 https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

  1	plugins=( [plugins...] zsh-syntax-highlighting)

  git-open

  介绍：直接在终端界面打开对应仓库的页面信息

  1	git clone --depth=1 https://github.com/paulirish/git-open.git $ZSH_CUSTOM/plugins/git-open

  主题

  powerlevel10k/powerlevel10k

  github地址: https://github.com/romkatv/powerlevel10k

  1	git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/themes/powerlevel10k

  然后修改.zshrc

  1	ZSH_THEME="powerlevel10k/powerlevel10k"

  ]]> https://baofeidyz.com/2024/0367001e6dac/

  • 多线程读取HashMap会产生死循环？

  ]]> baofeidyz's blog 周报 Thu, 29 Aug 2024 16:00:00 GMT

  • 多线程读取HashMap会产生死循环？

  多线程读取HashMap会产生死循环？

  最近在看廖雪峰大佬写的Spring Cloud开发博客，其中在设计资产系统时，提到说

  为什么要使用ConcurrentMap？
  使用ConcurrentMap并不是为了让多线程并发写入，因为AssetService中并没有任何同步锁。对AssetService进行写操作必须是单线程，不支持多线程调用tryTransfer()。

  但是读取Asset支持多线程并发读取，这也是使用ConcurrentMap的原因。如果改成HashMap，根据不同JDK版本的实现不同，多线程读取HashMap可能造成死循环（注意这不是HashMap的bug），必须引入同步机制。

  我就很好奇，为什么多线程读取HashMap可能造成死循环，我自己没有遇到过，因为我从来不在多线程的环境下使用HashMap（当然不排除可能我用的一些缓存组件内部实现用了）

  在Google上简单看了一些帖子的分析，基本是都是和HashMap扩容相关，大部分都是一边读一边写产生的问题，比如你是否听说过 HashMap 在多线程环境下操作可能会导致程序死循环?。我在学习HashMap源码的时候确实注意到过。但这样一看，难道说是描述不严谨么？

  干脆咱们一起看看源码：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; if ((e = first.next) != null) { if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }

  从我理解来看，我认为只是多线程读是不会出现死循环的，这里只是描述的不严谨罢了。

  果然看评论区给出了正确的描述：
  

  ]]> https://baofeidyz.com/2024/0139c0cf5db0/

  • 地图选型
  • 土耳其iCloud服务涨价：价格翻倍
  • 基于UnraidOS制作torrent文件并上传到PT

  ]]> baofeidyz's blog 折腾 AppleMusic 技术选型 周报 地图 Thu, 22 Aug 2024 16:00:00 GMT

  • 地图选型
  • 土耳其iCloud服务涨价：价格翻倍
  • 基于UnraidOS制作torrent文件并上传到PT

  地图选型

  常规来说在国内就是高德、百度、腾讯这三家，但是企业版授权还是比较贵的，如果只是一些小项目，对于地图只是一个展示的基础功能。目前这三家还没有提供细分产品和定价，对于此，可以考虑使用天地图

  土耳其iCloud服务涨价

  去年土耳其iCloud服务已经翻倍一次了，今年又翻倍，目前算下来价格：

  • 50GB 24.99里拉 5.26元
  • 200GB 79.99里拉 16.83元
  • 2TB 249.99里拉 52.61元

  涨了一倍的价格，并且是所有人全部涨价，不管是否是新订阅。价格优势越来越小，可能只有一个非云上贵州提供服务能让大家感到满意了。

  Apple官网价格查看：iCloud+ plans and pricing

  基于UnraidOS制作torrent文件并上传到PT

  本质上需要用到两个docker服务，一个是transmission，一个是jlesage/mediainfo。

  transmission主要用途是制作torrent文件，而jlesage/mediainfo是因为PT站要求需要获取对应的解析数据。

  制作种子文件非常简单，进入transmission容器的控制台，然后敲入以下命令：

  1	transmission-create 文件或文件绝对路径

  就可以了。

  获取媒体信息则是直接通过jlesage/mediainfo提供的WebUI，直接打开具体的文件，然后选择格式为TXT，复制即可。

  最后我们就按照PT站要求将种子文件提交到PT站做审核即可。

  ]]> https://baofeidyz.com/2024/7e11f68354a6/

  • 序列化（Kryo）
  • 发布了新的博客：Hashtable和HashMap的差别、个人影视库搭建方案分享
  • SPI：Service Provider Interface
  • SPI：Spring中的应用
  • 旁听Donald J.Trump和Elon Musk的live talking

  ]]> baofeidyz's blog Java 周报 序列化 Kryo Thu, 15 Aug 2024 16:00:00 GMT

  • 序列化（Kryo）
  • 发布了新的博客：Hashtable和HashMap的差别、个人影视库搭建方案分享
  • SPI：Service Provider Interface
  • SPI：Spring中的应用
  • 旁听Donald J.Trump和Elon Musk的live talking

  序列化

  Java本身有提供序列化和反序列化实现，但是在实际开发中发现大家很少使用。对于一些有可读性要求，前后端交互的场景，使用JSON序列化已成默认。

  我自己有维护一个任务组件，一开始也是采用JSON序列化，并且数据存到数据库以后还可以直接搜索和阅读。但后面随着需要支持的业务越来越复杂，JSON序列化没有办法支持类似BufferedImage这类对象的序列化和反序列化操作，后面就改用了Java序列化实现。

  最近在考虑将这个任务组件重写并开源，所以考虑在原来的基础上增加一些更好的选型。

  Kryo序列化

  Kryo 是我关注到的一个序列化选型。Kryo使用的是BSD-3-Clause许可协议，还是比较宽松的，对于我这个开源组件来说没有任何问题。

  性能和安全性方面因为有其他知名开源项目的使用，所以我也不担心这方面。相比之下，我更关心他所支持的序列化类型。

  我在Kryo项目的readme中查看到了这个链接：https://github.com/EsotericSoftware/kryo/blob/master/src/com/esotericsoftware/kryo/Kryo.java#L179 从这个代码来看：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

  addDefaultSerializer(byte[].class, ByteArraySerializer.class); addDefaultSerializer(char[].class, CharArraySerializer.class); addDefaultSerializer(short[].class, ShortArraySerializer.class); addDefaultSerializer(int[].class, IntArraySerializer.class); addDefaultSerializer(long[].class, LongArraySerializer.class); addDefaultSerializer(float[].class, FloatArraySerializer.class); addDefaultSerializer(double[].class, DoubleArraySerializer.class); addDefaultSerializer(boolean[].class, BooleanArraySerializer.class); addDefaultSerializer(String[].class, StringArraySerializer.class); addDefaultSerializer(Object[].class, ObjectArraySerializer.class); addDefaultSerializer(BigInteger.class, BigIntegerSerializer.class); addDefaultSerializer(BigDecimal.class, BigDecimalSerializer.class); addDefaultSerializer(Class.class, ClassSerializer.class); addDefaultSerializer(Date.class, DateSerializer.class); addDefaultSerializer(Enum.class, EnumSerializer.class); addDefaultSerializer(EnumSet.class, EnumSetSerializer.class); addDefaultSerializer(Currency.class, CurrencySerializer.class); addDefaultSerializer(StringBuffer.class, StringBufferSerializer.class); addDefaultSerializer(StringBuilder.class, StringBuilderSerializer.class); addDefaultSerializer(Collections.EMPTY_LIST.getClass(), CollectionsEmptyListSerializer.class); addDefaultSerializer(Collections.EMPTY_MAP.getClass(), CollectionsEmptyMapSerializer.class); addDefaultSerializer(Collections.EMPTY_SET.getClass(), CollectionsEmptySetSerializer.class); addDefaultSerializer(Collections.singletonList(null).getClass(), CollectionsSingletonListSerializer.class); addDefaultSerializer(Collections.singletonMap(null, null).getClass(), CollectionsSingletonMapSerializer.class); addDefaultSerializer(Collections.singleton(null).getClass(), CollectionsSingletonSetSerializer.class); addDefaultSerializer(TreeSet.class, TreeSetSerializer.class); addDefaultSerializer(Collection.class, CollectionSerializer.class); addDefaultSerializer(ConcurrentSkipListMap.class, ConcurrentSkipListMapSerializer.class); addDefaultSerializer(TreeMap.class, TreeMapSerializer.class); addDefaultSerializer(Map.class, MapSerializer.class); addDefaultSerializer(TimeZone.class, TimeZoneSerializer.class); addDefaultSerializer(Calendar.class, CalendarSerializer.class); addDefaultSerializer(Locale.class, LocaleSerializer.class); addDefaultSerializer(Charset.class, CharsetSerializer.class); addDefaultSerializer(URL.class, URLSerializer.class); addDefaultSerializer(Arrays.asList().getClass(), ArraysAsListSerializer.class); addDefaultSerializer(void.class, new VoidSerializer()); addDefaultSerializer(PriorityQueue.class, new PriorityQueueSerializer()); addDefaultSerializer(BitSet.class, new BitSetSerializer()); addDefaultSerializer(KryoSerializable.class, KryoSerializableSerializer.class);

  我感觉有一些些担忧呀，毕竟我的任务组件是没有限制对象类型的。不过Kryo支持自定义序列化实现方式，如果真的遇到了不支持的对象类型，也许我可以自己写一个然后合并给Kryo。

  这块如果要采用Kryo代替Java的序列化的话，我可能还得加一个单元测试来确认支持的对象范围。

  参考内容

  • 深入浅出序列化（2）——Kryo序列化

  SPI：Service Provider Interface

  从Java 1.6开始，引入了java.util.ServiceLoader类，我简单看了一下源码，有几个有意思的点分享一下：

  懒加载

  内部有一个private修饰的LazyIterator类

  扫描路径

  默认扫描路径前缀是META-INF/services/

  类加载的时候，有获取ExtClassLoader实例

  这个方法蛮有意思的，循环查找，直到prev为ExtClassLoader的实例。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

  /** * Creates a new service loader for the given service type, using the * extension class loader. * * <p> This convenience method simply locates the extension class loader, * call it <tt><i>extClassLoader</i></tt>, and then returns * * <blockquote><pre> * ServiceLoader.load(<i>service</i>, <i>extClassLoader</i>)</pre></blockquote> * * <p> If the extension class loader cannot be found then the system class * loader is used; if there is no system class loader then the bootstrap * class loader is used. * * <p> This method is intended for use when only installed providers are * desired. The resulting service will only find and load providers that * have been installed into the current Java virtual machine; providers on * the application's class path will be ignored. * * @param <S> the class of the service type * * @param service * The interface or abstract class representing the service * * @return A new service loader */ public static <S> ServiceLoader<S> loadInstalled(Class<S> service) { ClassLoader cl = ClassLoader.getSystemClassLoader(); ClassLoader prev = null; while (cl != null) { prev = cl; cl = cl.getParent(); } return ServiceLoader.load(service, prev); }

  我就很好奇，为什么他非要拿到extClassLoader，目前还没有找到答案。

  SPI：Spring中的应用

  其实Spring框架中也有用到SPI，对应的路径是META-INF/services/spring.factories，如果你在引入别人的jar包时，你就会发现很多都有这个spring.factories文件，这个就是Spring用于管理自动加载的。

  与Configuration注解的差别

  有@Configuration注解的类路径需要是@SpringBootApplication声明的扫描路径（不声明如果就是当前类及所有子路径）。

  所以我们如果要做一个组件，最好就是加上META-INF/services/spring.factories以便其他人集成

  文件内容模版

  1 2 3

  org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.baofeidyz.AbcdThreadPoolConfiguration,\ com.baofeidyz.AbcdServiceConfiguration

  旁听Donald J.Trump和Elon Musk的live talking

  你可以点这个链接回听。

  这件事发生在川普被枪击之后，也是被Twitter封禁之后第一次回归twitter平台，直接和Elon Musk开启talking。我听了一部分，可能就china、nuclear、develop fast这些地方有点记忆点，其他的也就是听了个寂寞。不过这么轻松就能直接参与历史事件，还是很值得记录一下。

  ]]> https://baofeidyz.com/2024/c6548447bec7/
  最近得益于阿里云盘的收割计划，大家对于个人影视库的搭建方案开启了新的探索，在此我也蹭蹭热点，分享一下我的个人影视库搭建方案。

  ]]> baofeidyz's blog 折腾 生活 折腾 生活 Tue, 13 Aug 2024 06:51:05 GMT
  最近得益于阿里云盘的收割计划，大家对于个人影视库的搭建方案开启了新的探索，在此我也蹭蹭热点，分享一下我的个人影视库搭建方案。

  方案简介

  19年那会做的还比较简单，emby+zimuzu就可以了。那会也发过博客：【技术宅拯救世界】emby+zimuzu打造家庭影院

  目前是自建的NAS存储，然后通过各种渠道收集媒体资源，最后再通过infuse扫库和观看。infuse不只是Apple TV端支持，iOS、iPadOS以及macOS也是支持的，所以在苹果全家桶的情况下，一个infuse就可以解决所有问题。

  自建NAS

  项目	型号	链接	备注
  操作系统	Unraid OS Basic	Unraid官网	购入价：33美元
  U盘	金士顿 32G USB2.0 CZ33	京东自营	购入价：35元，好像下架了
  机箱+电源	TANK	淘宝	电源是店家搭配的，购入价：1070元
  主板	ASUSTeK COMPUTER INC. PRIME H610M-E D4	淘宝	主板+CPU一起买的，购入价：1200
  CPU	Intel® Core™ i3-12100
  内存	威刚 16G DDR4 3200	京东自营	购入价：230元
  HDD存储硬盘	TOSHIBA 16T企业盘	京东自营	购入价：2200元
  SSD缓存盘	铨兴 C201 SATA 3.0 1TB	京东自营	购入价：287元

  踩坑一：主板和内存条不兼容

  我遇到过华硕主板和金士顿内存条不兼容的问题，会导致无法正常重启。解决办法只能是拔掉BIOS电池，然后进BIOS设置关闭快速启动后，再指定启动盘才可以启动。而拔BIOS电池需要拆掉所有的东西，真是非常痛苦的一段经历。

  我升级过BIOS到最新的版本，问题依然存在。

  我也寄修过华硕这块主板，华硕说主板是没有问题的，又给我寄回来了，说是检测一切正常，也没有复现我遇到的问题。中途也不给我打电话，直接就给我寄回来，我都是快递给我打电话才知道被原封不动寄回，结果就是问题依然存在，没有解决。

  最后的最后是我带着碰运气的想法买了一根威刚的内存条才解决问题。但是目前重启以后华硕的BIOS还是会报错，需要手动按F8选择启动盘，但至少不用拔BIOS电池，不用拆机了。

  我建议不要买华硕的主板。

  踩坑二：NAS系统选择

  我一开始也没有计划买Unraid，我想着用个开源的系统就好了，比如TrueNAS，甚至直接装个debian也可以。

  我是在配置home assistant的时候遇到的网络问题，折腾了我很长一段时间，断断续续可能有接近两周我都是折腾到半夜，后面实在是受不了了，就试用了一下Unraid，发现HA完全没问题，直接就可以用，然后发现所有我需要的都有，果断付费，多出来的时候我早点睡觉多好。

  没想到，最近一段时间还成了理财产品😂。

  听说U盘也可能存在兼容性问题，如果你也考虑Unraid，我是建议你直接抄我作业。

  媒体资源渠道

  人人

  已死，怀念一下。

  BT站

  RARBG，已关闭。目前我也没有在使用BT站了。

  PT站

  目前主力。

  PT站是相对于BT来说，划分出一个小圈子的种子分享站。多数都是邀请制，且有分享率要求（上传量/下载量）。但也正是因为对于分享率有要求，使得种子的下载速度非常快，跑满带宽是一件很轻松的事。

  PT的好处在于不会发生分享的链接被关闭的情况，且资源质量非常高，也不会出现恶心人的水印或者中间插播广告的情况。

  PT站门槛比较高，首先注册就能卡掉绝大数人。我这篇博客也不会涉及具体的PT站介绍，因为大部分PT站有要求不得公开宣传，否则会被封号。对于邀请问题，其实你在一些相对技术宅的论坛发帖求邀，留个邮箱会有大佬乐意给你的。邀请发帖的时候要说明自己有无公网IP，带宽上传速度是多少，硬盘大小，是否可7x24h待机，是否知晓PT站的新人审核制度等等。

  如果你不清楚审核制度则需要明确说明，一般就是给你再多发一个网址，自己看看就理解的事儿，千万不要不懂装懂，搞不好会连累邀请你的人。

  网盘资源

  网盘分享的速度一般都比PT更快，所以我用网盘的时候也非常多。

  我目前主力是使用TG频道、TG机器人等。

  网盘资源经常遇到加水印广告，视频播到中间部分突然插播菠菜广告的，所以一般PT有资源，我就不会选择网盘。

  资源管理方案

  PT资源管理

  Unraid OS本身是支持docker的，基于docker安装一个qbitorrent就可以完成对PT资源的管理，并且下载完成后会一直做种。

  网盘资源管理

  一开始我是直接使用alist挂载，然后infuse通过webdav协议挂载。

  后来infuse直接支持了阿里云盘，就直接挂载了，这个方案是最好的，尤其人在外面的时候，云盘保存一下马上就可以使用infuse播放（相对于阿里云盘自己的播放器可以免费观看更高的清晰度）。

  最近阿里云盘已经全面限速了，1080P都没办法流畅在线播放。所以目前的方案是alist挂载阿里云盘，同时也挂载NAS的本地磁盘，通过alist直接将阿里云盘中的资源复制到NAS本地磁盘即可。

  虽然速度只有500k，但是白天远程操作一下，晚上再观看并不影响。其他的网盘资源也是同样的方案，非常好用。

  播放器

  infuse，苹果所有终端都适配了，独一家的杜比解码授权，我是早期土耳其区的年付订阅用户，目前还是99里拉每年，算下来大概一年25元人民币。

  infuse使用TMDB服务做解析，PT站资源命名很规范没有任何问题，网盘资源需要自己修改调整。对于TMDB上没有的资源我会自己上去新建和编辑。

  远程观看解决方案

  Unraid OS中基于docker安装tailscale，然后配置上SSL证书，开启HTTPS访问即可解决，这块有规划详细一点的搭建博客，敬请期待。

  总结

  PT是主力，网盘打辅助，所有的网盘资源都通过alist直接复制到本地磁盘，通过tailscale+SSL在外也能安全访问家里的服务。

  播放全靠infuse，大部分资源都是杜比的，有一个授权解码很重要，目前是按年订阅中。

  ]]> https://baofeidyz.com/2024/eb322648f18b/

  • Hashtable不允许空值
  • Hashtable是线程安全的
  • 性能比HashMap差
  • 继承差异
  • 遍历差异
  • 一些题外话

  ]]> baofeidyz's blog 技术 Java Java基础 Mon, 12 Aug 2024 06:24:08 GMT

  • Hashtable不允许空值
  • Hashtable是线程安全的
  • 性能比HashMap差
  • 继承差异
  • 遍历差异
  • 一些题外话

  HashTable不允许空值

  这个是Hashtable的put方法源码：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  public synchronized V put(K key, V value) { // Make sure the value is not null if (value == null) { throw new NullPointerException(); } // Makes sure the key is not already in the hashtable. Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; @SuppressWarnings("unchecked") Entry<K,V> entry = (Entry<K,V>)tab[index]; for(; entry != null ; entry = entry.next) { if ((entry.hash == hash) && entry.key.equals(key)) { V old = entry.value; entry.value = value; return old; } } addEntry(hash, key, value, index); return null; }

  我简单查了一下校验的原因，可信度比较高的是因为Hashtable出现的比较早，是在Java 1.0引入的，发布于1996年1月，可能是为了确认get(key)方法返回null时，不是因为值为null而返回，而是因为真的没有这个key。

  而HashMap是在Java 1.2引入的，发布于1998年12月。Hashmap继承于AbstractMap

  Hashtable是线程安全的

  Hashtable主要的方法都增加了synchronized关键字，确保了线程安全，HashMap则没有。

  性能比HashMap差

  也是因为增加synchronized关键字

  继承差异

  HashMap继承的是AbstractMap，而`Hash

  遍历差异

  HashMap引入了fail-fast机制，如果迭代过程中被其他线程做了修改（除迭代器的remove方法外），会抛出ConcurrentModificationException

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  public final void forEach(Consumer<? super K> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e.key); } if (modCount != mc) throw new ConcurrentModificationException(); } }

  Hashtable因为用了同步机制，就不存在这个问题了

  一些题外话

  由于Hashtable几乎所有的方法都是同步的，所以实际开发中很少使用，而我自己则是从来没用过。需要多线程使用时，建议选择ConcurrentHashMap

  ]]> https://baofeidyz.com/2024/8b4b824ee5c2/

  • 新增两篇shell脚本：Git删除本地所有分支、Maven多模块时仅构建单个模块
  • 个人博客增加了RSS插件

  ]]> baofeidyz's blog 周报 hexo hexo-next Thu, 08 Aug 2024 16:00:00 GMT

  • 新增两篇shell脚本：Git删除本地所有分支、Maven多模块时仅构建单个模块
  • 个人博客增加了RSS插件

  给博客增加了RSS插件

  • 项目地址：https://github.com/hexojs/hexo-generator-feed

  安装及配置修改

  1	npm install hexo-generator-feed --save

  在hexo的_config.yml文件最末尾加上

  1 2 3 4 5 6 7 8 9 10 11 12 13

  feed: enable: true type: atom path: atom.xml limit: 20 hub: content: content_limit: 140 content_limit_delim: ' ' order_by: -date icon: icon.png autodiscovery: true template:

  此时你的RSS订阅已经部署成功，对应地址是你的域名/atom.xml，比如我的RSS订阅地址是https://baofeidyz.com/atom.xml

  修改hexo next配置增加按钮

  我的博客使用的是hexo next主题，对应项目地址是：https://theme-next.js.org/

  hexo next在两个位置提供了RSS订阅按钮的位置，分别是菜单和文章底部。

  • 菜单：

  1 2	menu: RSS: /atom.xml || fa fa-rss

  即可加上菜单位置的RSS订阅按钮，如下图所示：
  

  • 文章底部

  1 2	follow_me: RSS: /atom.xml || fa fa-rss

  我觉得没有太大必要，所以我并没有开启这个文章底部的订阅按钮，就不截图展示效果了，大家可以自行尝试。

  RSS订阅效果展示

  RSS订阅软件为Thunderbird

  

  ]]> https://baofeidyz.com/2024/638ccbb78dca/

  ]]> baofeidyz's blog 技术 Maven Shell Tue, 06 Aug 2024 06:28:32 GMT

  1	mvn clean package -U -Dmaven.test.skip=true -pl 子模块1的相对路径,子模块2的相对路径 -am -T 4 --settings ~/.m2/settings.xml

  如果你只有一个子模块，需要去掉间隔符号

  • -U：表示会强制更新带有SNAPSHOT标记的快照依赖
  • -Dmaven.test.skip=true：表示会跳过代码测试代码的编译和运行
  • -pl：意为project list，用于指定你需要构建的子模块
  • -am：意为also make，用于表示需要将子模块相关的依赖模块一起构建
  • -T：并发构建
  • --settings：指定具体的maven settings文件，可选参数

  ]]> https://baofeidyz.com/2024/7722782a22f5/

  ]]> baofeidyz's blog 技术 Git Shell Tue, 06 Aug 2024 06:09:58 GMT

  1	git branch | grep -v $(git branch --show-current) | xargs git branch -D

  ]]> https://baofeidyz.com/2024/938f9eb4796d/

  ]]> baofeidyz's blog 技术 数据库 Oceanbase Fri, 02 Aug 2024 02:25:48 GMT

  ORA-01843: not a valid month

  错误SQL

  1 2 3 4 5 6

  SELECT * FROM mytable WHERE mytable.xxx BETWEEN '2024-01-10 00:00:00' AND '2025-01-10 23:59:59'

  错误原因

  没有使用TO_DATE函数

  ORA-01810: format code appears twice

  错误SQL

  1 2 3 4 5 6

  SELECT * FROM mytable WHERE mytable.xxx BETWEEN TO_DATE('2024-01-10 00:00:00', 'yyyy-MM-dd HH:mm:ss') AND TO_DATE('2025-01-10 23:59:59', 'yyyy-MM-dd HH:mm:ss')

  错误原因

  Oracle不区分大小写，所以这里不能用yyyy-MM-dd HH:mm:ss，日期里面有mm，时间中也有mm就导致了这个错误。
  改成yyyy-mm-dd hh24:mi:ss即可

  参考

  • ORA-01810: format code appears twice
  • Oracle转换时间出现的问题：ORA-01810: format code appears twice

  执行计划查看方式

  这块官网文档有写：查看执行计划

  简单来说主要就是在SQL上加上EXPLAIN即可

  ]]> https://baofeidyz.com/2024/e342b7febf8f/

  前言：最近我在将自己写的一些组件开源，想要发布到maven中央仓库，结果发现网上很多的教程都已经过时，而官网的教程也有一定程度上的混沌，主要是部分文章已经过时导致的。给我这样的小白选手带来了一些麻烦，在我自己成功发布后决定总结一下整个流程以及中间遇到的问题分享出来。

  maven中央仓库的限制

  官网地址：https://central.sonatype.org/publish/requirements/

  1. 不允许发布快照；
  2. 必须有javadoc包；
  3. 必须有souce包：也就是你的代码是开源的，这也是为什么一些不开源jar包不选择中央仓库的主要原因，比如itext和aspose等
  4. 至少有.md5和.sha校验结果；
  5. 必须要使用GPG或者gpg签名；
  6. 必须有pom.xml文件：同时需要有正确的groupId、artifactId、version、name、description、url、licenses、developers、scm

  那么接下来我会详细讲解一下关于这些条件的。

  ]]> baofeidyz's blog 技术 Java maven Wed, 17 Jul 2024 09:32:24 GMT

  前言：最近我在将自己写的一些组件开源，想要发布到maven中央仓库，结果发现网上很多的教程都已经过时，而官网的教程也有一定程度上的混沌，主要是部分文章已经过时导致的。给我这样的小白选手带来了一些麻烦，在我自己成功发布后决定总结一下整个流程以及中间遇到的问题分享出来。

  maven中央仓库的限制

  官网地址：https://central.sonatype.org/publish/requirements/

  1. 不允许发布快照；
  2. 必须有javadoc包；
  3. 必须有souce包：也就是你的代码是开源的，这也是为什么一些不开源jar包不选择中央仓库的主要原因，比如itext和aspose等
  4. 至少有.md5和.sha校验结果；
  5. 必须要使用GPG或者gpg签名；
  6. 必须有pom.xml文件：同时需要有正确的groupId、artifactId、version、name、description、url、licenses、developers、scm

  那么接下来我会详细讲解一下关于这些条件的。

  不允许发布快照

  快照即snapshot，也就是说你pom.xml文件中的version中不能包含SNAPSHOT关键字

  必须有javadoc包

  在你的pom.xml文件中加上插件即可：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-javadoc-plugin</artifactId> <version>2.9.1</version> <executions> <execution> <id>attach-javadocs</id> <goals> <goal>jar</goal> </goals> </execution> </executions> </plugin> </plugins> </build> </project>

  其中插件的版本最好是直接使用最新的，你可以在这里查看最新的插件版本：maven-javadoc-plugin

  这样在最后使用maven来发布的时候，这个插件会自动帮你处理好javadoc的部分。当然，如果你的代码中不符合javadoc规范，则需要通过错误信息自行处理掉。

  必须有souce包

  和必须有javadoc包类似，也是通过插件来处理。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-source-plugin</artifactId> <version>2.2.1</version> <executions> <execution> <id>attach-sources</id> <goals> <goal>jar-no-fork</goal> </goals> </execution> </executions> </plugin> </plugins> </build> </project>

  插件最新版本见：maven-source-plugin

  至少有.md5和.sha校验结果

  和必须有javadoc包类似，也是通过插件来处理。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <build> <plugins> <plugin> <groupId>org.sonatype.central</groupId> <artifactId>central-publishing-maven-plugin</artifactId> <version>0.5.0</version> <extensions>true</extensions> <configuration> <publishingServerId>central</publishingServerId> <checksums>required</checksums> <deploymentName>记得修改这里，是你在中央仓库任务中的发布任务名称没有特别重要的意思</deploymentName> </configuration> </plugin> </plugins> </build> </project>

  插件最新版本见：central-publishing-maven-plugin

  同时这个插件也包含了直接发布到中央仓库的作用，后面会单独再讲到的。

  必须要使用GPG或者PGP签名

  和必须有javadoc包类似，也是通过插件来处理。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-gpg-plugin</artifactId> <version>3.2.4</version> <executions> <execution> <id>sign-artifacts</id> <phase>verify</phase> <goals> <goal>sign</goal> </goals> </execution> </executions> </plugin> </plugins> </build> </project>

  插件最新版本见：maven-gpg-plugin

  安装GPG

  除了配置maven插件之外，你还需要在本地安装gpg以及初始化自己的私钥、公钥，并且还需要将公钥推送到三方服务器上。
  这个是官网对应的介绍：https://central.sonatype.org/publish/requirements/gpg/

  我使用的是macOS + Homebrew的组合：

  1	brew install gpg

  生成密钥

  安装好gpg后，我们需要生成自己的私钥和公钥：

  1	gpg --gen-key

  需要输入自己的姓名、电子邮件地址和密码。同时此密钥的有效期默认为 3 年（官网文档没更新，现在默认已经有效期是3年）。

  当密钥过期以后用到这个密码来延长有效期。

  分发公钥

  使用命令查看自己的密钥key

  1	gpg --list-keys

  会拿到类似的结果：

  1 2 3 4 5 6

  ~ ❯ gpg --list-keys 16:06:40 [keyboxd] --------- pub xxx 2024-07-10 [SC] [有效至：2027-07-10] ABA2A06BB49B04E3B47616698B90791C18BFEF1E uid [ 绝对 ] baofeidyz <baofeidyz@gmail.com> sub xxx 2024-07-10 [E] [有效至：2027-07-10]

  可以看到这个pub一行最后有一串类似于UUID的内容，比如我的就是：ABA2A06BB49B04E3B47616698B90791C18BFEF1E，这个就是你的密钥key。

  再使用命令分发即可：

  1	gpg --keyserver keyserver.ubuntu.com --send-keys ABA2A06BB49B04E3B47616698B90791C18BFEF1E

  其中keyserver.ubuntu.com有几个替代品：

  • keyserver.ubuntu.com
  • keys.openpgp.org
  • pgp.mit.edu

  我自己用的keys.openpgp.org

  1	gpg --keyserver keys.openpgp.org --send-keys ABA2A06BB49B04E3B47616698B90791C18BFEF1E

  这是我的分发链接：https://keys.openpgp.org/vks/v1/by-fingerprint/ABA2A06BB49B04E3B47616698B90791C18BFEF1E

  分发后，你也可以在这个网页搜索自己的key：https://keys.openpgp.org/

  必须有pom.xml文件

  实际在发布的时候，必须有单独的pom.xml文件。
  但是我是用插件central-publishing-maven-plugin发布，所以我们只需要按照maven规范在项目中维护好pom.xml文件即可，打包的时候会由插件将pom.xml挪到正确的位置。

  关于pom.xml文件内容的维护涉及了很多内容，我把groupId、artifactId、version、name、description、url合并为常规内容，其他的则单独描述。

  我这里也把我自己的pom.xml文件链接放这里供大家参考。
  需要注意的是官网给出的示例已经过时了（截止2024年7月10日的信息）。

  常规部分

  开始这部分之前，你需要在中央仓库完成注册/登录并且需要验证属于自己的域。
  访问官网，在最右侧有一个Sign In按钮
  
  我建议是直接使用GitHub授权登录。有两个理由：

  1. 后续关于scm的声明时需要用到GitHub开源代码托管服务；
  2. 如果你没有自己的域名，你可以直接使用GitHub提供的；

  如果你像我一样，希望用自己的域名，则在登录完成后点击自己的名称，然后选择“View Namespaces”
  
  然后点击“Add Namespace”按照网页提示添加，然后去修改dns解析即可。需要注意的是，这里的Namespcae和域名是反的，比如我的域名是baofeidyz.com，则这里需要输入的是com.baofeidyz

  • groupId：这里则对应刚才的Namespcae即可
  • artifactId：组件ID，任意即可，比如我最近上传的组件PageHelperEnhance
  • version：版本号，比如1.0.0（记得不要带-SNAPSHOT，maven中央仓库不允许发布快照）
  • name：组件名称，比如PageHelperEnhance
  • description：描述，比如“Mybatis PageHelper组件的功能加强，封装了分页查询全部数据以及边查询边操作的生产者消费者模式。”
  • url：开源地址，比如：https://github.com/baofeidyz/PageHelperEnhance

  licenses

  开源协议，关于选择的问题，建议去看看GitHub提供的资料：choosing-the-right-license

  另外官网有提到两个授权，分别是The Apache License, Version 2.0和MIT License
  但是我个人觉得MIT和GPL3.0更重要些。

  MIT

  1 2 3 4 5 6 7 8 9

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <licenses> <license> <name>MIT License</name> <url>http://www.opensource.org/licenses/mit-license.php</url> </license> </licenses> </project>

  developers

  这个相对来说简单很多，就是注明一下开发者信息即可，你可以直接参考我的内容进行修改。

  1 2 3 4 5 6 7 8 9 10

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <developers> <developer> <name>baofeidyz</name> <email>baofeidyz@gmail.com</email> <url>https://baofeidyz.com</url> </developer> </developers> </project>

  • name写你自己的名称
  • email写你自己的电子邮箱地址
  • url则是你个人主页的地址，如果没有可以写你自己的GitHub主页，比如 https://github.com/baofeidyz

  如果有多个开发者，则多加几个developer节点即可

  scm

  官网介绍：https://central.sonatype.org/publish/requirements/#scm-information
  如果用的也是GitHub管理，那直接根据我的示例修改成你自己的信息即可：

  1 2 3 4 5 6 7 8

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <scm> <connection>scm:git:git://github.com/baofeidyz/PageHelperEnhance.git</connection> <developerConnection>scm:git:ssh://github.com:baofeidyz/PageHelperEnhance.git</developerConnection> <url>https://github.com/baofeidyz/PageHelperEnhance/tree/main</url> </scm> </project>

  • connection是git地址，一般在GitHub项目有一个绿色的code按钮，点击以后即可找到

  

  准备发布到maven中央仓库

  如果你已经全部满足了上述所有的要求，此时你就可以开始做最后的准备了。
  在官网登录自己的账号以后，选择“View Account”
  
  再点击“Generate User Token”
  
  此时你会拿到Username和Password两个参数，以及一个settings.xml示例
  

  如果你之前曾经发布过到自建maven仓库，相信后面要如何调整你已经非常清楚了。

  首先你的本地需要安装maven，下载解压以后会看到一个settings.xml文件，你需要做的就是将官网获取的Username和Password放到这个settings.xml文件中，参考位置如下：

  1 2 3 4 5 6 7 8 9 10 11 12

  <?xml version="1.0" encoding="UTF-8"?> <settings xmlns="http://maven.apache.org/SETTINGS/1.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 https://maven.apache.org/xsd/settings-1.2.0.xsd"> <servers> <server> <id>central</id> <username>xxxxx</username> <password>xxxx</password> </server> </servers> </settings>

  注意这里的id为central，实际上是对应着我在至少有.md5和.sha校验结果提到的内容：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <build> <plugins> <plugin> <groupId>org.sonatype.central</groupId> <artifactId>central-publishing-maven-plugin</artifactId> <version>0.5.0</version> <extensions>true</extensions> <configuration> <publishingServerId>central</publishingServerId> <checksums>required</checksums> <deploymentName>记得修改这里，是你在中央仓库任务中的发布任务名称没有特别重要的意思</deploymentName> </configuration> </plugin> </plugins> </build> </project>

  和这个publishingServerId是保持一致的。

  至此，所有的准备都OK了。

  发布到maven中央仓库

  在项目的pom.xml文件的同级目录中，执行

  1	mvn deploy

  即可，当然我更推荐指定settings.xml文件以避免一些没必要处理的问题

  1	mvn deploy --settings ~/.m2/settings.xml

  成功推送后，你还需要在官网 https://central.sonatype.com/publishing/deployments点击“Publish”正式发布。然后就可以在中央仓库搜索到自己的组件了。其他镜像库，比如阿里、mvnrepository.com等大概四个小时左右就会同步。
  
  
  

  也许你可能还会遇到一些问题，我简单例举几个以及处理方式：

  javadoc不通过

  如果没有长期使用javadoc规范，很可能你的注释内容会因为各种不标准导致javadoc不通过的，此时你只需要耐心的查看报错信息然后根据信息去排查解决问题就可以。

  推送到maven仓库以后被拒绝

  central-publishing-maven-plugin 这个插件默认是推送到maven仓库后，会将结果信息返回给你（此外你还可以在官网通知中查看），会明确的告知你缺少什么。
  你如果按照maven中央仓库的限制做了调整，相信这一步会很顺利。

  最后

  如果文章内容有不正确的地方，还请评论告知。如果你成功发布了项目也欢迎在评论区留下你的项目链接，非常欢迎大家宣传自己的开源项目！

  ]]> https://baofeidyz.com/2024/f2f4221aa1fd/ 查看PDF文件元数据的方法

  ]]> baofeidyz's blog 技术 PDF Mon, 17 Jun 2024 12:31:43 GMT 查看PDF文件元数据的方法

  方法一：直接修改后缀名

  这是简单的办法，将文件后缀名改成txt，然后用文本阅读器打开即可

  方法二：使用itext-rups

  工具类则是推荐itext7-rups，这是itext自己开源的阅读器

  方法三：写代码

  1 2 3 4 5 6 7 8 9 10 11

  String filePath = "xxx.pdf"; FileInputStream fis = new FileInputStream(filePath); byte[] content = new byte[fis.available()]; fis.read(content); fis.close(); String text = new String(content); System.out.println(text);

  PDF元数据解析

  2024年12月更新：

  • PDF元数据解析：流对象和过滤器

  挖坑，待填，需要的可以先看相关资料

  相关资料

  • ISO 32000-2:2020

    2024年12月9日更新：发现原链接打不开，然后这个PDF文档有版权保护，不允许互联网分享，所以自求多福吧。

  关联博客

  • PDF专栏
  ]]> https://baofeidyz.com/2024/af2009bc0c4b/ 项目中原本的方案中是将word保存了所有的修改并转为pdf做在线预览，但是在转换的过程中丢失了修改记录和批注信息。

  ❌ 方案一：使用aspose做word转pdf且同时保留修改记录 -收费

  我司目前只采购了aspose 20.11版本，基于这个版本简单尝试了一下，缺点如下：

  1. 只能完成删除记录的显示；
  2. 无法声明出操作人和操作时间；
  3. 单页word有概率被转成了两页；

  高版本的aspose有可能是支持的，我在官网有找到一份文档，需要的朋友可以去看看： Aspose Words export Comment and Revision author Aspose Words 导出注释和修订作者，但我司没有采购高版本aspose的计划，所以方案一我这里是放弃了。

  另外我附上我自己写的demo代码以供大家尝试：

  ]]> baofeidyz's blog 技术 Java 技术选型 Sun, 16 Jun 2024 11:57:28 GMT 项目中原本的方案中是将word保存了所有的修改并转为pdf做在线预览，但是在转换的过程中丢失了修改记录和批注信息。

  ❌ 方案一：使用aspose做word转pdf且同时保留修改记录 -收费

  我司目前只采购了aspose 20.11版本，基于这个版本简单尝试了一下，缺点如下：

  1. 只能完成删除记录的显示；
  2. 无法声明出操作人和操作时间；
  3. 单页word有概率被转成了两页；

  高版本的aspose有可能是支持的，我在官网有找到一份文档，需要的朋友可以去看看： Aspose Words export Comment and Revision author Aspose Words 导出注释和修订作者，但我司没有采购高版本aspose的计划，所以方案一我这里是放弃了。

  另外我附上我自己写的demo代码以供大家尝试：

  maven依赖:

  1 2 3 4 5 6 7 8 9 10

  <dependency> <groupId>com.aspose</groupId> <artifactId>aspose-pdf</artifactId> <version>20.11</version> </dependency> <dependency> <groupId>com.aspose</groupId> <artifactId>aspose-words</artifactId> <version>20.11</version> </dependency>

  这个jar包不在apache的maven仓库中，你可以在这里检查：https://repo.maven.apache.org/maven2/com/aspose/ 是没有aspose的任何包的，你需要在你的maven pom.xml文件中加上以下信息（位于project的子节点即可）：

  1 2 3 4 5 6 7

  <repositories> <repository> <id>AsposeJavaAPI</id> <name>Aspose Java API</name> <url>https://releases.aspose.com/java/repo/</url> </repository> </repositories>

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

  package com.baofeidyz.blog; import com.aspose.words.Comment; import com.aspose.words.Document; import com.aspose.words.EditingLanguage; import com.aspose.words.NodeCollection; import com.aspose.words.NodeType; import com.aspose.words.PdfLoadOptions; import com.aspose.words.PdfPageMode; import com.aspose.words.PdfSaveOptions; import com.aspose.words.Revision; import com.aspose.words.RevisionOptions; import com.aspose.words.RevisionsView; import com.aspose.words.ShowInBalloons; import java.io.InputStream; public class App { public static void main(String[] args) throws Exception { PdfLoadOptions loadOptions = new PdfLoadOptions(); loadOptions.getLanguagePreferences().setDefaultEditingLanguage(EditingLanguage.CHINESE_PRC); try (InputStream inputStream = App.class.getClassLoader().getResourceAsStream("test.docx")) { Document document = new Document(inputStream, loadOptions); for (Revision revision : document.getRevisions()) { revision.setAuthor("author"); } NodeCollection comments = document.getChildNodes(NodeType.COMMENT, true); for (Comment comment : (Iterable<Comment>) comments) { System.out.println("1= " + comment.getAuthor()); comment.setInitial(comment.getAuthor()); } document.getLayoutOptions().setShowParagraphMarks(true); document.getRevisions().get(0).getAuthor(); document.setRevisionsView(RevisionsView.ORIGINAL); document.getLayoutOptions().setShowComments(true); document.setTrackRevisions(true); RevisionOptions revisionOptions = document.getLayoutOptions().getRevisionOptions(); revisionOptions.setShowOriginalRevision(true); revisionOptions.setShowInBalloons(ShowInBalloons.FORMAT_AND_DELETE); revisionOptions.setShowRevisionBars(true); revisionOptions.setShowRevisionMarks(true); PdfSaveOptions saveOptions = new PdfSaveOptions(); saveOptions.setPreserveFormFields(true); saveOptions.setAdditionalTextPositioning(true); saveOptions.setCreateNoteHyperlinks(true); saveOptions.setDisplayDocTitle(true); saveOptions.setExportDocumentStructure(true); saveOptions.setOpenHyperlinksInNewWindow(true); saveOptions.setPageMode(PdfPageMode.USE_OUTLINES); saveOptions.setPrettyFormat(true); document.save("target/result.pdf", saveOptions); } } }

  ❌ 方案二：采用kkFileView -免费，使用前注意开源协议

  kkFileView在国内还算是被用得比较多，且做的比较简单的开源服务，基本上部署一个docker就可以快速搞定。

  但经过研究后发现，kkFileView在针对word预览这点上，还是基于word转pdf实现的，且自身没有提供更多的参数，默认转换结果是没有批注和修订信息的。

  ✅ 方案三：基于NTKO和WPS(NPAPI)方案直接预览word -收费

  NTKO -收费

  NTKO是重庆软航科技有限公司提供的文档插件，其主要是提供web在线编辑word功能。老版本只能支持IE浏览器，在新版本（平台版Plus-2019）中已经支持了Chrome（⚠️ 只支持了32位的Chrome）等浏览器。

  NTKO和aspose一样，也是需要采购的，采购完成以后NTKO会给出详细的开发文档。其实现原理就是利用插件在IE中直接打开一个word编辑器，操作界面和WPS或者Office的word一致（取决于你本地电脑上有WPS还是word）

  我这里就不贴具体的开发教程了，你能知晓大概情况就行，如果确定要用NTKO建议直接联系对方商务索要试用版再决定是否采购。

  WPS（NPAPI）-接口免费但需要专业版WPS

  贴一下维基百科的介绍：
  NPAPI：Netscape Plugin Application Programming Interface， 是一个跨平台的通用浏览器插件应用程序接口。1995年由网景公司发布，应用于网景导航者2.0版本，但其他浏览器很快也跟进支持，成为一个共通的插件标准，与微软的ActiveX形成竞争关系。
  2014年11月，Google宣布Chrome将于2015年1月默认屏蔽NPAPI插件，9月份会完全移除支持，以鼓励开发者和用户转用HTML5、Chrome API或Google Native Client等新技术取代NPAPI。虽然Google曾经提出了名为PPAPI（Pepper Plugin API）的解决方案，但没有得到其它厂商的普遍支持。

  WPS(NPAPI)是wps专业版提供的接口，web应用可以通过NPAPI与WPS应用进行交互。但NPAPI在高版本的浏览器中已经被移除。庆幸的是信创环境中的浏览器基本保留了NPAPI

  关于这个模式是可以在WPS官网找到的资料的，地址：https://open.wps.cn/previous/docs/client/wpsLoad

  
  官网也给出了代码示例

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  <!DOCTYPE   html > <html  lang = "en" > <head>      <meta  charset = "UTF-8" >      <title> wps二次开发演示  </title> </head> <body>      <object  type = "application/x-wps"  width = "1024"  height = "768"  id = "wps" ></object>      <!--通过类型 “application/x-wps” 来加载WPS浏览器NPAPI插件，并传递宽高值-->      <script  type = "text/javascript" >          //来获取wps的插件对象          var obj  = document.getElementById( "wps" );          //获取WPS对象树的根节点，后续功能调用都是根据 Application 逐步得到的          var Application  = obj.Application;          //创建一个新的空白文档          Application.createDocument( "wps" );          //获取文档内容区域          var range   = Application.ActiveDocument.Content ;          // 在文档内容区域插入一个3行5列的表格，设置表格显示边框          Application.ActiveDocument.Tables.Add(range, 3, 5).Borders.Enable = 1 ;      < /script> </body> </html>

  我有使用奇安信可信浏览器（基于麒麟OS）验证：
  
  需要强调的是必须要使用专业版的wps，另外这个方案还有一个缺点就是能用的API几乎没有，也没有找到什么有效的文档，纯靠自己摸索

  1 2	this.wpsEditor = document.getElementById('wps').Application; this.wpsEditor.openDocumentRemote(url, readonly);

  如果你知道更多的资料，还请在这篇博客下方评论补充，感谢。

  其他选型

  • WPS WebOffice
  • OnlyOffice
  • Office 365 online
  ]]> https://baofeidyz.com/2024/a6609d7716b6/
  ]]> baofeidyz's blog 折腾 摄影 生活 折腾 摄影 生活 Fri, 31 May 2024 11:37:10 GMT

  在v站上看到一篇帖子分享了开源项目Gallery-Portfolio，看了一下demo感觉蛮不错的，可以展示快门、光圈和ISO信息。
  这个项目部署需要用到 vercel 、Cloudflare R2，当然如果你有自己的域名会更好。

  第一步，项目调整

  因为项目本身有一些文字描述、页面标题等不支持动态设置，所以你觉得介意的话就得自己调整，这需要你有一定的开发知识。

  我自己也有简单调整一些文字，默认主题也改成了dark模式，你可以在这里看看效果 baofeidyz’s gallery

  项目本身的readme写的很详细，建议先看看readme，然后我这里补充几点：

  1. nodejs安装方法：https://nodejs.org/en/download/package-manager
  2. 新建的.env文件不要提交。默认fork操作后的权限都是public的，所以不要提交这个文件以避免Cloudflare R2的密钥被盗用

  另外，如果你没有安装node.js你也可以不用拉取，善于利用GitHub提供的code space是更好的办法，关于code spaces可以看看https://docs.github.com/en/codespaces

  第二步，申请免费的Cloudflare R2

  你需要自己注册Cloudflare账号，如果已经有那么就直接复用就可以。

  创建一个单独的桶，然后我建议是上传包含照片的文件夹，任意上传一张先试试，自己知道咋回事以后再尝试继续上传即可。

  桶创建好以后，还需要创建“R2 API令牌”，需要注意的是，Gallery-Portfolio有一个压缩照片生成缩略图的功能，所以你在创建R2 API令牌的时候，需要选择“对象读和写”的权限，“指定存储桶”为刚才创建的那个桶，TTL选择永久。

  在本地填好.env文件，按照readme给出的方法测试一下。

  第三步，部署到vercel

  简单描述一下吧，你需要注册一个账号，然后绑定你的GitHub账号，然后就可以一键部署了。
  部署的时候会有一个地方填写环境变量，你不用一个一个拷贝，你把整个.env文件的内容粘贴一下就可以了。

  可选一，去掉多余的exif信息

  安装exiftool工具，官网地址：https://exiftool.org

  macOS可以使用homebrew安装：

  1	brew install exiftool

  安装完成以后，可以使用以下脚本去除extif信息以保证隐私安全

  1	exiftool -all= -tagsFromFile @ -ExposureTime -ISO -ApertureValue -FNumber *.jpg

  同时我自己还加上了一个版权信息，完整的脚本如下

  1	exiftool -all= -tagsFromFile @ -ExposureTime -ISO -ApertureValue -FNumber -copyright="© 2024 baofeidyz@gmail.com" *.jpg

  每个相机厂商的exif信息的关键字可能有所不同，对于你想要保留的快门时间、ISO、光圈等信息可能与我给出的关键字是不同的，你可以通过

  1	exiftool -s xxx.jpg

  来获取详细的关键字，然后再调整为你自己的脚本即可

  可选二，增加水印

  为了避免有人不经过我的允许拿去商用，我在每张照片的正中增加了水印，用的是Lightroom批量处理。

  ]]> https://baofeidyz.com/apple-music-qa2/
  baofeidyz's blog Apple Music AppleMusic Thu, 12 Oct 2023 05:24:52 GMT

  操作步骤

  ⚠️ 警告：不要先绑定礼品卡，在下面的步骤中我有说明何时绑定

  🔔 提示：刚开始使用时，不建议登录iCloud。只需要登录app store就可以订阅Apple Music，后期稳定以后再考虑使用iCloud。这一步骤不是必须，但有可能会因为你登录了iCloud导致封控等级变高，所以请先不要直接登录iCloud

  

  首先看第一张图，我们打开Apple Music，在登录了土耳其Apple ID帐号后能看到激活页面有一个订阅按钮（Redeem Now）。

  在我们点了订阅按钮以后，由于我们的账户没有激活iTunes，所以我们会看到一个弹窗提示。这里大概的意思是“你的Apple ID还没有在iTunes商店中使用过，请点击review按钮去登记”，所以我们直接点击弹窗中的Review按钮跳转去登记即可。

  

  点击订阅按钮以后，需要输入密码

  

  在新的页面中，我们会看到一个苹果媒体协议的内容，我们默认勾选Agree to Terms and Conditions就行了

  

  关于这个最上面这个信用卡和手机号两个选项，经过我个人的实测是可以不填的，所以不建议大家去选中。选中以后就会变成必填。

  如果不小心点到了，有两种解决方案：

  1. 点击左上角的“Back”，返回到第一张图的状态，点击Redeem Now按钮重新走流程即可；

  2. 选择Mobile Phone，使用国内手机号也是可行的（我没有实测，是网友反馈给我的） 之前确实可以，现在是完全不行了

  要在这个弹窗中点击按钮，然后随便输入一个土耳其的地址和手机号即可（在之前的文章中，我有给出一个特定的值，已确认那个地址信息会被苹果封控，请勿再用）。 请使用三方服务网站提供的土耳其地址：https://www.meiguodizhi.com/tr-address 或者自行在Google地图中查找一个地址信息进行填写。

  这个时候就可以绑定礼品卡重新操作去订阅Apple Music服务了。

  如果你此时发现你必须要输入手机号或者信用卡，这意味着你已经被风控了。
  你可以选择：

  1. 打电话给中国大陆的Apple支持（只能电话），就直说你无法购买App Store中的收费应用即可，一般等待24小时后就可以了
  2. 更复杂的解决方案，这个方案我就不分享了，不然会很快被和谐（实在是需要的话，你可以通过我的闲鱼账号与我取得联系，但这会存在一些费用）

  点我跳转到闲鱼
  如果闲鱼链接失效，可以直接搜索用户“土耳其礼品卡”，会员名x开头，7结尾，粉丝数量大于150的就是我了

  背景（原因）

  这一章节是故意放到后面的，便于大家直接根据前文操作。 对于一些比较感兴趣的朋友，则可以继续阅读

  今日（2023年10月12日）有朋友遇到了需要绑定信用卡或者土耳其手机号的问题，在尝试付费订阅Apple Music时，苹果弹出需要绑定信用卡或手机号的弹窗，且此时为必选，无法跳过。如下图，“Credit/debit card”是默认勾选上的，无法取消。

  

  这与我之前发布的文章《Apple Music激活时遇iTunes注册弹窗的解决方案》是不同的，当时这个页面甚至还可以绑定+86的手机号，而现在只能绑定+90（土耳其）的手机号了。

  当然最后我还是给这位朋友解决的，但是操作方法过于复杂，就不多讲了，说出来可能一会儿就死了。

  ]]> https://baofeidyz.com/apple-music-qa1/

  2023年10月12日更新：文章内容已过期，请移步到 《新注册土耳其Apple ID订阅Apple]]> baofeidyz's blog Apple Music AppleMusic Sun, 20 Aug 2023 05:42:09 GMT

  2023年10月12日更新：文章内容已过期，请移步到 《新注册土耳其Apple ID订阅Apple Music详细操作步骤，新手一定要看！》

  最近有朋友在激活Apple Music服务时候遇到因新注册Apple ID没有激活iTunes帐户产生了一些问题，这篇文章主要是更详细的解决方案。

  

  首先看第一张图，我们打开Apple Music，在登录了土耳其Apple ID帐号后能看到激活页面有一个订阅按钮（Redeem Now）。

  在我们点了订阅按钮以后，由于我们的账户没有激活iTunes，所以我们会看到一个弹窗提示。这里大概的意思是“你的Apple ID还没有在iTunes商店中使用过，请点击review按钮去登记”，所以我们直接点击弹窗中的Review按钮跳转去登记即可。

  

  点击订阅按钮以后，需要输入密码

  

  在新的页面中，我们会看到一个苹果媒体协议的内容，我们默认勾选Agree to Terms and Conditions就行了

  

  

  关于这个最上面这个信用卡和手机号两个选项，经过我个人的实测是可以不填的，所以不建议大家去选中。选中以后就会变成必填。

  如果不小心点到了，有两种解决方案：

  1. 点击左上角的“Back”，返回到第一张图的状态，点击Redeem Now按钮重新走流程即可；

  2. 选择Mobile Phone，使用国内手机号也是可行的（我没有实测，是网友反馈给我的）

  要在这个弹窗中点击按钮，然后随便输入一个土耳其的地址和手机号即可，我这里提供了一个参考数据：

  1 2 3 4

  Street: Gevhernesibe Postcode: 38010 City: İstasyon Phone: 262 6560404

  ]]> https://baofeidyz.com/2023/9e27261d88ca/

  2024年12月4日更新：这个方案最终被抛弃了，建议大家直接使用 baofeidyz's blog macOS aTrust easyconnect Sun, 28 May 2023 16:00:00 GMT

  2024年12月4日更新：这个方案最终被抛弃了，建议大家直接使用 https://github.com/docker-easyconnect/docker-easyconnect 即可

  aTrust是深信服原easyconnect的升级产品，重点打造了一个“零信任”的概念，就是这个概念让我头皮发麻，其在官网直接挂着

  终端检测深入：支持进程级检测，可发现和阻止终端上非可信应用进程；在登录时、每一次访问业务时，对终端环境持续进行检测和认证，确保终端合规。

  

  这和病毒有什么差别么？所以我当然不能让这种糟粕运行在我的macOS宿主机上，于是我开始了折腾之旅。

  第一步，申请个人免费的vmware

  这个申请的方法大家可以在网上搜一下，有很多详细的图文教程，我后面会考虑补充一篇博客，但现在没时间搞。

  当然你也可以试试免费的Oracle VM VirtualBox，理论上来说也是一样可用的。

  第二步，下载debian 11的镜像文件

  我要特别讲一下为什么要下载debian 11，这是因为atrust官方提供的linux安装包特别强调了自己支持的是国产化的uos和麒麟os，但是咱们下载下来以后是一个deb文件，经过我自己测试，将deb包转为rpm包以后，在centos 7/centos 7.5/centos 8上都无法安装。

  当然我不排除是我自己操作有问题，大家如果特别喜欢用centos的，可以考虑自己折腾一下。但是centos已经不维护了，在使用过程中会有一些问题。

  经过我自己的测试，debian 11是可以使用的。

  debian 11的镜像推荐大家用BT种子的方式，实测比直接通过镜像站下载的速度更快，但请不要使用迅雷这类只下载不上传的“吸血”软件。
  BT种子官网下载地址：debian-11.6.0-amd64-DVD-1.iso 其他版本的镜像大家可以自行在官网查找

  补充信息：BT下载软件推荐qbittorrent，请在下载成功以后保持至少24小时运行时间以供其他人从您本地获取文件。如果您有NAS服务器那就更好
  请不要使用迅雷这类只下载不上传的“吸血”软件

  第三步，使用vmware引导安装debian 11

  这里我就不写具体的操作步骤了，请注意：

  1. 虚拟机网络要选择桥接（这非常重要）
  2. 你需要安装桌面才能打开atrust登录你的账号
  3. 语言选择的时候直接选择中文，否则时区在启动后修改比较麻烦，很可能导致无法使用apt-get update更新

  可能会遇到的问题

  无法执行apt-get update或者是速度较慢

  可以改用镜像源，修改/etc/apt/sources.list文件的内容，这里用aliyun举例：

  1 2 3 4 5 6 7 8

  deb https://mirrors.aliyun.com/debian/ bullseye main non-free contrib deb-src https://mirrors.aliyun.com/debian/ bullseye main non-free contrib deb https://mirrors.aliyun.com/debian-security/ bullseye-security main deb-src https://mirrors.aliyun.com/debian-security/ bullseye-security main deb https://mirrors.aliyun.com/debian/ bullseye-updates main non-free contrib deb-src https://mirrors.aliyun.com/debian/ bullseye-updates main non-free contrib deb https://mirrors.aliyun.com/debian/ bullseye-backports main non-free contrib deb-src https://mirrors.aliyun.com/debian/ bullseye-backports main non-free contrib

  然后再执行apt-get update即可

  如果你一直遇到更新失败，你可以按照这个检查顺序：

  1. ping mirrors.aliyun.com 看看能否ping通网络
  2. 检查 ping mirrors.aliyun.com 返回的IP是否是宿主机可以ping通的IP，以此确认是不是dns解析存在问题。存在问题可以通过修改debian 11上的/etc/hosts文件来解决
  3. 检查时区/时间是否正确

  第四步，在debian 11中安装atrust

  atrust下载客户端时，选择amd 64 麒麟Kylin即可，官网似乎没有找到下载介绍页，这个地址应该是有各个团队/企业的VPN登录页提供的
  

  下载完的deb安装包，可以通过scp命令直接传输到debian中，当然也可以使用一些sftp客户端

  安装deb时，需要带上相关的依赖，你可以执行

  1	sudo apt-get -f install atrust.deb

  debian 11默认安装过程中没有开启root账号的ssh远程登录配置，你得去把这个打开。可参考：debian 开启root账号远程ssh登录
  或者你直接在虚拟机页面中执行

  第五步，debian开启路由转发

  通过修改/etc/sysctl.conf文件中的net.ipv4.ip_forward的值改为1，并执行sysctl -p使得配置生效即可
  再把debian的防火墙关闭即可

  第六步，macOS宿主机修改路由a

  1	sudo route add 1.0.0.0/8 【这里写上debian虚拟机的IP地址】

  这样就可以了

  1.0.0.0/8这个是我随便写的，如果你们用的是192，或者172的开头的IP地址，那么就是192.0.0.0/8或者172.0.0.0/8。
  当然如果你本地的IP地址就是192开头的，那么你可能需要拆得更细致一点。假设你本地的IP地址是192.168.1.100，你的内网地址是192.168.31开头，那么你的shell脚本就应该是

  1	sudo route add 192.168.32.0/24 【这里写上debian虚拟机的IP地址】

  这个地方需要你对网络有一定的了解，添加成功以后可以使用telent命令确认一下是否能通特定的端口

  此外你还需要注意两点：

  1. 这个debian虚拟机用的是桥接模式，所以每次连接新的路由器可能会拿到不同的IP，这时候你需要删掉之前的路由，然后加上新的路由

     1	sudo route delete 1.0/8

  2. 对于内部使用域名访问的服务，则需要修改macOS宿主机的hosts文件，或者你本地自建一个dns服务来处理

  这样做了以后，不管你是ping还是 telnet 还是 curl 或者是socket连接都可以无感体验，debian 11推荐1c1g的配置即可，肯定会比你直接在macOS宿主机上登录atrust会耗电一些。如果有条件的话，也可以把debian 11部署到其他的电脑上。

  其他你可能需要了解的

  macOS宿主机更换网络以后如何处理？

  我尝试过单独重启网络

  1	sudo systemctl restart networking

  但实际没有效果，具体原因我暂时也没时间去搞了，我目前是通过重启debian 11来解决的

  1	sudo systemctl reboot -i

  为什么不使用docker而选择虚拟机？

  macOS上的docker本质上也是一个运行在虚拟机中的，并且docker在官网已经明确说明macOS上的docker服务无法实现从宿主机到docker容器的通信
  

  GitHub上也有相关的解决方案（docker-connector），如果你感兴趣的话，你可以动手尝试一下。docker安装debian 11以后，安装一个vnc server即可解决atrust客户端登录的问题，其他操作应该和我这篇博客的方法相差不大

  ]]> https://baofeidyz.com/2023/69cd795b27a2/ Jetcache踩坑合集

  写在前面

  本文主要是记录个人在使用jetcache时遇到的一些问题以及相应的解决方案，次之是将这些问题和解决方案发布到互联网中希望能帮助到一些人，如果觉得文章写得还不错，可以点赞收藏以鼓励我继续更新博客，这将对我非常重要。

  流水账子标题中重复带上jetcache关键字主要是为了提高搜索的准确性，本身文章上下文已足够表达含义，但是为了优化搜索情况特意加上的。

  踩坑流水账

  jetcache默认返回值为null时候，不会缓存

  这个是jetcache的默认策略，我之所以遇到这个问题是我自己写的测试代码时直接返回了null，我误认为是我spring aop配置有问题，导致缓存没有生效，实则是jetcache默认策略。

  在com.alicp.jetcache.anno.Cached注解中有一个属性cacheNullValue，默认值为false，表示不缓存空值。

  jetcache不支持模糊清空缓存

  这点其实在GitHub issue清单中有好几个issue 都是与这个问题相关的，如果你也是从Spring Cache转到jetcache，由于缺少模糊清空缓存，会导致整个系统原有的实现都必须调整。

  这个特性主要影响到缓存的数据是一个列表或者是一整颗树的情况，当列表或树中部分值更新以后，这个列表的缓存或树的缓存没有办法更新。

  jetcache多节点缓存清空需要先有@Cached注册

  ]]> baofeidyz's blog 技术 Java jetcache Sun, 28 May 2023 01:00:00 GMT Jetcache踩坑合集

  写在前面

  本文主要是记录个人在使用jetcache时遇到的一些问题以及相应的解决方案，次之是将这些问题和解决方案发布到互联网中希望能帮助到一些人，如果觉得文章写得还不错，可以点赞收藏以鼓励我继续更新博客，这将对我非常重要。

  流水账子标题中重复带上jetcache关键字主要是为了提高搜索的准确性，本身文章上下文已足够表达含义，但是为了优化搜索情况特意加上的。

  踩坑流水账

  jetcache默认返回值为null时候，不会缓存

  这个是jetcache的默认策略，我之所以遇到这个问题是我自己写的测试代码时直接返回了null，我误认为是我spring aop配置有问题，导致缓存没有生效，实则是jetcache默认策略。

  在com.alicp.jetcache.anno.Cached注解中有一个属性cacheNullValue，默认值为false，表示不缓存空值。

  jetcache不支持模糊清空缓存

  这点其实在GitHub issue清单中有好几个issue 都是与这个问题相关的，如果你也是从Spring Cache转到jetcache，由于缺少模糊清空缓存，会导致整个系统原有的实现都必须调整。

  这个特性主要影响到缓存的数据是一个列表或者是一整颗树的情况，当列表或树中部分值更新以后，这个列表的缓存或树的缓存没有办法更新。

  jetcache多节点缓存清空需要先有@Cached注册

  这个是jetcache比较新的特性了，利用了CacheMonitor接口，并且在这个的基础上抽象了一个com.alicp.jetcache.support.BroadcastManager支持了更多的中间件，并且对于循环通知的问题有一个很好的解决方案。

  但是jetcache只考虑到了同一份代码多节点部署的情况，我的实际应用场景比这个更复杂一些。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  private void processCacheMessage(CacheMessage cacheMessage) { if (sourceId.equals(cacheMessage.getSourceId())) { return; } Cache cache = cacheManager.getCache(cacheMessage.getArea(), cacheMessage.getCacheName()); if (cache == null) { logger.warn("Cache instance not exists: {},{}", cacheMessage.getArea(), cacheMessage.getCacheName()); return; } Cache absCache = CacheUtil.getAbstractCache(cache); if (!(absCache instanceof MultiLevelCache)) { logger.warn("Cache instance is not MultiLevelCache: {},{}", cacheMessage.getArea(), cacheMessage.getCacheName()); return; } Cache[] caches = ((MultiLevelCache) absCache).caches(); Set<Object> keys = Stream.of(cacheMessage.getKeys()).collect(Collectors.toSet()); for (Cache c : caches) { Cache localCache = CacheUtil.getAbstractCache(c); if (localCache instanceof AbstractEmbeddedCache) { ((AbstractEmbeddedCache) localCache).__removeAll(keys); } else { break; } } }

  在这个方法中，是直接通过cacheManager实例去获取的，

  当然这个问题也很好解决，你可以把这个模块的代码抽取出来，新建maven的module即可解决。

  又或是直接增加@Cached注解声明即可。

  jetcache的key必须是一个EL表达式的key，不能是固定字符串

  不太确定是不是jetcache特意为之，但是在使用过程中稍微注意一下即可

  jetcache在遇到参数是集合的时候，key不可以是EL表达式

  在这个方法 中，你可以看到当@CacheInvalidate中的multi属性声明为true时，可以看到调用了一个toIterable方法，而这个方法的实现则是

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  private static Iterable toIterable(Object obj) { if (obj.getClass().isArray()) { if (obj instanceof Object[]) { return Arrays.asList((Object[]) obj); } else { List list = new ArrayList(); int len = Array.getLength(obj); for (int i = 0; i < len; i++) { list.add(Array.get(obj, i)); } return list; } } else if (obj instanceof Iterable) { return (Iterable) obj; } else { return null; } }

  只能说jetcache支持了EL表达式，但是又没有完全支持。

  ]]> https://baofeidyz.com/apple-music/

  2025年7月29日更新：

  1. 去掉了家庭组的信息，我目前没有家庭组提供，建议大家自己成组
  2. 更新了部分已过期的信息，比如土耳其里拉的价格
  3. 删除了已失效的百度手机助手提供的Apple Music安卓版链接
  4. 新增了Apple Music安卓旧版本客户端123盘的分享链接
  5. 迁移了博客《Apple Music激活时遇iTunes注册弹窗的解决方案》和《新注册土耳其Apple ID订阅Apple Music详细操作步骤，新手一定要看！》
  6. 更新了闲鱼链接

  2024年7月5日更新：

  1. 原帖在这里：https://baofeidyz.hashnode.dev/apple-music
  2. 调整部分过时的内容，新增了iCloud云盘链接（阿里云盘不让分享apk文件，所以先暂时拿iCloud云盘用一下）

  2023年10月12日更新：
  很抱歉，就目前来看苹果已经在逐步收紧了，如果还没上车的朋友请尽快上车了，后期可能注册和订阅都将变的越来越困难，详细操作步骤我已经单独更新了一篇博客，请务必查看！链接：《新注册土耳其Apple ID订阅Apple Music详细操作步骤，新手一定要看！》

  2023年7月23日更新：
  很抱歉，就我今天测试结果来看，至少从今天（也许很早之前）苹果已经改为免费一个月了，博客原标题中的“-免费六个月”部分已修改为“每月最低不到2元”（目前家庭订阅是29.99里拉，约等于8元，家庭订阅最多可以六人，平均算下来人均不到1.4元）。此外，部分平台由于文章无法再编辑，已尽量通过评论区的方式告知，希望您理解。

  ]]> baofeidyz's blog Apple Music AppleMusic Fri, 19 May 2023 03:41:52 GMT

  2025年7月29日更新：

  1. 去掉了家庭组的信息，我目前没有家庭组提供，建议大家自己成组
  2. 更新了部分已过期的信息，比如土耳其里拉的价格
  3. 删除了已失效的百度手机助手提供的Apple Music安卓版链接
  4. 新增了Apple Music安卓旧版本客户端123盘的分享链接
  5. 迁移了博客《Apple Music激活时遇iTunes注册弹窗的解决方案》和《新注册土耳其Apple ID订阅Apple Music详细操作步骤，新手一定要看！》
  6. 更新了闲鱼链接

  2024年7月5日更新：

  1. 原帖在这里：https://baofeidyz.hashnode.dev/apple-music
  2. 调整部分过时的内容，新增了iCloud云盘链接（阿里云盘不让分享apk文件，所以先暂时拿iCloud云盘用一下）

  2023年10月12日更新：
  很抱歉，就目前来看苹果已经在逐步收紧了，如果还没上车的朋友请尽快上车了，后期可能注册和订阅都将变的越来越困难，详细操作步骤我已经单独更新了一篇博客，请务必查看！链接：《新注册土耳其Apple ID订阅Apple Music详细操作步骤，新手一定要看！》

  2023年7月23日更新：
  很抱歉，就我今天测试结果来看，至少从今天（也许很早之前）苹果已经改为免费一个月了，博客原标题中的“-免费六个月”部分已修改为“每月最低不到2元”（目前家庭订阅是29.99里拉，约等于8元，家庭订阅最多可以六人，平均算下来人均不到1.4元）。此外，部分平台由于文章无法再编辑，已尽量通过评论区的方式告知，希望您理解。

  ---

  写在前面的话： 本文为了照顾更多的人，写了很多的内容，如果你只是想要确切的方法请滑到相应的章节即可。

  为什么要使用Apple Music？

  1. 界面简洁
  2. 一次订阅可收听曲库中所有的歌曲，不存在二次收费
  3. 交互体验非常棒
  4. 较于Spotify价格更低

  一定要用iPhone才能使用Apple Music吗？

  当然不是，Apple Music目前除了苹果全家桶的支持以外，还支持安卓手机、网页、智能电视、游戏主机（PS5和XBOX）、Roku电视棒以及Windows PC

  你可以在这个Apple Music官网的最下方找到所有设备支持的清单，特别说明的是，即便你的安卓手机没有GMS（Google套件）也可以使用Apple Music，你可以直接请求以下地址安装：

  对于只有安卓/Android设备的朋友需要注意一点是新版本的客户端移除了礼品卡绑定入口，需要使用低版本的客户端才可以。绑定完了以后再换回新版或者Google play版即可。
  同时也建议大家在绑定礼品卡的时候最好是一次性搞定一年左右的比较合适。

  • iCloud云盘：iCloud_Apple_Music
  • 123盘：AppleMusic-3.6.0-2021-07-27.apk

  

  为什么要使用土耳其区的Apple music？

  这一章节的内容主要是向你阐述为什么要选择土耳其区的Apple Music而不是使用中国大陆区

  No.1 费用低廉

  这是我推荐使用土耳其区最主要的原因。

  土耳其Apple Music费用低。目前1新土耳其里拉等于0.36元，土耳其Apple Music个人订阅是19.99新土耳其里拉，约等于7.2元对于中国大陆的Apple Music 10元/月就已经便宜了。 如果你选择开通家庭订阅，价格是29.99新土耳其里拉，并且能找到五个人一起拼，那么均摊下来是1.8元！一个月不到2块钱！

  目前我的Apple Music家庭组还有三个位置，有需要的也可以直接联系我，评论留言或者闲鱼私聊即可。

  No.2 土耳其音乐曲库远大于中国大陆区

  1. Apple Music在不同地区的曲库是不一样的，中国大陆的曲库应该是最小的（之一），美区应该是最大的，土耳其属于二者之间
  2. Apple Music对音乐也做了分级，音乐中带儿童色情的“脏标”在中国大陆的曲库中是没有的，土耳其则有
  3. 2022年周杰伦发布的新专辑《最伟大的作品》，其他地区均是同步更新，而中国大陆则是延期接近三个月才更新
  4. 封面图有所差异 第一张图中国大陆区域在展示Beyonce的《RENAISSANCE》，第二张图是土耳其区
  5. 部分歌手的歌曲版权存在差异化，比如华晨宇，TFBOYS的歌曲在中国大陆区的Apple Music几乎没有 左侧是中国大陆区域搜索华晨宇，右侧是在土耳其搜索华晨宇，结果差距很大

  
  

  6. 部分不能讲的原因导致无法上架的，比如歌手李志，还有一些台湾的组合以及马来西亚的歌手等等，但在土耳其区则无此问题

  No.3 土耳其区功能更多

  1. Apple Music土耳其区可以解锁真正的电台功能

  2. 中国大陆订阅的Apple Music不支持AppleTV使用。当然目前有部分网友通过卡网络bug的形式在AppleTV上使用Apple Music，但如果可以直接使用岂不是更好？

  3. 土耳其区可以直接观看Apple Music live，比如2022年歌手Billie Eilish在英国伦敦举办的live演唱会录屏就可以直接在Apple Music观看。就算你没有AppleTV，你还可以通过AirPlay（隔空投放）到电视上观看：发稿前发现中国大陆区也可以看

  

  当然如果你没有AppleTV，手机上也是可以观看的

  No.4 土耳其免费赠送时间长

  在中国大陆区，官方的赠送时间是一个月，而在土耳其区是整整六个月！：这个已经没有了，目前都是免费一个月，我之前确实白嫖了半年😂

  如何注册与开通土耳其区Apple Music？

  1. 访问苹果用于注册appleid的网址：https://appleid.apple.com/account

     如果你存在无法打开此网站的问题，可以考虑重启自己的设备（手机）或者是由Wi-Fi切换到数据流量（蜂窝移动网络）试试。

  2. 访问以后，我们根据网页提示的信息进行填写即可

     

     这里有几点信息你可能需要知道的：

     1. 姓氏和名字不需要填写真实的，你可以填写任意内容

     2. 国家或地区请记得选择土耳其，这里的顺序是按照拼音首字母来的，大概是在这个位置前后

        

  3. name@example.com这里就是你想要创建的Apple ID账号，你需要输入一个你已经存在的邮箱账号，注意不能是icloud.com的邮箱账号 如果你没有邮箱账号的话，你可能需要单独为此注册一个，推荐使用腾讯邮箱或者网易163邮箱（或者outlook、gmail邮箱）

     需要注意的是，你如果有QQ号，那么默认你就是有QQ邮箱的，账号是你的QQ号码@qq.com。 例如你的QQ号码是123456789，那么你的QQ邮箱就是123456789@qq.com

     • 手机注册腾讯QQ邮箱请访问：QQ注册

     • 电脑注册腾讯QQ邮箱请访问：QQ注册

  4. 最后输入密码、验证手机号即可注册成功

  我最近一段时间也在注册新的Apple ID，我发现苹果的限制是越来越多了，经常遇到无法创建账号的问题，这个就是苹果自己的风控。如果你也遇到了这个问题（实际上很多人都遇到过，闲鱼上经常有人来问）。

  1. 切换网络：失败的时候如果用的蜂窝数据就换成Wi-Fi再提交，如果失败的时候是Wi-Fi那就换成蜂窝数据。特别注意一点就是不要使用公共Wi-Fi，比如咖啡店、奶茶店、车站、酒店这种人流性特别大的就不要尝试了。如果确实找不到合适的Wi-Fi可以试试换个地方，然后开关飞行模式。因为基站切换的时候有概率会刷新你的公网IP。
  2. 浏览器使用隐私模式：Windows设备快捷键是ctrl+shift+n，macOS设备快捷键是command+shift+n。移动设备则需要自己在浏览器设置中找一下或者装一个duckduckgo浏览器有“一键焚烧”功能。主要是为了避免苹果利用cookie之类的缓存来判断你的设备。
  3. 换设备：如果你用的设备已经注册过多个Apple ID，那么你提交失败的概率就非常大。我现在就是这种状态，第一种和第二种方法对我来说已经没有太多用处了。
  4. 换邮箱地址：比较有名的邮箱成功率会高一些，比如qq.com、163.com、gmail.com、outlook.com等等。如果你用的自己的域名邮箱，提交失败也是常事。

  如何订阅土耳其区Apple Music？

  首先你要知道你是不能直接使用微信、支付宝、银行卡（银联）等渠道直接订阅土耳其区Apple Music的，目前土耳其区也不支持类似于美区可用的Paypal方案。

  常见的方案有两种：

  1. 你搞到一张土耳其的银行卡。相信大多数人都做不到这点

  2. 通过购买土耳其区App Store 礼品卡。这也是目前最为主流的解决方案

     主要有两种方式来购买土耳其App Store礼品卡：

  方式1:通过oyunfor直接购买App Store礼品卡

  1. 在 https://www.oyunfor.com/ 中注册账号

  2. 选择你需要的额度 https://www.oyunfor.com/apple-store/apple-store-itunes-gift-card，先加入购物车

  3. 确定好金额后提交订单

  4. 可通过国内的visa或master信用卡付款，支付平台会收取3%左右的手续费，然后银行方面还可能收取货币转换费（一般使用单币卡可以免货币转换费，具体请咨询银行客服）

  5. 购买成功以后无法直接拿到礼品卡，你需要先绑定自己的手机号，+86目前可用

  可能出现的问题以及解决方案：

  1. 官网默认是土耳其语，你需要切换到English或者自己使用网页翻译服务

  2. 目前没有被墙，但直连速度很慢很慢，所以还是需要有比较稳定的上网方案，且节点不能支持IPv6，否则在付款阶段会被拒绝

  3. 手机号在网页上绑定以后还是无效，你需要在官网上咨询客服，不支持中文，需要使用英文交流

  4. 客服大概率会让你使用WhatsApp来验证手机号的有效性，对于大部分用户来说可能注册WhatsApp又是一个很麻烦的事儿

  方式2：通过我卖的土耳其App Store 礼品卡直接激活

  目前我已经在闲鱼上架了多种面额的 App Store 礼品卡，均是通过oyunfor购买所得。

  拍下付款以后，会自动发货，自动答复的消息中有相应的激活方法

  其他问题可以评论区留言，或者闲鱼私聊我

  点我跳转到闲鱼

  如果闲鱼链接失效，可以直接搜索用户“土耳其礼品卡”，会员名x开头，7结尾，粉丝数量大于150的就是我了

  如何迁移Apple Music中国大陆区的资料库？

  首先是不推荐直接将自己目前的Apple ID改为土耳其区，那么这种情况下已经有了中国大陆区的Apple Music要如何迁移呢？

  非常简单，Apple Music有一个播放列表共享功能，虽然中国大陆区的共享功能收到了限制（不能搜索其他人的），但是可以通过链接直接分享。

  所以我们只要把资料库中所有的歌曲都新建成一个播放列表并生成共享链接，然后土耳其区的账号访问这个播放列表，添加并勾选到资料库即可完成。

  如何将中国大陆区的播放列表批量迁移？

  很抱歉，这个暂时没有特别好的方法，建议是利用Apple Music列表共享功能将列表一个一个的挪动

  如何将中国大陆区自己上传的音乐文件批量迁移？

  对于自己主动上传的这部分音乐文件，Apple Music是可以直接下载的，只需要用一台电脑先下载源文件，然后切换账号重新上传即可完成

  写到最后

  其实，当你有一个外区Apple ID以及App Store礼品卡以后，你可以订阅很多其他的服务或者购买其他的软件，而且土耳其区的价格都比较低。比如Affinity Photo2

  此外，目前国行的App Store已经全面实行了备案制，很多app其实在国区都没了，有个土耳其区的Apple ID还是不错的。

  ]]> https://baofeidyz.com/solve-macos-intellij-idea-high-cpu-usage/ 解决macOS]]> baofeidyz's blog 技术 macOS IDEA Mon, 10 Apr 2023 01:00:00 GMT 解决macOS IntelliJ IDEA 卡顿问题

  写在前面的话1：我在撰写这篇博客时候，所用的IntelliJ IDEA版本是IntelliJ IDEA 2022.3.3 (Ultimate Edition)，你需要知道可能对于不同的IntelliJ IDEA版本会有一定的差异
  
  写在前面的话2：如果我这篇博客可以帮助到你，请给我一个免费的赞和收藏，谢谢

  问题描述

  我遇到的卡顿问题主要体现在编辑代码时，输入中文时，cpu使用率飙升到100%，并且中文已经在键盘中打完了，但是展示到IntelliJ IDEA页面上还需要5秒以上，已经卡到没办法做研发工作了。

  一些相关的因素

  在特别卡的时候，我有更换过一次项目。我在做这个项目之前，虽然也卡，但是不会类似于这个项目这么卡。
  但同时我在这期间有升级过macOS的系统版本和IntelliJ IDEA的版本，变量因素很多，加大了问题排查定位的难度。

  排查思路

  我以前很喜欢写流水账，但是这次来来回回花了我好几个月才解决，所以我已经回忆不起来我到底是怎么一步一步排查的了，我尝试写一些我还能想起来的作为排查思路

  检查内存、硬盘、cpu使用率

  这是我最开始的考虑，macOS上有一个系统应用，叫“活动监视器“，这里面可以比较清晰的看到IntelliJ IDEA的cpu、内存、硬盘、网络的使用情况，当然你也可以在终端中使用top或者htop来确认。
  通过我的观察，我发现我输入中文的时候，我的八个很容易就达到了100%，CPU使用率轻轻松松超过400%

  如果你使用IntelliJ IDEA开发程序，那么Java应用的卡顿问题如何处理，你应该是比较熟悉的，对吧？但是如果没有源码，我们直接去查IntelliJ IDEA的线程信息其实帮助也不是很大，我稍微花了一点时间在网络上翻找了一些帖子。

  IntelliJ IDEA其实是有自己的分析工具，其位置在于【顶栏->Help->Diagnostic Tools->Activity Monitor】

  说个题外话，不建议安装IntelliJ IDEA的中文语言包，因为互联网上大量文档主要还是用英文来写的，我在解决这个IntelliJ IDEA卡顿问题的时候也在IntelliJ IDEA自己的论坛看了很多帖子，如果你长期使用中文语言包，对于一些词汇太陌生会导致自己处理问题比较麻烦。

  

  从这个工具里面咱们就可以看到具体什么进程导致CPU的高占用，对于进程名不熟悉的，借助于Google也可以很快了解具体是做什么的。

  不同的使用场景下，会存在不同的原因，并且因为IntelliJ IDEA还支持了插件，所以导致卡顿的原因更是不计其数，但只要你懂得如何去排查问题，这个事儿就变得没有那么困难了。

  一个一个的禁用插件来排查

  这个方法是很多人都有提到的，并且在实际应用上是真的有效果！如果你安装的插件比较多，那么请一个一个的disable掉，利用排查法找到具体是哪个插件所导致的，插件越多理论上时间会比较长，你也可以选择以五个为单位快速定位一个大致的范围。

  常见的一些解决方案

  修改IntelliJ IDEA的内存

  放到第一位肯定是相当重要的，但IntelliJ IDEA在扫描、编译、处理各类问题的时候，确实是需要很大内存的。我个人目前是给到了6G。

  网上有各种各样教你修改配置文件的方法，但是IntelliJ IDEA自己就提供了这样的功能，你直接需要点击【顶栏->Help->Edit Custom VM Options】就可以在IntelliJ IDEA编辑框打开一个以.vmoptions结尾的文件。如果之前已经有-Xmx属性那么就改一下，如果没有就新起一行加上即可，如果你想和我一样配置成6G，那么修改属性值应该是-Xmx6144m即可，这表示最小堆内存位6G

  使用更高版本的jdk以及IntelliJ IDEA的新界面

  java 原来使用的是OpenGL，但是macOS从Mojave开始启用了新的Metal框架，jetbrains对此也是早早布局，我这里放两个链接供你了解更多的内容：

  1. Metal for IntelliJ Platform | The JetBrains Platform Blog
  2. https://youtrack.jetbrains.com/issue/JBR-745/Improve-java2d-rendering-performance-on-macOS-by-using-Metal-framework

  当你的分辨率非常高，或者是显示器非常的多时，渲染的压力就会越大，cpu就会飙升，IntelliJ IDEA也会变卡。截止目前IntelliJ IDEA已经发布了New UI，虽然被标记为Beta，但从我个人使用情况来说，我还没遇到过问题。反而新版本的UI更让我聚焦我的开发工作，用了几天很快就适应了。
  简单来说，你需要jre 17及以上版本且IntelliJ IDEA版本保持为最新版即可。

  插件导致的卡顿

  git插件

  排查思路很简单，就是我在上一个章节中提到的一个一个的禁用插件来排查，如果你已经确定是IntelliJ IDEA的git插件导致的卡顿，但是你又想像我一样继续使用这个git插件，那么应该怎么解决呢？

  这个问题我是偶然一次浏览到的，macOS 下 Intellij IDEA 变得特别卡该如何解决？ - 知乎 其中第一个高赞回答就是解决方法，其实就是.gitignore文件设置不合理，导致git插件索引了大量无意义的文件，我目前维护的这个项目git下同时存放了多个子系统的代码，文件数量和层级都非常的夸张。

  我在我本地修改了.gitignore文件的内容，去掉了一些我不需要管的文件夹后，git插件导致的IntelliJ IDEA卡顿问题就迎刃而解了。

  其他插件

  • 如果你确定你不需要，比如alibaba的p3c检查，或者是一些其他的检查扫描类插件，可以disable的都尽量卸载即可。
  • 对于一些比较小众的插件，你可以尝试通过GitHub直接联系作者以寻求解决方案。
  ]]> https://baofeidyz.com/2023/da2a256aff47/ mat用小内存解析超大堆快照的可行方法

  写在前面的话1：服务器上的堆大小已经远超过我开发机的内存大小了，如果直接使用mat客户端来分析很快就会出现OOM的问题，这篇博客一定程度上可以解决这个问题
  
  写在前面的话2：大部分同学一直都在使用mat的gui来做分析，但其实mat的gui只是增加来一个html预览功能，我们可以利用mat命令直接生成html，甚至我们还可以挂载成在线服务，以供其他人浏览，非常赞

  命令

  1 2 3

  /Applications/mat.app/Contents/Eclipse/ParseHeapDump.sh ~/Downloads/java_pidxxx.hprof org.eclipse.mat.api:suspects /Applications/mat.app/Contents/Eclipse/ParseHeapDump.sh ~/Downloads/java_pidxxx.hprof org.eclipse.mat.api:overview /Applications/mat.app/Contents/Eclipse/ParseHeapDump.sh ~/Downloads/java_pidxxx.hprof org.eclipse.mat.api:top_components

  ]]> baofeidyz's blog 技术 Java memory-analyzer Mon, 10 Apr 2023 01:00:00 GMT mat用小内存解析超大堆快照的可行方法

  写在前面的话1：服务器上的堆大小已经远超过我开发机的内存大小了，如果直接使用mat客户端来分析很快就会出现OOM的问题，这篇博客一定程度上可以解决这个问题
  
  写在前面的话2：大部分同学一直都在使用mat的gui来做分析，但其实mat的gui只是增加来一个html预览功能，我们可以利用mat命令直接生成html，甚至我们还可以挂载成在线服务，以供其他人浏览，非常赞

  命令

  1 2 3

  /Applications/mat.app/Contents/Eclipse/ParseHeapDump.sh ~/Downloads/java_pidxxx.hprof org.eclipse.mat.api:suspects /Applications/mat.app/Contents/Eclipse/ParseHeapDump.sh ~/Downloads/java_pidxxx.hprof org.eclipse.mat.api:overview /Applications/mat.app/Contents/Eclipse/ParseHeapDump.sh ~/Downloads/java_pidxxx.hprof org.eclipse.mat.api:top_components

  这个是基于macOS客户端来使用的，其他平台的mat命令位置得对应修改一下，当然如果你觉得分三次解析比较麻烦，你也可以直接一行完成

  1	/Applications/mat.app/Contents/Eclipse/ParseHeapDump.sh ~/Downloads/java_pidxxx.hprof org.eclipse.mat.api:suspects org.eclipse.mat.api:overview org.eclipse.mat.api:top_components

  从我实际的使用体验来说，建议是分开解析，其实很多时候你只需要一个suspects视图就足够了。

  你需要注意的是mat在第一次解析的时候会生成很多的index索引类的文件，你得保证你的硬盘空间足够保存这部分的文件。
  但mat完成以后，其实就是生成了多个html文件，你可以选择借助于nginx，挂载为在线地址，以供其他人在线预览，实际体验还是很不错的。

  ]]> https://baofeidyz.com/2023/ffff4831c7af/

  与此同时，这还是一份我个人重装macOS系统的备忘录😁

  baofeidyz's blog macOS Wed, 04 Jan 2023 01:00:00 GMT

  与此同时，这还是一份我个人重装macOS系统的备忘录😁

  工具类

  软件名称	软件用途	价格	推荐下载方式
  homebrew	macOS包管理工具	免费	终端执行：/bin/bash -c “$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)”
  mos	用于鼠标切换上下滚动的顺序，以及鼠标平滑滚动	免费	brew install mos
  AppCleaner	卸载app，并且删掉相关联的文件	免费	brew install appcleaner
  numbers	替代Excel	免费	app store
  keynote	替代PowerPoint	免费	app store
  pages	替代word	免费	app store
  chrome浏览器	上网、开发调试	免费	https://google.cn/chrome
  sinology drive client	群晖文件同步工具	免费	Synology Drive
  snipaste	截图、贴图工具	基本版免费（高级版macOS还没上）	brew install snipaste
  mircsoft remote	windows操作系统远程桌面工具	免费	美区app store
  infuse	一个跨iOS iPadOS macOS tvos，带资源刮削的播放器	x刀/年	美区app store
  Obisidian	markdown笔记软件	免费（同步服务收费）	brew install –cask obsidian
  marktext	markdown编辑软件，操作表格的时候会比Obisidian好用很多很多，可以搭配使用	免费	brew install mark-text
  ForkLift	ftp、sftp软件	收费，买断制	brew install –cask forklift
  Maccy	剪贴板记录软件	免费	brew install maccy
  MonitorContror	显示器亮度控制软件	免费	brew install –cask monitorcontrol
  Itsycal	菜单栏中的日期选起控件	免费	brew install Itsycal
  omnidisksweeper	磁盘清理工具	免费	brew install –cask omnidisksweeper
  vmware-fusion	vmware虚拟机免费版	个人免费（需要自己在官网申请license）	brew install –cask vmware-fusion
  hiddenbar	管理macOS菜单栏图标	免费	brew install –cask hiddenbar

  一键安装：

  1 2 3 4 5 6 7 8 9 10

  brew install mos && \ brew install appcleaner && \ brew install snipaste && \ brew install --cask forklift && \ brew install --cask obsidian && \ brew install mark-text && \ brew install maccy && \ brew install Itsycal && \ brew install --cask omnidisksweeper && \ brew install --cask hiddenbar

  通讯软件

  软件名称	软件用途	价格	推荐安装方式
  telegram	聊天	免费（高级会员需订阅）	app store（有沙盒机制）
  foxmail	管理企业邮件	免费	brew install –cask foxmail
  thunderbird	邮件管理	开源免费	brew install –cask thunderbird

  一键安装：

  1	brew install --cask thunderbird

  编程软件

  软件名称	软件用途	价格	推荐安装方式
  drawio	UML绘图工具	免费	brew install –cask drawio
  vscode	文本编译器（也可以是IDE）	免费	brew install –cask visual-studio-code
  docker	容器化工具	免费	brew install –cask docker
  orbstack	容器化工具	免费	brew install –cask orbstack
  nginx	web、代理服务等	免费	brew install nginx
  mat	java堆内存分析工具	免费	brew install mat
  jmeter	并发测试工具	免费	brew install jmeter
  node	开发环境	免费	brew install node
  git	代码分支管理工具	免费	brew install git
  sdkman	各类SDK管理工具	免费	curl -s “https://get.sdkman.io“

  一键安装：

  1 2 3 4 5 6 7 8 9

  brew install --cask drawio && \ brew install --cask visual-studio-code && \ brew install --cask orbstack && \ brew install nginx && \ brew install mat && \ brew install jmeter && \ brew install node && \ brew install git && \ curl -s "[https://get.sdkman.io](https://get.sdkman.io)"

  ]]> https://baofeidyz.com/2022/7a54c64670b4/ Java云原生开发初体验报告

  baofeidyz's blog 技术 Java Java Native Tue, 09 Aug 2022 01:00:00 GMT Java云原生开发初体验报告

  背景

  前段时间在考虑做一款小工具，功能非常简单，调用多个HTTP接口，分析处理返回的数据，生成Excel文件即可。 为了尽量的让这个工具的实用性更高，我首先想到Java的云原生开发方案，直接构建为可执行文件，不需要使用的人再去安装jre运行环境，或者是带着庞大的jre文件发出。再者，我也想试试Java的云原生方案到底好不好用。

  技术选型

  因为一直在使用Spring开发业务，所以我这次直接使用了Spring Native

  开发过程

  注：均基于 macOS

  开发环境安装

  Spring官网的文章写的非常好，直接参考官文就可以了。Spring官方文档 我选择安装了sdk man，然后

  1	sdk install java 22.1.r11-nik

  剩下的就是直接用spring native创建一个项目就可以了，这个非常简单。

  编译构建

  1. 如果你用了阿里云的maven仓库，请记得切换成apache的原库

  2. macOS默认mvn命令指定的jdk版本可能不是你新安装的GraalVM（像我本地就有七八个不同的JDK版本），会出现一些编译错误，那么你需要创建~/.mavenrc文件

  1 2	// 路径记得自己改成正确的 export JAVA_HOME=/Users/baofeidyz/.sdkman/candidates/java/current

  报错集锦

  报错1

  1 2 3

  gu install native-image Downloading: Component catalog from download.bell-sw.com Error: Unknown component: native-image

  在高版本里面，这个native-image好像不需要手动安装了（也有可能是我之前安装过）Install fails in 19.2.0 with gu · Issue #1665 · oracle/graal · GitHub 然后我直接运行了一下native-image发现已经有了

  报错2 反射错误

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `com.baofeidyz.XXXDTO` (no Creators, like default constructor, exist): cannot deserialize from Object value (no delegate- or property-based Creator) at [Source: UNKNOWN; byte offset: #UNKNOWN] (through reference chain: java.util.ArrayList[0]) at com.fasterxml.jackson.databind.DeserializationContext.reportBadDefinition(DeserializationContext.java:1904) at com.fasterxml.jackson.databind.DatabindContext.reportBadDefinition(DatabindContext.java:400) at com.fasterxml.jackson.databind.DeserializationContext.handleMissingInstantiator(DeserializationContext.java:1349) at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.deserializeFromObjectUsingNonDefault(BeanDeserializerBase.java:1415) at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserializeFromObject(BeanDeserializer.java:351) at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:184) at com.fasterxml.jackson.databind.deser.std.CollectionDeserializer._deserializeFromArray(CollectionDeserializer.java:355) at com.fasterxml.jackson.databind.deser.std.CollectionDeserializer.deserialize(CollectionDeserializer.java:244) at com.fasterxml.jackson.databind.deser.std.CollectionDeserializer.deserialize(CollectionDeserializer.java:28) at com.fasterxml.jackson.databind.deser.DefaultDeserializationContext.readRootValue(DefaultDeserializationContext.java:323) at com.fasterxml.jackson.databind.ObjectMapper._readValue(ObjectMapper.java:4650) at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:2856) 有省略部分堆栈

  这个报错只有在GraalVM下运行时才会出现，我最开始以为是因为我用了lombok然后导致的编译问题，同时我也有注意到，Spring Native本身是直接带了lombok的，我觉得不太可能吧。 但是我还是尝试去掉了lombok，当然并没有什么用。

  然后我又开始在网上寻找一些蛛丝马迹，看看有没有其他人也遇到了类似的问题。但是Java Native问题的搜索真的是非常难找，因为这类问题有可能因为其他的原因也会出现，并且由于Spring Native使用人非常的少，你很难在Google的结果中找到真正的答案。我也尝试使用site:github.com再去Google搜索，仍没有找到答案。 我甚至都想去提issue了 😂 GitHub - graalvm/native-build-tools: Native-image plugins for various build tools

  我后来咨询了一位做过Spring Native开发的朋友，他告诉我，可能是因为反射导致的，需要增加配置。 我顺着这位朋友的思路，去看了一下反射配置的问题，正好在这篇文章中给出了一个示例

  1 2 3

  @TypeHint(types = Data.class, typeNames = "com.example.webclient.Data$SuperHero") @SpringBootApplication public class SampleApplication { // ... }

  我顺着这个例子，修改了一下代码

  1 2 3 4 5

  @TypeHint(types = XXXDTO.class, typeNames = "com.baofeidyz.XXXDTO") @SpringBootApplication public class MySpringNativeApplication { // ... }

  确实解决了这个jackson反序列化导致的错误，但我又遇到了新的错误。

  报错3 缺少字符集

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  java.nio.charset.UnsupportedCharsetException: CP1252 at java.nio.charset.Charset.forName(Charset.java:529) at org.apache.poi.util.LocaleUtil.<clinit>(LocaleUtil.java:56) at org.apache.poi.ss.usermodel.DataFormatter.<init>(DataFormatter.java:242) at org.apache.poi.ss.usermodel.DataFormatter.<init>(DataFormatter.java:233) at org.apache.poi.ss.formula.functions.TextFunction.<clinit>(TextFunction.java:33) at org.apache.poi.ss.formula.atp.AnalysisToolPak.createFunctionsMap(AnalysisToolPak.java:82) at org.apache.poi.ss.formula.atp.AnalysisToolPak.<init>(AnalysisToolPak.java:47) at org.apache.poi.ss.formula.atp.AnalysisToolPak.<clinit>(AnalysisToolPak.java:33) at org.apache.poi.ss.formula.udf.AggregatingUDFFinder.<clinit>(AggregatingUDFFinder.java:35) at java.lang.Class.ensureInitialized(DynamicHub.java:518) at org.apache.poi.xssf.usermodel.XSSFWorkbook.<init>(XSSFWorkbook.java:155) ~[na:na] at org.apache.poi.xssf.usermodel.XSSFWorkbook.<init>(XSSFWorkbook.java:226) ~[na:na] at org.apache.poi.xssf.usermodel.XSSFWorkbook.<init>(XSSFWorkbook.java:214) ~[na:na] // 有省略堆栈信息

  这个看起来像是poi在操作的时候，遇到了一个chartset问题，spring有一个专门的仓库我在这个仓库里面找到了这个issue，我看到一个人也遇到了这个charset的问题，但是他是mysql的时候遇到的，他提到加了一个参数用于解决这个问题。 紧接着，我又找到了几个issue：

  • I tried to build a native image program with POI, but it failed · Issue #3191 · oracle/graal · GitHub

  • issue with okhttp with graalvm-ce-19.0.0 · Issue #1294 · oracle/graal · GitHub

  • UnsupportedEncodingException when running native-image generated binary · Issue #1370 · oracle/graal · GitHub

  了解到说，需要在native-image编译的时候，增加一个AddAllCharsets参数 但是我是使用的spring native的maven插件，我的构建命令是mvn -Pnative，我并没有直接使用native-image，我不知道怎么增加这个参数才是对的。 此外，我还看了两份文档：

  • 关于这个如何查看堆信息之类的：GraalVM Dashboard

  • 关于native-image这个命令如何使用的：https://www.graalvm.org/uploads/quick-references/native-image-quick-reference-v2_A4.pdf 然后我又去查了一下Spring Native自己维护的一个hints项目：spring-native/spring-native-configuration/src/main/java at main · spring-projects-experimental/spring-native · GitHub 然后又去研究了一下Spring Native的脚本：spring-native/compileWithMaven.sh at main · spring-projects-experimental/spring-native · GitHub

  终于，我知道如何在Spring Native中增加这个AddAllCharsets参数了 😄

  1 2 3 4 5 6 7

  @TypeHint(types = XXXDTO.class, typeNames = "com.baofeidyz.XXXDTO") // 👇 下面这行代码就解决了我的问题 @NativeHint(options = "-H:+AddAllCharsets") @SpringBootApplication public class MySpringNativeApplication { // ... }

  最佳实践就是加一个@NativeHint(options = "-H:+AddAllCharsets") 当然不可能这么顺利的，很快我又遇到了新的报错

  错误4 POI的resource文件未加载

  1 2 3 4 5 6 7 8 9 10 11 12

  org.apache.xmlbeans.SchemaTypeLoaderException: XML-BEANS compiled schema: Could not locate compiled schema resource org/apache/poi/schemas/ooxml/system/ooxml/index.xsb (org.apache.poi.schemas.ooxml.system.ooxml.index) - code 0 at org.apache.xmlbeans.impl.schema.XsbReader.<init>(XsbReader.java:63) at org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl.initFromHeader(SchemaTypeSystemImpl.java:235) at org.apache.xmlbeans.impl.schema.SchemaTypeSystemImpl.<init>(SchemaTypeSystemImpl.java:201) at org.apache.poi.schemas.ooxml.system.ooxml.TypeSystemHolder.<init>(TypeSystemHolder.java:9) at org.apache.poi.schemas.ooxml.system.ooxml.TypeSystemHolder.<clinit>(TypeSystemHolder.java:6) at org.openxmlformats.schemas.spreadsheetml.x2006.main.CTWorkbook.<clinit>(CTWorkbook.java:22) at org.apache.poi.xssf.usermodel.XSSFWorkbook.onWorkbookCreate(XSSFWorkbook.java:475) at org.apache.poi.xssf.usermodel.XSSFWorkbook.<init>(XSSFWorkbook.java:232) at org.apache.poi.xssf.usermodel.XSSFWorkbook.<init>(XSSFWorkbook.java:226) at org.apache.poi.xssf.usermodel.XSSFWorkbook.<init>(XSSFWorkbook.java:214) // 有省略

  我猜测应该是因为资源没有引入导致的，所以我理解应该还是应该用spring native提供的hint去实现。我参考这个代码块 增加了一个@ResourceHint

  1 2 3 4 5 6 7

  @TypeHint(types = XXXDTO.class, typeNames = "com.baofeidyz.XXXDTO") @ResourceHint(patterns = {"(^/|[a-zA-Z])*/.+(/$)?.xsb"}) @NativeHint(options = "-H:+AddAllCharsets") @SpringBootApplication public class MySpringNativeApplication { // ... }

  报错5

  1 2 3 4 5 6

  java.lang.ClassCastException: org.apache.xmlbeans.impl.values.XmlComplexContentImpl cannot be cast to org.openxmlformats.schemas.spreadsheetml.x2006.main.CTWorkbook at org.apache.poi.xssf.usermodel.XSSFWorkbook.onWorkbookCreate(XSSFWorkbook.java:475) at org.apache.poi.xssf.usermodel.XSSFWorkbook.<init>(XSSFWorkbook.java:232) at org.apache.poi.xssf.usermodel.XSSFWorkbook.<init>(XSSFWorkbook.java:226) at org.apache.poi.xssf.usermodel.XSSFWorkbook.<init>(XSSFWorkbook.java:214) // 有省略

  然后我在GraalVM的issue清单中找到了这个issue：Getting following error while generating excel file using native image. · Issue #1929 · oracle/graal · GitHub 基本上错误信息就是一致的。 我试了一下，不行。

  我感觉POI和GraalVM配合坑有点多，我不打算一个一个找了，我尝试去找一些大而全的文章，于是，我找到了这篇文章：Graalvm使用采坑 - 行万里路才能回到内心深处，读万卷书才能看得清皓月繁星

  可惜还是失败了，我感觉算了吧，POI和GraalVM的路还很长哦…

  一些思考

  1. 对于这种POI组件的问题，处理起来确实很难。我查了GraalVM的ISSUE清单，5.0之前的POI确实是有一些问题，但与此同时GraalVM可能需要大量的构建参数去配置，然后Spring Native又在其中转了一次。也就是说，我需要知道这个问题不是POI导致的，然后去看native-image对应的解决方案（配置参数）是什么，然后再转成Spring Native的hints。如果我不能确定这个问题是不是POI导致的，我连提ISSUE给谁都不清楚，如果自己尝试去排查编译问题，这就会进入一个更深的坑。

  2. 我建议如果Spring Native example下找不到对应的例子之前，不要去趟这个浑水，整个开发过程非常阻塞，问题很难说真正的解决完。

  3. Java云原生的路确实很难走，不管是GraalVM去适配组件，还是组件去适配GraalVM，整个适配时间会拉得很长很长。

  4. GraalVM编译时间很长，我的项目并不大，4核8线程，16G内存，但是每次都需要大概3分钟左右，并且编译的时候，CPU使用率一直都很高。

  后续

  我后来用GO重写了整个程序，这是我第一次用GO，从0开始学，大概花了20个小时就写完了，并且我还用了协程并发，处理了一些线程安全的问题。相比之下，Spring Native至少花了我四倍的时间，并且没有做完。 GO编译速度非常快，我交叉编译linux或windows也才10s，CPU使用率也不高，相比之下，GO做这类小工具的云原生开发真的是非常好用。

  所以我在怀疑，Java云原生是否真的有意义？希望十年后，能被打脸。

  以上就是我Java云原生的初步体验报告，如果对你有一点点帮助，希望可以给我的文章点个赞和收藏。

  ]]> https://baofeidyz.com/2022/ec3fcefc534b/ NanoPi R2S 软路由折腾记 baofeidyz's blog 折腾 折腾 NanoPi R2S Fri, 17 Jun 2022 01:00:00 GMT NanoPi R2S 软路由折腾记

  😩 问题多多

  最开始用的是YouTuber 洋葱提供的固件，但是存在一些问题：

  1. TF卡的空间没有挂载完（8G的卡，只用到了1G左右），自己用fdisk挂载逻辑分区报错；
  2. 修改docker默认存储位置后，镜像依赖的一些程序无法使用，如curl等；
  3. 直接opkg install安装固件总会出一些莫名其妙的依赖问题，opkg update也好，还是直接ipk安装，都会遇到很多奇奇怪怪的问题；

  🧐 有机会？

  接着，我就去openwrt官网找了镜像，但无论是用工具balenaEther刷入，还是使用dd命令写入。当在TF卡插回R2S时，SYS灯一直红色长亮，wan和lan的灯无任何响应。
  由于R2S本身还有挑卡的毛病，不太确定是不是镜像本身存在问题；

  😋 解决啦～

  后面意外发现其实友善也有自己的官网，在其wiki上找到了镜像下载地址，
  下载刷入以后，正常启动。

  我用的是balenaEther，但使用dd应该也是可行的

  docker也可正常使用。当然还是遇到了一些小问题。

  🐛 一些小问题

  openclash订阅更新一直失败

  安装好openclash插件以后，在更新订阅时，一直提示失败。

  DNS无法解析

  常见DNS无法解析，直接写到etc/hosts，使用ping或者nslookup命令验证解决

  curl命令缺少依赖文件

  openclash下载文件也是依赖于wget或者curl之类命令，我ssh连接到路由器以后，测试了一下这两个命令是否可正常下载文件，结果到curl时，发现缺少了部分so依赖文件，使用opkg install安装对应的包就解决了。
  参考：libwolfssl5.2.0.99a5b54a_5.2.0-stable-2_x86_64.ipk OpenWrt 21.02 Download

  🥶 继续折腾HASS

  未完待续…

  ]]> https://baofeidyz.com/2022/889ffcfbf52a/ baofeidyz's blog 技术 踩坑 Docker Fri, 10 Jun 2022 01:00:00 GMT Docker容器一启动就挂，要怎么排查？

  1. 分析镜像信息

  通过

  1	docker inspect 镜像ID

  可以查看当前镜像的属性信息，那么我们重点需要关注的是Entrypoint这个属性的信息。
  关于entrypoint是什么，你可以参考Dockerfile reference | Docker Documentation

  我这里获取到的Entrypoint信息如下：

  1 2 3

  "Entrypoint": [ "/docker-entrypoint.sh" ],

  这个Entrypoint可以说是非常的简单，但是又非常的复杂。
  简单在于就一行，是直接去执行/docker-entrypoint.sh这个脚本，但是复杂在于我们并不能直接看到这个docker-entrypoint.sh的内容。

  2. 分析Entrypoint

  一般来说，我们有几种方法可以看到这个/docker-entrypoint.sh文件：

  1. 挂载：通过docker run -v将这个目录挂载到宿主机上，就算这个容器一启动就死，我们也不用担心拿不到文件；
  2. 交互命令（这个词是我自己想的，可能不是很准确）：通过docker run -it 镜像ID sh -c "cat /docker-entrypoint.sh"去查看内容。这个方法其实还是需要容器启动的，如果是启动立刻挂的情况，这个方法应该是会失效的；
  3. 跳过entrypoint：通过`docker run –entrypoint sh 镜像ID -c “cat /docker-entrypoint.sh”，即可覆盖镜像中的entrypoint，覆盖以后，容器并没有去运行entrypoint脚本，所以也就不会挂了。

  3. 覆盖entrypoint

  既然都可以覆盖entrypoint了，那我们为啥要局限于通过交互命令去查看文件呢？

  1	docker run -d --entrypoint sh 镜像ID -c "ping 127.0.0.1"

  通过这个命令，给容器一个不可完成的任务，那么这个容器将一直存活。然后再通过

  1	docker exec -it 容器ID sh

  进入容器，岂不是美哉？

  如果你的镜像比较简单，可能会没有ping命令，那么你可能需要tail或者其他命令来保证容器可长期存活

  4. 手动执行entrypoint

  容器不会被自动杀掉以后，我们就可以一步一步的去分析这个entrypoint到底是死在哪儿了？

  这里就没有办法展开讲了，因为每个人的情况都是不同的，只要有点耐心，我相信一定是可以解决的。

  ]]> https://baofeidyz.com/2022/ee902c708a62/ baofeidyz's blog 技术 Java 踩坑 Docker K8s JMX Fri, 03 Jun 2022 01:00:00 GMT Docker（K8S）环境下开启JMX远程监控

  问题引入

  JMX（即Java Management Extensions），如果你在网上搜索如何配置JMX，你就会看到这样的一堆配置

  1 2 3 4 5 6

  -Djava.rmi.server.hostname= -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.rmi.port= -Dcom.sun.management.jmxremote.port= -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false

  然后你就会发现在docker下，怎么弄都不对。

  JMX分析

  JMX其实需要注册三个端口，其作用为：

  • 端口1: 接收注册请求，JMX客户端（如jvisualvm）在连接时，需要填写的端口号

  • 端口2: 用于远程连接，可以与端口1使用同一个端口号

  • 端口3: 用于本地连接，随机（这个端口在实际业务场景中，不需要去指定，我暂时没研究如何指定这个端口）

  排坑

  坑点1 JMX端口仅暴露1个

  由于JMX是在远程监控的情况下是需要两个端口的，所以在Docker环境下很可能就会出现因为端口没映射全而导致的失败

  解决办法也很简单，就是把端口1和端口2设置为同一个端口即可，这样也可以减少端口映射过多而产生的端口冲突

  1 2	-Dcom.sun.management.jmxremote.rmi.port=8888 -Dcom.sun.management.jmxremote.port=8888

  注：8888这个端口是我随便写的，在合法范围内都可以

  坑点2 java.rmi.server.hostname配置导致JMX连接失败

  坑点1其实在网络上已经有大把大把现成的文章了，而对于坑点2，则在于java.rmi.server.hostname这个配置。我个人认为这个是因为JMX诞生比较早，所以JMX并没有适配容器化，这就导致了第二个坑点。

  java.rmi.server.hostname配置失败的体现在于，你的JMX客户端，会在连接中卡顿很久，这其实就是JMX尝试连接，但连接不上导致的。

  JMX客户端根据你填写的IP和PORT去查找JMX服务，这时候你的服务端会返回这个java.rmi.server.hostname和com.sun.management.jmxremote.rmi.port，JMX客户端再根据这两个值去连接。

  那么在docker环境下，你配置的java.rmi.server.hostname很可能就配置错了，你需要保证这个java.rmi.server.hostname是客户端直接可连的，并且这个com.sun.management.jmxremote.rmi.port也是可以直接访问的。

  我使用的环境是我用我的笔记本去监控运行在服务器K8S集群中的服务，这种情况下，我需要把java.rmi.server.hostname配置为这个集群所使用的映射服务IP，

  如果你的映射服务IP过多，这就会很麻烦，因为每次修改java.rmi.server.hostname需要重启，而重启等同于重新部署，这就导致有可能不匹配，这个问题可能需要想办法绑定，或者自己手动用kubectl做映射

  并且你还需要保证com.sun.management.jmxremote.rmi.port是映射服务所使用的端口。

  创建端口映射的时候，就保证你的容器端口和映射端口得是一致的，不然JMX服务返回给JMX客户端的端口，没办法通过端口映射连接了

  

  参考

  how-to-connect-with-jmx-from-host-to-docker-container-in-docker-machine

  ]]> https://baofeidyz.com/2022/6fd6c11c6446/ 不要直接复用其他业务的线程池

  baofeidyz's blog 技术 Java 踩坑 Fri, 03 Jun 2022 01:00:00 GMT 不要直接复用其他业务的线程池

  前言

  最近在复查团队小伙伴的代码时发现，错误复用了一个定时触发信息同步的线程池。但他开发的代码所对应的业务场景是响应前端页面的请求。而这次的线程池复用将可能会导致系统页面“卡死”。

  信息同步的线程池，其主要配置信息为：

  • corePoolSize：4
  • maximumPoolSize：8
  • keepAliveTime：30L
  • unit：TimeUnit.SECONDS
  • workQueue：new ArrayBlockingQueue<>(1000)
  • threadFactory：new com.google.common.util.concurrent.ThreadFactoryBuilder().setNameFormat("xxx-pool-%d").build()
  • handler：new ThreadPoolExecutor.CallerRunsPolicy()

  这个定时任务设定为每半个小时执行一次，当定时任务开始执行后，这个队列任务很快就会装满。

  如果这个时候响应前端页面请求的线程进入，就会进行等待队列，此时可能会发生：

  1. 任务队列满，触发丢弃策略，前端页面请求被丢弃，用户拿不到的正确的数据；
  2. 任务较多，前端页面请求等待，可能会出现前端页面请求超时，系统“卡死”；

  分析

  存在任务优先级存在问题。页面请求的优先级应大于信息同步任务的优先级，但如果复用同一个线程池，那么在任务执行顺序上，就是先进先执行。

  如果此前已经有多个信息同步任务正在等待，页面请求也必须要等到信息同步任务执行完成以后才可以去与其他线程抢占系统资源。

  结论

  对于一些优先级较高的任务，应当独立维护线程池。虽然在JVM中还存在线程调度问题，但至少不会一直阻塞去等待其他任务的执行。

  对于一些优先级较低的定时任务，可以考虑适当复用，与此同时也需要考虑好核心线程数、最大线程数、等待队列、丢弃策略等。

  很多技术解决方案都是一把双刃剑，用得好，事半功倍，用不好，系统宕机😂

  ]]> https://baofeidyz.com/2022/8f9d0cbeb525/ baofeidyz's blog 技术 Java 踩坑 macOS Fri, 03 Jun 2022 01:00:00 GMT 解决macOS Big Sur升级后部分java应用无法打开的问题JavaVM: Failed to load JVM: libserver.dylib

  升级到macOS Big Sur以后，之前安装的dbeaver和mat都无法打开了，点击报错都是同一个问题。

  实际上oracle jdk在安装完成以后是没有 libserver.dylib 这个文件的，但是dbeaver和mat还是在查找这个文件，应该是出兼容性bug了。

  解决的方案很简单，就是要找到这个 libserver.dylib 对应应该是什么文件就可以了。几番折腾之下，我在这里找到了答案，实际的地址应该是

  1	/Library/Java/JavaVirtualMachines/jdk1.8.0_271.jdk/Contents/Home/jre/lib/server/libjvm.dylib

  使用ln -s创建一个链接就可以解决了。

  1	sudo ln -s /Library/Java/JavaVirtualMachines/jdk1.8.0_271.jdk/Contents/Home/jre/lib/server/libjvm.dylib /Library/Java/JavaVirtualMachines/jdk1.8.0_271.jdk/Contents/Home/lib/libserver.dylib

  如果你的jdk文件夹和我的命令不一样，请记得修改命令。

  升级之前为啥没有这个问题，我就不知道了，很有可能我之前创建过链接被macOS给删掉？（可能性不大吧）

  ]]> https://baofeidyz.com/2021/44e6c6da4a97/ baofeidyz's blog 技术 Git Mon, 23 Aug 2021 01:00:00 GMT git仓库从30G压缩到600M-git文档仓库过大的优化方案

  项目上使用git管理相关文档，因维护多年，导致其文档仓库已经逼近30G的大小，对于我这台256G的MBP来说，无疑是占用了巨大的空间，介于此，我计划减少这个仓库的体积。

  git-lfs

  git-lfs是atlassian维护的开源项目，意图解决因反复修改大文件而导致git仓库变大，以及影响初次下载的体验；

  在我尝试使用git-lfs后，占用空间被压缩到了24G左右，但效果并不明显，这主要是因为这个git仓库中的大部分文档都不存在反复修改的情况，大部分文件都是上传后再也没有改过。

  可以说git-lfs解决了我一部分的问题，但并没有全部解决。

  GVFS

  GVFS是微软的开源项目，意图解决git对于超大型仓库的维护问题，但很可惜，GVFS依赖于window操作系统，我手上主力机还是macOS，所以GVFS就不考虑了。

  git sparse checkout

  sparse checkout是git自己维护的功能，其提供的功能是告诉git相关的命令再拉取时仅拉取部分文件，或排除掉部分文件。

  很现实，sparse checkout就是解决我这个问题的最佳方案

  使用方法

  1. 新建仓库并设置远端仓库地址

  1 2	git init git remote add -f origin <url>

  1. 开启配置

  1	git config core.sparsecheckout true

  1. 配置想要拉取的文件路径

  1	xxx/xxx/**

  或者是不想要拉取的文件路径

  1

  !yyy/**

  然后正常使用git pull拉取即可

  1. 注意使用较新版本的git；

  2. 使用方法也可以参考[官网链接](git config core.sparsecheckout true)

  结论

  最终我使用的是git-lfs搭配git parse checkout搭配使用，一方面降低大文件重复修改所产生的占用，一方面只需要拉取我自己需要的文件到本地即可。

  这样操作以后，原30G的git仓库，我现在只需要600M就可以了～

  ]]> https://baofeidyz.com/2020/e94cc37e0655/ baofeidyz's blog 技术 故障排查记录 Tue, 15 Dec 2020 01:00:00 GMT Java应用被k8s认定为oom杀掉

  前不久现场反馈说服务运行一段时间就重启了，希望我介入排查一下。

  先说结论

  jvm堆大小与k8s pod设置的大小一致，均为4g。因jvm还存在其他的内存占用，pod服务总体的内存占用会超过4g，k8s认定为oom，将其杀掉。以及jvm较低版本没有支持容器namespace的资源隔离。

  处理过程

  1. 检查日志

     看服务重启前后日志有无抛出一些较为严重的错误，是否存在因为个别异常导致的服务重启；

  2. 修改jvm堆的大小，增加oom时候自动dump等参数

     1. 怀疑是系统内部有一些“不良”业务导致的堆的大量占用，试想是否可以通过增加堆的大小，再对堆进行快照分析，确定具体占用较大堆内存的业务代码，对其进行定向优化。
     2. 增加-XX:+HeapDumpOnOutOfMemoryError以及-XX:HeapDumpPath=/myPath/heapdump.hprof参数，让jvm在下一次oom时自动导出堆的快照，便于分析。

     通过不停的分析堆的镜像快照，确实是没有任何业务代码过多的或者过量的导致了堆的增长，增加的-XX:+HeapDumpOnOutOfMemoryError也没有生效。

  3. 检查k8s pod信息

     在k8s
     pod信息查到，服务是以oom的原因导致被kill的。经过了解，k8s认定pod的内存占用达到了pod所配置的limit值时，就会判定为oom，然后杀掉，从侧面增加-XX:+HeapDumpOnOutOfMemoryError
     无效的原因。

     检查现场配置时发现，jvm堆的大小和pod的大小限制一致。已知java 8除了堆以外还有其他的内存占用，猜测是不是这部分导致了pod实际内存使用大小超过了pod限制导致。

     修改pod限制参数为6g后，问题得以解决。

  后续思考

  虽然修改为6g以后，服务不再被k8s以oom的原因kill了，但于此同时，还有一个问题一直萦绕着我。

  为什么jvm没有回收内存？

  在一番了解后，我了解到Java 1.8有一个更新，在Java 1.8
  191这个版本中，Java更新了对于namespace的支持，地址是：https://www.oracle.com/java/technologies/javase/8u191-relnotes.html，对应具体的bug描述是https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8146115

  容器是通过linux的namespace做资源隔离，通过pid下的cgroup做资源限制，但是在早先版本中，jvm并没有支持这一特性，从而导致了jvm内存不回收的问题。

  jvm指定的堆大小到底

  ]]> https://baofeidyz.com/2020/4fcfc7a47487/ 技术 Java Java中级 Thu, 10 Dec 2020 01:00:00 GMT 类的加载、链接和初始化（基于Java 1.8）

  Java的数据类型（Data type）主要是有两种：

  1. 基本类型 primitive types
  2. 引用类型 reference types

  其中引用类型又被细分为：

  1. 类 class types
  2. 数组 array types
  3. 接口 interface types

  基本类型和数组类型是由Java虚拟机直接生成的，其他（类 class types、接口 interface types）则需要Java虚拟机对其进行链接和初始化。

  1. Java虚拟机启动 Java Virtual Machine Startup

  • 通过引导类加载器创建一个初始类来启动，并执行这个public class中的void main(String[])方法。
  • 初始类可以作为命令行参数提供。或者，该实现可以提供一个初始类，该初始类设置一个类加载器，该类加载器进而加载。

  2. 创建和加载 Creation and Loading

  • 指查找字节流，并据此创建类的过程。
  • 其中数组（array types）是没有字节流的，由Java虚拟机直接生成，对于其他的类来说，Java虚拟机需要借助于类加载器来完成查找字节流的工程。

  2.1 类加载器 ClassLoader

  在Java虚拟机规范中，类加载器被分为两种：

  1. Java虚拟机提供的引导类加载器（bootstrap class loader)
  2. 用户定义的类加载器(user-defind class loaders)

  2.1.1 Java虚拟机提供的引导类加载器 bootstrap class loader

  • bootstrap class loader 由Java虚拟机提供的
  • 这个类加载器是使用C++实现的，没有对应的Java对象。

  2.1.2 用户定义的类加载器 user-defind class loaders

  • user-defind class loaders 是Java虚拟机规范中对于类加载器的分类划分，是一个统称，实际上并没有这个类加载器
  • 用户定义的类加载器都是java.lang.ClassLoader类的子类
  • 在Java虚拟机规范中提到，用户定义的类加载器可以实现通过网络下载类，动态生成类或从加密文件中提取类
  • 用户定义的类加载器需要由bootstrap class loader去加载
  • 在Java1.8的核心类库中，提供了两个类加载器，分别是：
    1. 扩展类加载器 extention class loader
       sun.misc.Launcher.ExtClassLoader
    2. 应用类加载器 application class loader
       sun.misc.Launcher.AppClassLoader

  2.1.2.1 扩展类加载器 extention class loader

  • 扩展类加载器的父是启动类加载器（bootstrap class loader)
  • 负责加载相对次要、但又通用的类，如JRE的lib/ext目录下jar包中的类（以及java.ext.dirs指定的类, 这个可以通过查看sun.misc.Launcher.ExtClassLoader.getExtDirs()方法确认）

  2.1.2.2 应用类加载器 application class loader

  • 应用类加载器的父则是扩展类加载器
  • 负责加载应用程序路径下的类（应用程序指虚拟机参数-cp/-classpath、系统变量java.class.path或环境变量CLASSPATH所指定的路径。这个可以通过查看sun.misc.Launcher.AppClassLoader确认）
  • 默认情况下，应用程序中包含的类便是通过应用类加载器加载的。

  2.1.3 双亲委派模型

  • 指的是一个类加载器接收到加载请求时，会先将请求转发给父类加载器，在父类加载器没有找到所请求的类的情况下，该类加载器才会去尝试加载。

  • 双亲委派模型可以避免类的重复加载，以及java的核心api被篡改的问题。

  3 链接 Linking

  • 指将创建的类合并至Java虚拟机中，使之能够执行的过程。可分为验证(Verification)、准备(Preparation)以及解析(Resolution)三个阶段

  3.1 验证 Verification

  验证是为了确保被加载的类满足Java虚拟机的约束条件。

  3.2 准备 Preparation

  • 准备是为被加载的类的静态字段分配内容。
  • 构造其他跟类层次相关的数据结构：如用来实现虚方法的动态绑定的方法表。

  3.3 解析 Resolution

  在开始解析之前，需要知道：
  class文件被加载到Java虚拟机之前，这个类无法知道其他类及其方法、字段所对应的具体地址，甚至不知道自己方法、字段的地址。因此，每当需要引用这些成员时，Java编译器会生成一个符号引用。在运行阶段，这个符号引用一般都能无歧义地定位到具体目标上。

  • 解析的目标是将符号引用解析成为实际应用： 如果符号引用指向一个未被加载的类，或者未被加载类的字段或方法，那么解析就触发这个类的加载。（但未必会出发这个类的链接和初始化）

  此外，在Java虚拟机规范中并没有要求在链接过程中完成解析。仅规定了：如果某些字节码使用了符号引用，那么在执行这些字节码之前，需要完成对这些符号引用的解析。

  4. 初始化 Initialization

  • 为标记为常量值的字段赋值，以及执行<clinit>方法的过程
  • Java虚拟机会通过加锁来确保类的<clinit>方法仅被执行一次

  常量值解释：
  Java代码中，如果要初始化一个静态字段，可以在声明时直接赋值，或者在静态代码块中对其进行赋值
  如果直接赋值的静态字段被final所修饰，并且它的类型是基本类型或字符串时，该字段便会被Java编译器标记为常量值（ConstantValue）

  4.1 初始化的触发条件

  在Java虚拟机规范中明确枚举了以下情况：

  • The execution of any one of the Java Virtual Machine instructions new, getstatic, putstatic, or invokestatic that references C (§new, §getstatic, §putstatic, §invokestatic). These instructions reference a class or interface directly or indirectly through either a field reference or a method reference.

  • Upon execution of a new instruction, the referenced class is initialized if it has not been initialized already.

  • Upon execution of a getstatic, putstatic, or invokestatic instruction, the class or interface that declared the resolved field or method is initialized if it has not been initialized already.

  • The first invocation of a java.lang.invoke.MethodHandle instance which was the result of method handle resolution (§5.4.3.5) for a method handle of kind 2 (REF_getStatic), 4 (REF_putStatic), 6 (REF_invokeStatic), or 8 (REF_newInvokeSpecial).

  • This implies that the class of a bootstrap method is initialized when the bootstrap method is invoked for an invokedynamic instruction (§invokedynamic), as part of the continuing resolution of the call site specifier.

  • Invocation of certain reflective methods in the class library (§2.12), for example, in class Class or in package java.lang.reflect.

  • If C is a class, the initialization of one of its subclasses.

  • If C is an interface that declares a non-abstract, non-static method, the initialization of a class that implements C directly or indirectly.

  • If C is a class, its designation as the initial class at Java Virtual Machine startup (§5.2).

  Java虚拟机规范中有部分是依赖于Java虚拟机指令了，我对此了解并不多，以下摘抄于《极客时间-深入拆解Java虚拟机-郑雨迪》的分享，相较而言更通俗易懂些。

  1. 当虚拟机启动时，初始化用户指定的主类；
  2. 当遇到用以新建目标类实例的new指令时，初始化new指令的目标类；
  3. 当遇到调用静态方法的指令时，初始化该静态方法所在的类；
  4. 当遇到访问静态字段的指令时，初始化该静态字段所在的类；
  5. 子类的初始化会触发父类的初始化；
  6. 如果一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，会触发该接口的初始化；
  7. 使用反射API对某个类进行反射调用时，初始化这个类；
  8. 当初次调用MethodHandle实例时，初始化该MethodHandle指向的方法所在的类。

  5. 绑定本机方法实现

  指的是将Java编程语言以为的其他语言编写的功能和实现native方法的功能集成到Java虚拟机中以便可以执行的过程。

  传统上来说，此过程可称为链接，但Java虚拟机规范中指出，使用绑定是为了避免于Java虚拟机对类和接口的链接产生混淆。

  6. Java虚拟机退出

  当调用Runtime.exit()、Runtime.halt()、System.exit，并且SecurityManager安全管理其允许exit或halt时候，Java虚拟机就会被关闭。

  同时，JNI（Java Native Interface）规范描述了对于JNI调用相关的java虚拟机的终止信息。

  参考文档

  https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html
  https://time.geekbang.org/column/article/11523

  ]]> https://baofeidyz.com/2020/135d626f9fdb/ HashMap源码实现解析

  技术 Java Java中级 Sat, 08 Aug 2020 01:00:00 GMT HashMap源码实现解析

  1 2 3

  java version "1.8.0_251" Java(TM) SE Runtime Environment (build 1.8.0_251-b08) Java HotSpot(TM) 64-Bit Server VM (build 25.251-b08, mixed mode)

  基于数组+链表实现，通过&与运算，计算数组下标。在JDK8中，加入红黑树实现，使其时间复杂度保持在O(1)到O(logn)

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

  /** * The table, initialized on first use, and resized as * necessary. When allocated, length is always a power of two. * (We also tolerate length zero in some operations to allow * bootstrapping mechanics that are currently not needed.) */ transient Node<K,V>[] table; static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }

  HashMap 静态内部类Node，实现链表，通过Node[]这个数组属性存放所有的节点。

  put(K,V)

  应该直接看final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)这个方法更为实际

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

  final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }

  如果当前想要存放的这个节点的hash值暂时没有存在的节点，则直接在数组中添加。

  1 2	if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);

  通过&与运算，

  如果当前节点的hash值存在了，则在这个节点下增加链表。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

  else { Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } }

  从JDK8 开始，当链表中的子节点超过八个时，将转为红黑树。关于红黑树的数据结构特点，我现在也不是特别的理解，先给自己挖个坑，改天填。

  红黑树

  HashMap扩容

  HashMap中有一个属性：threshold ，这个主要是根据阀值和当前HashMap的大小计算而来，可通过查看

  1 2 3 4 5 6 7 8 9 10 11 12

  public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity); }

  在初始化HashMap的最后，会根据当前的阀值和实际的大小进行计算threshold的值，同时在每一次操作元素的时候，都会去比较当前HashMap的实际大小与threshold的值，如果当前实际大小已经大于了这个限定的阀值，此时将会对HashMap进行扩容。

  resize()方法主要是两个步骤：

  1. 计算大小；
  2. 将原HashMap中的元素进行移动

  挖坑，以后填

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) { if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr;

  get(Object key)

  get方法就更好理解了，首先还是通过hash值找到数组下标，然后通过数组下标获取的实际的元素。然后判断一下当前节点key的hash值是否与第一个节点相同，相同则直接返回结果。

  如果不同，这个时候，就得看第一个节点后的下一个节点是采用的红黑树还是使用的链表。然后再根据key的hash去取值即可。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; if ((e = first.next) != null) { if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }

  ]]> https://baofeidyz.com/2020/ca30dff3752f/ ArrayList源码解析

  技术 Java Wed, 05 Aug 2020 01:00:00 GMT ArrayList源码解析

  1 2 3

  java version "1.8.0_251" Java(TM) SE Runtime Environment (build 1.8.0_251-b08) Java HotSpot(TM) 64-Bit Server VM (build 25.251-b08, mixed mode)

  基于数组实现

  1	transient Object[] elementData;

  add(E e)

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  /** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return <tt>true</tt> (as specified by {@link Collection#add}) */ public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); } private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }

  size是当前数组实际使用的大小，如果当前所需要的数组地址已经大于了当前数组的容量，则对数组进行扩容操作，即调用grow方法。

  1 2 3 4 5 6 7 8 9 10 11

  private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); }

  得到所需要扩容的大小以后，调用navite方法对集合进行扩容。
  扩容结束以后，将size（代表着实际占用的变量）进行自增，同时将这个数组下标进行赋值。

  remove(Object o)

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; }

  remove方法实际上就是遍历数组所有的元素，然后找到数组下标，再根据数组下标进行删除

  1 2 3 4 5 6 7 8 9 10 11 12

  /* * Private remove method that skips bounds checking and does not * return the value removed. */ private void fastRemove(int index) { modCount++; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // clear to let GC do its work }

  定位到具体需要删除的数组下标以后，将下标后的数据往前移动，并将最后一个元素设为null，便于GC回收内存。

  迭代器

  私有内部类，通过“游标”去操作数组

  为什么不能在循环里面增加或删除元素

  foreach

  foreach本质上就是迭代器的实现，但在删除的时候，使用的是集合的remove方法，而不是迭代器提供的remove方法，这就导致在迭代器遍历中，有一个校验是否并发修改的方法无法通过验证，抛出异常。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  @SuppressWarnings("unchecked") public E next() { checkForComodification(); int i = cursor; if (i >= size) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) throw new ConcurrentModificationException(); cursor = i + 1; return (E) elementData[lastRet = i]; } // modCount是ArrayList中的属性值，是集合添加元素、删除元素的次数，expectedModCount是迭代器中的属性值，是预期的修改次数。实际修改值与期望值不同 final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }

  for循环

  for循环本质上是使用数组下标遍历数组，通过前文中提到的remove(Object o)方法的实现，可以了解到，实际上是将需要删除的元素后的数组向前移动，并将最后一个元素设为null，便于GC回收。

  那么当我们使用for循环操作数组，并对其进行删除操作的时候

  1 2 3 4 5

  for (int i = 0; i < list.size(); i++){ if(list[i] == 'xxx'){ list.remove(i); } }

  假设数组中，第X个元素满足条件，并将其进行删除。 此时X后的数据元素全部向前移动，那么第X个元素，已经是移动前X+1，如果此时i++自增，那么你取到的是未移动前的X+2个元素。

  所以我们只需要修正一下遍历的数组下标即可解决

  1 2 3 4 5 6

  for (int i = 0; i < list.size(); i++){ if(list[i] == 'xxx'){ list.remove(i); i--; } }

  部分参考： https://blog.csdn.net/wangjun5159/article/details/61415358

  ]]> https://baofeidyz.com/2020/0b6497dc2639/ baofeidyz's blog 技术 踩坑 Maven Sun, 05 Jul 2020 01:00:00 GMT 解决私有证书导致Maven无法更新的问题

  最近公司更换了maven的私有化仓库，一般来说，其实也没啥大问题，就是修改一下setting文件就好了。但麻烦的是，他们搞了一个自签的证书，强制使用了https。

  遇到的问题

  全局代理

  这个属于自己把自己坑了，怪自己科学上网管理不当。

  1. 终端检查是否有全局代理

     1 2 3

     echo $http_proxy echo $https_proxy echo $all_proxy

  2. 检查IDEA代理设置

     Preferences->Appearance & Behaivor->System Settings->HTTP Proxy

  3. You have JVM property https.proxyHost set

  在IDEA 的 HTTP Proxy页面看到了这个警告，通过一番搜索，发现可以在IDEA的配置文件vmoptions里面加上-Djava.net.useSystemProxies=true解决掉

  证书问题

  由于公司用的是自签的证书，所以还得配置自签的证书

  其实最开始我是没有确认原因的，我是通过IDEA help->Show log in finder找到了IDEA的详细日志，才确认到因为证书问题导致无法更新的。

  由于maven是依赖于java的，即便是我给macOS安装了根证书也无效，所以还得给java运行环境安装根证书才可以。

  需要注意的是，idea默认启动maven的jdk环境可能并不是系统安装的jdk，需要到idea配置面板中确认一下即可。

  

  ]]> https://baofeidyz.com/2020/4f7ec9837351/ 记因缓存返回引用对象导致的线程安全问题 baofeidyz's blog 技术 Java 踩坑 故障排查记录 Thu, 11 Jun 2020 01:00:00 GMT 记因缓存返回引用对象导致的线程安全问题

  背景

  前几天处理生产环境问题的时候，遇到一个因为缓存写的不太好，直接返回了引用对象，导致的线程安全问题。

  日志信息

  日志如下，部分与公司有关的信息已经删掉。

  1 2 3 4 5 6 7 8

  2020-06-01 14:37:49 [ERROR] [task-3] xxx -失败！ java.util.ConcurrentModificationException: null at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859) ~[na:1.7.0_80] at java.util.ArrayList$Itr.next(ArrayList.java:831) ~[na:1.7.0_80] 2020-06-01 14:37:49 [ERROR] [qtp1073067421-33398] xxx -失败！ java.util.ConcurrentModificationException: null at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859) ~[na:1.7.0_80] at java.util.ArrayList$Itr.next(ArrayList.java:831) ~[na:1.7.0_80]

  排查过程

  两个线程同时抛出一个异常点，在被我删掉的日志中显示这两个线程正在执行同一行代码。

  两个线程执行的同一行代码其实是一个foreach遍历，且经我检查，并没有对集合中的对象进行remove的操作。

  继续排查发现，这个foreach操作的对象是从一个缓存中获取到的，于是顺着这个缓存开始继续排查。跟着代码调用逻辑发现，有直接往这个缓存返回的list中做add的操作。

  检查后发现这个我们系统自己使用ConcurrentHashMap封装的缓存直接返回了引用对象ArrayList，且可读可写。

  结论

  最后其实结论就是缓存使用不当，导致多线程操作ArrayList对象，一边遍历一边插入新的元素，导致迭代器在做check的时候抛出了一场，出现了线程安全的问题。

  解决方案

  1. 返回结果的时候拷贝，不要直接返回引用对象
  2. 使用线程安全的List实现
  3. 还有啥？记一个TODO

  ]]> https://baofeidyz.com/2020/dc3b4841ef39/ baofeidyz's blog 技术 Java Java中级 Fri, 29 May 2020 01:00:00 GMT 线程安全的概念

  我的理解是由于程序使用多线程的方式运行，导致程序无法正确的得出我们期望的结果。

  什么会导致线程安全问题，主要是可见性、原子性、有序性问题。详细可见：Java并发编程-可见性、原子性、有序性问题引入

  线程安全的实现方式

  可见性和有序性问题

  主要是通过volatile、Happens-Before规则以及final关键字解决。详细可见Java并发编程-如何解决可见性和有序性问题

  原子性问题

  互斥锁

  sychronized

  死锁问题

  产生死锁需要同时满足四个条件，即：

  1. 互斥：共享资源X和Y只能被一个线程占用
  2. 占有且等待：线程1已经取得共享资源x，在等待共享资源y时，不释放共享资源x
  3. 不可抢占：其他线程不可抢占线程1占有的资源
  4. 循环等待：线程1等待线程2占有的资源，线程2等待线程1占有的资源

  解决死锁问题，就是解决上面四个条件的任一一个。

  1. 对于“占用且等待”条件，我们可一次性申请所有资源。
  2. 对于“不可抢占”条件，占用部分资源的线程进一步申请其他资源时，如果申请不到，可主动释放它占有的资源。
  3. 对于“循环等待”条件，按序申请，即资源是有线性顺序的，申请的时候可以先申请资源序号小的，再申请序号大的。

  针对于“不可抢占”条件，sychronized申请不到资源时会进入阻塞状态，无法释放已占有的资源，我们应使用JUC提供的Lock解决

  sychronized关键字的使用场景、作用范围

  实现方法

  利用Monitor，在使用sychronized关键字修饰的代码块，编译后自动生成相关加锁和解锁的代码，但仅支持一个条件变量，通过monitorenter和monitorexit实现。

  修饰非静态方法

  默认对当前实例对象this加锁

  修饰静态方法

  默认对当前类的Class对象加锁

  管程Monitor

  

  为什么局部变量是线程安全的？

  调用栈和栈帧

  CPU支持栈结构，这个栈与方法调用相关，被称为调用栈。
  每个方法在调用栈中都有自己的独立空间，被称为栈帧，每个栈帧都有对应方法需要的参数和返回地址。

  当调用方法时，会创建新的栈帧，并压入调用栈；当方法返回时，对应的栈帧会自动弹出，即栈帧和方法是同生共死的。
  

  局部变量存储位置

  局部变量放到了调用栈里，如下图所示：
  

  调用栈与线程

  每个线程都有自己独立的调用栈
  

  JUC中锁的分类和用途

  公平锁、非公平锁

  公平锁，多个线程按照申请锁的顺序来获取锁。会判断当前线程是否处于等待队列的头部，即链表的头部，如果是的话就直接获取锁。
  非公平锁，没有顺序。不会判断当前线程处于等待队列的具体位置。CAS操作成功则认定为获取到锁。
  synchronized是非公平锁，ReentrantLock可通过构造函数决定是公平锁还是非公平锁。

  可重入锁

  线程可重复获取同一把锁。
  ReentrantLock在获取锁时，判断当前线程是否是之前已获取锁的线程，如果是，则直接返回true表示锁获取成功。

  互斥锁（独享锁）、读写锁（共享锁）

  互斥锁（独享锁）指锁一次只能被一个线程持有，读写锁（共享锁）指该锁可被多个线程持有。
  synchronized和ReentrantLock都是互斥锁（独享锁），ReadWriteLock的读锁是共享锁，写锁是独占锁。

  乐观锁、悲观锁

  乐观锁在更新数据时会不断尝试更新，认为不加锁的并发操作是没问题的。基于CAS实现。
  悲观锁认为对一个共享变量的并发操作，这个共享变量是一定会发生修改的，采取加锁方式。

  乐观锁适合读操作远远大于写操作的情景，悲观锁适合写操作非常多的场景。

  分段锁

  对于ConcurrentHashMap来说，在put操作时，通过hashcode判断将要put的元素需要放到哪个分段，然后对分段进行加锁。当put操作不同的分段时，就可以实现并发操作。

  无锁、偏向锁、轻量级锁、重量级锁

  

  自1.6以后，java对synchronized进行了优化，当第一个线程获得了锁，锁状态变更新为偏向锁状态。

  偏向锁

  获取锁：当之前的线程再次获取锁时，无需再执行获取锁的过程。
  锁撤销：原持有偏向锁的线程状态是非活动状态时，偏向锁撤销，锁状态更新为无锁状态。

  轻量级锁

  获取锁：如果每次申请锁的线程都是不相同的，则锁会升级为轻量级锁，指向栈中锁记录的指针。轻量级锁适用于线程交替执行同步块的场景。
  释放锁：通过CAS操作，尝试把线程中复制的Displaced Mark Word对象替换当前的Mark Word，如果成功则完成解锁操作。如果失败则表明有其他线程获取该锁，此时锁膨胀为重量级锁。释放锁的同时，唤醒被挂起的线程。

  重量级

  当多个线程同时竞争锁，则轻量级锁会膨胀为重量级锁。指向互斥量的指针。未获取到锁的线程会阻塞。

  自旋锁

  循环检测锁标志位

  可中断锁

  Lock

  1 2 3 4 5 6 7 8

  // 支持中断的 API void lockInterruptibly() throws InterruptedException; // 支持超时的 API boolean tryLock(long time, TimeUnit unit) throws InterruptedException; // 支持非阻塞获取锁的 API boolean tryLock();

  线程安全的集合

  List

  CopyOnWriteArrayList

  在写操作的时候，会将共享变量复制一份出来，当写操作完成以后，再修改共享变量的内存引用地址。
  不能使用迭代器删除数据，因为操作的是一个副本，不会修改到实际的共享变量。

  Map

  ConcurrentHashMap

  • KEY和VALUE不允许为空
  • KEY是无序的

  ConcurrentSkipListMap

  • KEY和VALUE不允许为空
  • KEY是有序的
  • 实现方案是使用SkipList（跳表）数据结构

  Set

  CopyOnWriteArraySet

  类似于CopyOnWriteArrayList

  ConcurrentSkipListSet

  类似于ConcurrentSkipListMap

  Queue

  单端阻塞队列

  ArrayBlockingQueue

  使用数组实现

  LinkedBlockingQueue

  使用链表实现

  SynchronousQueue

  不持有队列，入队操作必须要等到消费者线程的出队操作

  LinkedTransferQueue

  链表实现，入队操作必须要等到消费者线程的出队操作

  PriorityBlockingQueue

  支持按照优先级出队

  DelayQueue

  支持延时出队

  双端阻塞队列

  LinkedBlockingDeque

  单端非阻塞队列

  ConcurrentLinkedQueue

  双端非阻塞队列

  ConcurrentLinkedDeque

  原子类

  原子化的基本数据类型

  AtomicBoolean

  AtomicInteger

  AtomicLong

  原子化的对象引用类型

  AtomicReference

  AtomicStampedReference

  AtomicMarkableReference

  用锁的最佳实践

  1. 永远只在更新对象的成员变量时加锁
  2. 永远只在访问可变的成员变量时加锁
  3. 永远不在调用其他对象的方法时加锁

  ]]> https://baofeidyz.com/2020/9f200d0fd6f4/ Gitlab Runner的安装与注册 baofeidyz's blog 技术 Git Gitlab-CICD Thu, 28 May 2020 01:00:00 GMT Gitlab Runner的安装与注册

  1.访问项目的gitlab页面获取token

  Settings -> CI/CD -> Runners

  获取到当前项目的key，如下图所示：

  

  此时我们就可以拿到对应的token了

  2. 安装gitlab runner

  官网安装教程：https://docs.gitlab.com/runner/install/

  建议是安装到CentOS服务器上

  1. 添加源

  1	curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.rpm.sh | sudo bash

  2. 通过包管理工具安装

  1	sudo yum install gitlab-runner

  默认会安装最新的版本，如果需要安装特定版本则可以通过以下命令实现

  1 2	yum list gitlab-runner --showduplicates | sort -r sudo yum install gitlab-runner-10.0.0-1

  3. 注册gitlab runner

  1	sudo gitlab-runner register

  需要输入项目所在的gitlab地址，类似于https://gitlab.xxx.com
  回车过后需要输入项目的token，也就是我们在第一步中获取到的
  后面会要求输入一些描述，紧接着是tag，这个可以用于.gitlab-ci.yml文件中指定具体的runner，可以认为tag就是这个当前注册runner的身份ID。最后是选择执行器，初级选手，只会使用shell,其他相关的请看EXECUTORS执行器简单介绍

  另，一台服务器可以注册多个gitlab runner

  EXECUTORS执行器简单介绍

  执行者	描述
  shell	在本地运行构建，默认
  docker	使用Docker容器运行构建 - 这需要在Runner运行的系统上安装[runners.docker]和Docker Engine
  docker-ssh	运行生成使用泊坞容器，但用SSH连接到它-这需要的存在[runners.docker]，[runners.ssh]以及码头工人引擎的亚军运行的系统上安装。注意：这将在本地计算机上运行docker容器，它只是更改命令在该容器内运行的方式。如果要在外部计算机上运行docker命令，则应更改host该runners.docker部分中的参数。
  ssh	使用SSH远程运行构建 - 这需要存在 [runners.ssh]
  parallels	使用Parallels VM运行构建，但使用SSH连接到它 - 这需要存在[runners.parallels]和[runners.ssh]
  virtualbox	使用VirtualBox VM运行构建，但使用SSH连接到它 - 这需要存在[runners.virtualbox]和[runners.ssh]
  docker+machine	喜欢docker，但使用自动缩放的Docker机器 - 这需要存在[runners.docker]和[runners.machine]
  docker-ssh+machine	喜欢docker-ssh，但使用自动缩放的Docker机器 - 这需要存在[runners.docker]和[runners.machine]
  kubernetes	使用Kubernetes Pods运行构建 - 这需要存在 [runners.kubernetes]

  shell执行器补充

  shell执行器是根据当前gitlab runner所安装的操作系统来决定的

  shell	描述
  bash	生成Bash（Bourne-shell）脚本。在Bash上下文中执行的所有命令（所有Unix系统的默认值）
  sh	生成Sh（Bourne-shell）脚本。Sh上下文中执行的所有命令（适用bash于所有Unix系统的后备）
  cmd	生成Windows批处理脚本。所有命令都在批处理上下文中执行（Windows的默认值）
  powershell	生成Windows PowerShell脚本。所有命令都在PowerShell上下文中执行

  .gitlab-ci.yml基本语法

  以下内容暂时只针对shell执行器

  config.toml基本配置

  官方文档介绍：https://docs.gitlab.com/runner/configuration/advanced-configuration.html

  全局配置

  关键字	描述
  concurrent	限制全局可以同时运行的作业数。使用所有已定义的运行者的作业的最大上限。0并不是指无限制，如果服务器性能还不错，可以尝试给个5
  log_level	日志级别（选项：调试，信息，警告，错误，致命，恐慌）。请注意，此设置的优先级低于命令行参数设置的级别--debug，-l或--log-level
  log_format	日志格式（选项：runner，text，json）。请注意，此设置的优先级低于命令行参数设置的格式--log-format
  check_interval	定义新作业检查之间的间隔长度（以秒为单位）。默认值为3; 如果设置为0或更低，将使用默认值。
  sentry_dsn	启用跟踪哨兵的所有系统级错误
  listen_address	地址（<host>:<port>），Prometheus指标HTTP服务器应该在其上监听

  [session_server]介绍

  此项配置应在[[runners]]外部指定，主要包含以下参数

  设置	描述
  listen_address	用于会话服务器的内部URL。
  advertise_address	Runner将向GitLab公开的URL，用于访问会话服务器。listen_address如果没有定义，则回退到。
  session_timeout	作业完成后会话可以保持活动状态的多长时间（这将阻止作业完成），默认为1800（30分钟）。

  其中listen_address和advertise_address需要以host:port形式提供，其中host可以是IP地址，也可以是域名。

  示例：

  1 2 3 4

  [session_server] listen_address = "0.0.0.0:8093" # listen on all available interfaces on port 8093 advertise_address = "runner-host-name.tld:8093" session_timeout = 1800

  [[runners]]介绍

  一个config.toml文件允许存在多个[[runners]]，也就对应了上文中提到的一个服务器允许注册多个gitlab runner
  相关配置参数介绍如下表所示：

  设置	描述
  name	Runner的描述，只是提供信息
  url	GitLab URL
  token	Runner的特殊令牌（不要与注册令牌混淆）
  tls-ca-file	包含证书的文件，用于在使用HTTPS时验证对等方
  tls-cert-file	包含证书的文件，以便在使用HTTPS时与对等方进行身份验证
  tls-key-file	包含私钥的文件，用于在使用HTTPS时与对等方进行身份验证
  limit	限制此令牌可同时处理的作业数。0（默认）仅表示不限制
  executor	选择应如何构建项目
  shell	用于生成脚本的shell的名称。默认值取决于平台。
  builds_dir	构建将存储在所选执行程序的上下文中的目录（本地，Docker，SSH）
  cache_dir	构建缓存的目录将存储在所选执行程序（本地，Docker，SSH）的上下文中。如果使用docker执行程序，则此目录需要包含在其volumes参数中。
  environment	附加或覆盖环境变量
  request_concurrency	限制GitLab新作业的并发请求数（默认值为1）
  output_limit	设置最大构建日志大小（以KB为单位），默认设置为4096（4MB）
  pre_clone_script	在克隆Git存储库之前要在Runner上执行的命令。例如，这可以用于首先调整Git客户端配置。要插入多个命令，请使用（三引号）多行字符串或“\ n”字符。
  pre_build_script	在克隆Git存储库之后但在执行构建之前要在Runner上执行的命令。要插入多个命令，请使用（三引号）多行字符串或“\ n”字符。
  post_build_script	在执行构建之后但在执行之前要在Runner上执行的命令after_script。要插入多个命令，请使用（三引号）多行字符串或“\ n”字符。
  clone_url	覆盖GitLab实例的URL。如果Runner无法连接到GitLab上的GitLab暴露自己，则使用。
  debug_trace_disabled	禁用该CI_DEBUG_TRACE功能。设置为true时，即使用户CI_DEBUG_TRACE将设置为调试跟踪，也将保持禁用状态true。

  示例：

  1 2 3 4 5 6 7 8 9 10

  [[runners]] name = "ruby-2.1-docker" url = "https://CI/" token = "TOKEN" limit = 0 executor = "docker" builds_dir = "" shell = "" environment = ["ENV=value", "LC_ALL=en_US.UTF-8"] clone_url = "http://gitlab.example.local"

  ]]> https://baofeidyz.com/2019/0e68c9260224/ Java线程基础

  baofeidyz's blog 技术 多线程 Java Fri, 26 Jul 2019 01:00:00 GMT Java线程基础

  线程状态

  关于java的线程状态，实际上你只要看Thread.java源码就可以了，网上很多资料都不全，而且往往你看了资料以后根本记不住，反而自己去花时间看看源码，思考每次位运算的结果，才能让你真的理解和掌握线程的状态转换~当然，我也不建议你看我的这篇文章，毕竟我是写给我自己看的。

  NEW

  Thread state for a thread which has not yet started.

  还没有开始的状态，就是new

  RUNNABLE

  Thread state for a runnable thread. A thread in the runnable state is executing in the Java virtual achine but it may be waiting for other resources from the operating system such as processor.

  正在jvm虚拟机中运行的状态，但是可能还需要等待系统资源，类似于cpu这种资源。

  BLOCKED

  Thread state for a thread blocked waiting for a monitor lock. A thread in the blocked state is waiting for a monitor lock to enter a synchronized block/method or reenter a synchronized block/method after calling

  在monitor管程阻塞等待获取资源（锁）的状态，主要表现在synchronized block/method

  WAITING

  Thread state for a waiting thread. A thread is in the waiting state due to calling one of the following methods:

  Object.wait with no timeout

  Thread.join with no timeout

  LockSupport.park

  A thread in the waiting state is waiting for another thread to perform a particular action.

  当调用Object.wait()、Thread.join()、LockSupport.park()方法的时候，调用线程就会进入waiting状态，只有当线程调用Object.notify()或者Object.notifyAll()方法的时候才会终止。另外，一个线程调用另外一个线程的join()方法，则该线程将等待另外一个线程执行结束。

  TIMED_WAITING

  Thread state for a waiting thread with a specified waiting time. A thread is in the timed waiting state due to calling one of the following methods with a specified positive waiting time.

  TERMINATED

  Thread state for a terminated thread.The thread has completed execution.

  ]]> https://baofeidyz.com/2019/19058a7e9208/ baofeidyz's blog 技术 多线程 Java Java中级 Sun, 21 Jul 2019 01:00:00 GMT 从源码看ThreadPoolExecutor和BlockQueue

  JDK版本

  此文章基于jdk 1.8.0_191

  需要用到的知识点

  位运算

  操作符	描述	例子
  ＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
  |	如果相对应位都是0，则结果为0，否则为1	（A | B）得到61，即 0011 1101
  ^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
  〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
  <<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
  >>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
  >>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

  线程池原理

  摘自 汪文君. Java高并发编程详解：多线程与架构设计 (Java核心技术系列) (Kindle 位置 2508-2512). 北京华章图文信息有限公司. Kindle 版本.

  所谓线程池通俗的理解就是有一个池子，里面存放着已经创建好的线程，当有任务提交给线程池执行时，池子中的 某个线程会主动执行该任务。如果池子中的线程数量不够应付数量众多的任务时，则需要自动扩充新的线程到池子 中，但是该数量是有限的，就好比池塘的水界线一样。当任务比较少的时候，池子中的线程能够自动回收，释放 资源。为了能够异步地提交任务和缓存未被处理的任务，需要有一个任务队列。

  

  一个完整的线程池应该具备如下要素：

  1. 任务队列：用于缓存提交的任务
  2. 线程数量管理功能：一个线程池必须能够很好地管理和控制线程数量，可通过如下三个参数来实现，比如创建 线程池时初始的线程数量 init；线程池自动扩充时最大的线程数量max；在线程池空闲时需要释放线程但是也要维护一定数量的活跃数量或者核心数量core。有了这三个参数，就能够很好地控制线程池中的线程数量，将其维护在一个合理的范围之内，三者之间的关系是 init<= core<= max
  3. 任务拒绝策略：如果线程数量已达到上限且任务队列已满，则需要有相应的拒绝策略来通知任务提交者
  4. 线程工厂：主要用于个性化定制线程，比如线程设置为守护线程以及设置线程名称等
  5. QueueSize：任务队列主要存放提交的Runnable，但是为了防止内存溢出，需要有limit数量对其进行控制
  6. Keepedalive 时间：该时间主要决定线程各个重要参数自动维护的时间间隔

  线程池的五种状态

  线程池状态示意图以及五种状态的说明摘自CSDN一只逗比的程序猿

  一共有五种，分别是RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED

  线程池状态切换示意图

  

  RUNNING

  状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理

  状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0

  SHUTDOWN

  状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务

  状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN

  注：虽然状态已经不是RUNNING了，但是如果任务队列中还有任务的时候，线程池仍然会继续执行，具体分析请见ThreadPoolExecutor.execute()方法解析

  STOP

  状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务

  状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP

  TIDYING

  状态说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现

  状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。
  当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING

  TERMINATED

  状态说明：线程池彻底终止，就变成TERMINATED状态

  状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED

  线程池五种状态的二进制表示

  线程池状态	二进制
  RUNNING	111
  SHUTDOWN	000
  STOP	001
  TIDYING	010
  TERMINATED	011

  1 2 3 4 5 6 7 8 9 10 11

  COUNT_BITS :29 RUNNING :11100000 00000000 00000000 00000000 SHUTDOWN :00000000 00000000 00000000 00000000 STOP :00100000 00000000 00000000 00000000 TIDYING :01000000 00000000 00000000 00000000 TERMINATED :01100000 00000000 00000000 00000000 RUNNING :-536870912 SHUTDOWN :0 STOP :536870912 TIDYING :1073741824 TERMINATED :1610612736

  ThreadPoolExecutor解读

  构造函数解读

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) throw new IllegalArgumentException(); if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException(); this.acc = System.getSecurityManager() == null ? null : AccessController.getContext(); this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; }

  先看参数

  1 2 3 4 5 6 7

  int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler

  对应含义关系如下

  参数名	类型	备注
  corePoolSize	int	核心线程数（如果allowCoreThreadTimeOut为true，核心线程将一直存活）
  maximumPoolSize	int	允许创建的最大线程数 （如果使用了无界队列LinkedBlockingQueue，这个值会失效，原因在讲解execute方法中提及）
  keepAliveTime	long	非核心线程闲置时的超时时长（如果allowCoreThreadTimeOut为true，这个时长也会用于核心线程）
  unit	TimeUnit	参数keepAliveTime的单位
  workQueue	BlockingQueue<Runnable>	任务队列，可选的子类有 ArrayBlockingQueue DelayQueue LinkedBlockingDeque LinkedBlockingQueue LinkedTransferQueue PriorityBlockingQueue SynchronousQueue
  threadFactory	ThreadFactory	线程工厂，为线程池提供创建新线程的功能（其他构造函数中默认传Executors.defaultThreadFactory()
  handler	RejectedExecutionHandler	拒绝策略，当队列和线程池都满了就才会根据这个策略进行处理。（默认为AbortPolicy，直接抛出异常），可选子类有ThreadPoolExecutor.AbortPolicy ThreadPoolExecutor.CallerRunsPolicy ThreadPoolExecutor.DiscardOldestPolicy ThreadPoolExecutor.DiscardPolicy

  执行方法解读

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

  public void execute(Runnable command) { if (command == null) throw new NullPointerException(); /* * Proceed in 3 steps: * * 1. If fewer than corePoolSize threads are running, try to * start a new thread with the given command as its first * task. The call to addWorker atomically checks runState and * workerCount, and so prevents false alarms that would add * threads when it shouldn't, by returning false. * * 2. If a task can be successfully queued, then we still need * to double-check whether we should have added a thread * (because existing ones died since last checking) or that * the pool shut down since entry into this method. So we * recheck state and if necessary roll back the enqueuing if * stopped, or start a new thread if there are none. * * 3. If we cannot queue task, then we try to add a new * thread. If it fails, we know we are shut down or saturated * and so reject the task. */ int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) reject(command); else if (workerCountOf(recheck) == 0) addWorker(null, false); } else if (!addWorker(command, false)) reject(command); }

  这里涉及到runState和workerCount两个概念，线程池中是利用32位的int变量来表示。

  因为线程池的状态总共有五种，2^2 = 4, 2^3 = 8，所以需要占用三位，实际采用的就是高三位表示，具体可见线程池五种状态的二进制表示

  剩下的部分全部都用于记录有效线程数，所以代码中也就规定有效线程数不可大于29位，也就是最大为2^29-1，详见execute()方法解析。

  然后我们再来一起看看execute(Runnable command)方法是如何运行的。

  execute()整体逻辑概览

  1. 最开始是一个基本的判空逻辑，如果传入的任务是空的则抛出异常
  2. 第一个判断：检查当前核心线程数，如果当前线程数小于核心线程则调用addWorker()方法创建线程，创建成功返回true
  3. 第二个判断：当核心线程池中的所有线程都在运行，此时将线程放到任务中
  4. 第三个判断：如果核心线程数已经满了，队列也添加失败了，那么这里就会调用上面提到的拒绝策略，如果我们没有在创建线程池时给出特定的拒绝策略，那么默认的实现就是抛出异常。

  1 2 3

  throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString());

  细节实现

  第一个判断：检查当前核心线程数

  1 2 3 4 5 6

  int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); }

  获取workerCount

  1 2	private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static int ctlOf(int rs, int wc) { return rs | wc; }

  这里的ctl变量是一个初始值为RUNNING的AtomicInteger对象，拿到的变量c中既存储了当前线程池的状态，又保存了当前线程池中的有效线程数量。

  画外音：这里的AtomicInteger对象为什么是线程安全的，是因为使用了CAS，具体不谈

  判断当前有效线程数量是否大于核心线程数量

  然后我们再看workerCountOf(c)方法的实现：

  1 2 3

  private static int workerCountOf(int c) { return c & CAPACITY; }

  CAPACITY的值为：

  1	00011111 11111111 11111111 11111111

  结合位运算法则，这里c & CAPACITY的结果集就是实际的有效线程数量。

  创建核心线程数量

  当有效线程数量小于核心线程数量的时候，我们需要调用addWorker(command, true)的方法去创建线程，这里的参数ture就用于标识当前想要创建的线程是核心线程。

  然后我们再来看看addWorker(command, true)方法的具体实现逻辑。

  addWork实现逻辑

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

  private boolean addWorker(Runnable firstTask, boolean core) { retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); // Check if queue empty only if necessary. if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false; for (;;) { int wc = workerCountOf(c); if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; if (compareAndIncrementWorkerCount(c)) break retry; c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop } } boolean workerStarted = false; boolean workerAdded = false; Worker w = null; try { w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { // Recheck while holding lock. // Back out on ThreadFactory failure or if // shut down before lock acquired. int rs = runStateOf(ctl.get()); if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); workers.add(w); int s = workers.size(); if (s > largestPoolSize) largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); } if (workerAdded) { t.start(); workerStarted = true; } } } finally { if (! workerStarted) addWorkerFailed(w); } return workerStarted; }

  rs为什么可以表示runstate？

  1	private static int runStateOf(int c) { return c & ~CAPACITY; }

  ~CAPACITY的值为：

  1	11100000 00000000 00000000 00000000

  所以后面的29位不论怎么样都会变成0，也就是最后的结果集中只会有高三位用于表示runstate的参数

  什么时候才会创建线程？

  1 2 3 4 5

  if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false;

  哇~这个判断真的是够绕的，我看了老半天，一起来缕一缕

  1	rs >= SHUTDOW

  代表当前runstate是SHUTDOWN STOP TIDYING TERMINATED 任意一个，关于五种状态的值可见线程池五种状态的二进制表示

  1	! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())

  A：在rs >= SHUTDOW成立的前提下，如果是rs != SHUTDOWN，则整个判断成立。

  B：在rs >= SHUTDOW成立的前提下，如果是firstTask != null，则整个判断成立。

  C：在rs >= SHUTDOW成立的前提下，如果是 workQueue.isEmpty()，则整个判断成立。

  并且A B C三个是有先后顺序的

  再总结一下就是在第一个判断成立的前提下，第二个判断中，只要有一个不成立就会返回false，线程创建失败。

  转成白话文就是

  A 当线程池状态为STOP TIDYING TERMINATED时，不会创建线程

  B 当线程池为SHUTDOWN时，不允许新建任务

  C 当线程池为SHUTDOWN时，且没有新的任务，此时如果任务队列也经没有任务，同样不会创建线程

  此时再回头看看线程池的五种状态

  ---

  接着往下看

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  for (;;) { // 第一步，拿到当前的有效线程数 int wc = workerCountOf(c); // 如果当前有效线程数已经大于等于允许的最大线程数，不允许创建 // 如果正准备创建的线程是core的线程且大于线程池初始化时设定的线程数，不允许创建 // 如果正准备创建的线程不是core但大于线程池初始化时设定的最大线程数，不允许创建 if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; // 利用CAS做自增操作，如果成功了，就跳出循环体开始下一步操作，如果失败则重试 if (compareAndIncrementWorkerCount(c)) break retry; // 重新读取当前的runstate，如果当前的runstate和循环体中的runstate有变化，则重新去判断是否需要创建线程 c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop }

  线程到底是怎么创建的呢？

  经历了层层校验逻辑，我们总算是要准备创建线程了。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

  // 标记线程是否启动 boolean workerStarted = false; // 标记线程是否被添加 boolean workerAdded = false; Worker w = null; try { w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; // 获取锁 mainLock.lock(); try { // Recheck while holding lock. // Back out on ThreadFactory failure or if // shut down before lock acquired. int rs = runStateOf(ctl.get()); // 再检查一下当前线程池的状态 // rs < SHUTDOWN 表示线程池的状态为RUNNING就直接创建线程 // rs == SHUTDOWN && firstTask == null 当前线程已经处于SHUTDOWN且当前没有新建的任务（也就是为了把任务队列执行完） if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { // 如果正准备创建的线程已经处于alive状态，则抛出异常 if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); // 否则放到workers中（包含线程池中所有的工作线程，将新构造的工作线程加入到工作线程集合中） workers.add(w); int s = workers.size(); if (s > largestPoolSize) largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); } if (workerAdded) { t.start(); workerStarted = true; } } } finally { if (! workerStarted) addWorkerFailed(w); }

  总结

  创建线程的条件：

  当前线程池状态为RUNNING，当前线程数小于核心线程数或当前线程线程数小于最大线程数。其中最大线程数又分为创建线程池时给定的数量以及程序允许的最大值。

  不创建线程的条件：

  当线程池状态不为RUNNING时，不会接受新的任务，此时如果任务队列还有任务，会把这部分处理完。

  第二个判断：当核心线程池中的所有线程都在运行，此时将线程放到任务中

  1 2 3 4 5 6 7 8 9 10

  // 检查当前线程池状态，如果为RUNNING状态，则尝试将任务放到任务队列中 if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); // 放置成功以后，再次检查当前的线程池状态，如果当前线程池状态非RUNNING，则尝试将刚刚放入的任务从任务队列中移除 if (! isRunning(recheck) && remove(command)) reject(command); // 如果当前线程数状态为RUNNING，但是workerCount的值又等于0则传入空任务结束此次创建 else if (workerCountOf(recheck) == 0) addWorker(null, false); }

  第三个判断：什么时候执行拒绝策略？

  1 2	else if (!addWorker(command, false)) reject(command);

  当第二个判断不成立，也就是当前线程池状态非RUNNING状态或尝试将任务放到任务队列中失败时，尝试再次创建一个非核心线程，此时线程数需要小于创建线程池时给定的最大值。

  总结

  结合第二个判断和第三个判断，就可以明白为什么当任务队列是无界的时候，最大线程数不会产生作用了。

  工作线程的执行

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

  final void runWorker(Worker w) { Thread wt = Thread.currentThread(); // 得到当前线程 Runnable task = w.firstTask; // 得到Worker中的任务task，也就是用户传入的task w.firstTask = null; // 将Worker中的任务置空 w.unlock(); // allow interrupts。 boolean completedAbruptly = true; // 标识当前Worker异常结束，默认是异常结束 try { // 如果worker中的任务不为空，执行执行任务 // 否则使用getTask获得任务。一直循环，除非得到的任务为空才退出 while (task != null || (task = getTask()) != null) { // 如果拿到了任务，给自己上锁，表示当前Worker已经要开始执行任务了， // 已经不是处于闲置Worker(闲置Worker的解释请看下面的线程池关闭) w.lock(); // 在执行任务之前先做一些处理。 // 1. 如果线程池已经处于STOP状态并且当前线程没有被中断，中断线程 // 2. 如果线程池还处于RUNNING或SHUTDOWN状态，并且当前线程已经被中断了， // 重新检查一下线程池状态，如果处于STOP状态并且没有被中断，那么中断线程 if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { // 任务执行前需要做什么，ThreadPoolExecutor是个空实现，子类可以自行扩展 beforeExecute(wt, task); Throwable thrown = null; try { // 真正的开始执行任务，这里run的时候可能会被中断，比如线程池调用了shutdownNow方法 task.run(); } catch (RuntimeException x) { // 任务执行发生的异常全部抛出，不在runWorker中处理 thrown = x; throw x; } catch (Error x) { thrown = x; throw x; } catch (Throwable x) { thrown = x; throw new Error(x); } finally { // 任务执行结束需要做什么，ThreadPoolExecutor是个空实现，子类可以自行扩展 afterExecute(task, thrown); } } finally { task = null; w.completedTasks++; // 记录执行任务的个数 w.unlock(); // 执行完任务之后，解锁，Worker变成闲置Worker，等待执行下一个任务 } } completedAbruptly = false; // 正常结束 } finally { processWorkerExit(w, completedAbruptly); // Worker退出时执行 } }

  BlockQueue

  

  三个添加元素的方法：

  • add:把e加到队列里,添加成功返回true，容量如果满了添加失败会抛出IllegalStateException异常
  • offer:表示如果可能的话,将e加到队列里，成功返回true,否则返回false
  • put:把e加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续.

  三个删除元素的方法：

  • poll:取走队列头部的对象,若不能立即取出,则可以等待timeout参数规定的时间,取不到时返回null
  • remove:基于对象找到对应的元素并删除，删除成功返回true，否则返回false
  • take:取走队列中排在首位的对象,若队列为空,一直阻塞到队列有元素并删除

  其中：

  队列不接受null 元素。试图add、put 或offer 一个null 元素时，某些实现会抛出NullPointerException。

  null 被用作指示poll 操作失败的警戒值。

  	抛出异常	特殊值	阻塞	超时
  插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
  移除	remove（Object o）	poll()	take()	poll(time, unit)
  检查	element()	peek()	不可用	不可用

  类型	含义
  抛出异常	如果试图的操作无法立即执行，抛一个异常
  特殊值	如果试图的操作无法立即执行，返回一个特定的值(常常是 true / false)
  阻塞	如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行
  超时	如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行， 但等待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是 true / false)

  常见的四个实现：

  ArrayBlockingQueue

  

  一个由数组支持的有界阻塞队列。此队列按 **FIFO（先进先出）**原则对元素进行排序。队列的头部是在队列中存在时间最长的元素。队列的尾部 是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列获取操作则是从队列头部开始获得元素。

  ArrayBlockingQueue的原理就是使用一个可重入锁和这个锁生成的两个条件对象进行并发控制(classic two-condition algorithm)

  ArrayBlockingQueue是一个带有长度的阻塞队列，初始化的时候必须要指定队列长度，且指定长度之后不允许进行修改

  属性

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  // 存储队列元素的数组，是个循环数组 final Object[] items; // 拿数据的索引，用于take，poll，peek，remove方法 int takeIndex; // 放数据的索引，用于put，offer，add方法 int putIndex; // 元素个数 int count; // 可重入锁 final ReentrantLock lock; // notEmpty条件对象，由lock创建 private final Condition notEmpty; // notFull条件对象，由lock创建 private final Condition notFull;

  创建

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

  // 构造函数要求指定队列大小capacity /** * capacity和fair，capacity同第一个构造方法，代表队列大小。fair代表该队列的访问策略是否公平。如果为 * true，则按照 FIFO 顺序访问插入或移除时受阻塞线程的队列；如果为 false，则访问顺序是不确定的。这里fair参 * 数被设置为ReentrantLock的入参，就可以通过ReentrantLock来保证线程访问是否公平。而此构造方法创建了两个 * Condition，也就是条件，分别是notEmpty和notFull，Condition可以调用wait()和signal()来控制当前现 * 成等待或者唤醒 */ // 默认fair为false public ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c) { this(capacity, fair); final ReentrantLock lock = this.lock; lock.lock(); // Lock only for visibility, not mutual exclusion try { int i = 0; try { for (E e : c) { checkNotNull(e); items[i++] = e; } } catch (ArrayIndexOutOfBoundsException ex) { throw new IllegalArgumentException(); } count = i; putIndex = (i == capacity) ? 0 : i; } finally { lock.unlock(); } }

  内部调用的this(capacity, fair)方法

  1 2 3 4 5 6 7 8

  public ArrayBlockingQueue(int capacity, boolean fair) { if (capacity <= 0) throw new IllegalArgumentException(); this.items = new Object[capacity]; lock = new ReentrantLock(fair); notEmpty = lock.newCondition(); notFull = lock.newCondition(); }

  数据的添加

  add

  ArrayBlockingQueue自己并没有实现add方法，而直接调用父类AbstractQueue的add方法

  1 2 3

  public boolean add(E e) { return super.add(e); }

  内部调用的super.add

  1 2 3 4 5 6

  public boolean add(E e) { if (offer(e)) return true; else throw IllegalStateException("Queue full"); }

  实际上最后调用的就是ArrayBlockingQueue自己的offer方法，但是如果offer方法返回结果为false，则抛出IllegalStateException

  offer

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  public boolean offer(E e) { // 不允许元素为空，为空会抛出NullPointerException异常 checkNotNull(e); // 获取锁 final ReentrantLock lock = this.lock; lock.lock(); try { // 元素个数和当前存储队列元素的数组大小相等，就不会再加了，所以会返回false if (count == items.length) return false; else { // 入队操作 enqueue(e); return true; } } finally { // 释放锁 lock.unlock(); } }

  内部调用的enqueue方法

  1 2 3 4 5 6 7 8 9 10 11 12 13

  private void enqueue(E x) { // assert lock.getHoldCount() == 1; // assert items[putIndex] == null; final Object[] items = this.items; items[putIndex] = x; // 放数据索引+1，如果数据索引已经与存储队列的元素数量相同则变为0 if (++putIndex == items.length) putIndex = 0; // 元素个数+1 count++; // 使用条件对象notEmpty通知，比如使用take方法的时，队列中没有数据被阻塞。这个时候队列中新增了一条数据，需要调用signal通知 notEmpty.signal(); }

  put

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  public void put(E e) throws InterruptedException { // 元素为空抛出NPE异常 checkNotNull(e); final ReentrantLock lock = this.lock; // 加锁，保证调用put方法的时候只有一个线程 lock.lockInterruptibly(); try { // 如果队列满了，阻塞当前线程并加入到条件对象notFull的等待队列里 while (count == items.length) // 线程阻塞并被挂起，同时释放锁 notFull.await(); // 入队 enqueue(e); } finally { lock.unlock(); } }

  疑问点，之前的入队操作的写法是

  1 2 3 4 5 6

  private void insert(E x) { items[putIndex] = x; putIndex = inc(putIndex); ++count; notEmpty.signal(); }

  为什么改了？改之前和改之后有什么区别？

  总结

  ArrayBlockingQueue总共有三个添加数据的方法，分别是add、put、offer

  • add方法：内部实际调用的是offer方法，如果队列已满则抛出IllegalStateException一场，否则返回true

  • offer方法：如果队列满了返回false，成功返回true

  • put方法：如果队列满了会阻塞线程，直到有线程消费了队列中的元素

  三个方法内部都使用可重入锁保证原子性

  数据的删除

  poll

  1 2 3 4 5 6 7 8 9 10 11

  public E poll() { // 加锁，保证调用poll方法的时候只有一个线程 final ReentrantLock lock = this.lock; lock.lock(); try { // 如果count=0，也就是队列中没有元素了，这时候会返回null，否则调用dequeue取元素 return (count == 0) ? null : dequeue(); } finally { lock.unlock(); } }

  内部调用的dequeue方法

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  private E dequeue() { // assert lock.getHoldCount() == 1; // assert items[takeIndex] != null; final Object[] items = this.items; @SuppressWarnings("unchecked") // takeIndex是用于拿数据的索引 E x = (E) items[takeIndex]; // 取出数据以后，这个元素位置为null items[takeIndex] = null; // 如果当前拿数据的索引大小已经和元素数组大小相等则置为0，这里的takeIndex之所以自增是因为FIFO原则 if (++takeIndex == items.length) takeIndex = 0; // 一个数据被取出，此时元素个数-1 count--; // TODO if (itrs != null) itrs.elementDequeued(); // 使用对象notFull通知，如使用put方法放置数据的时候队列满了，被阻塞，这个时候dequeue取出一条数据，队列没满，则可以继续放入 notFull.signal(); return x; }

  take

  1 2 3 4 5 6 7 8 9 10 11 12 13

  public E take() throws InterruptedException { final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { // 如果队列为空，阻塞当前线程，并加入到条件对象notEmpty的等待队列里 while (count == 0) // 线程阻塞并被挂起，同时释放锁 notEmpty.await(); return dequeue(); } finally { lock.unlock(); } }

  remove

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

  public boolean remove(Object o) { if (o == null) return false; final Object[] items = this.items; final ReentrantLock lock = this.lock; lock.lock(); try { if (count > 0) { // 放数据索引 final int putIndex = this.putIndex; // 取数据索引 int i = takeIndex; // 通过元素类型遍历,找到类型相同的索引位置，i<=元素总大小 do { if (o.equals(items[i])) { removeAt(i); return true; } if (++i == items.length) i = 0; // 因为putIndex就是最后一个放数据的位置，所以拿数据的索引不能等于它 // 但是有没有想过为什么不可以写<=呢？ } while (i != putIndex); } return false; } finally { lock.unlock(); } }

  内部调用的removeAt方法

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

  void removeAt(final int removeIndex) { // assert lock.getHoldCount() == 1; // assert items[removeIndex] != null; // assert removeIndex >= 0 && removeIndex < items.length; final Object[] items = this.items; // 如果要删除数据的索引位置就是拿数据索引位置，直接将takeIndex索引位置上的数据，然后takeIndex+1 if (removeIndex == takeIndex) { // removing front item; just advance items[takeIndex] = null; if (++takeIndex == items.length) takeIndex = 0; count--; if (itrs != null) itrs.elementDequeued(); } else { // an "interior" remove // slide over all others up through putIndex. // 如果要删除数据的索引位置不是takeIndex，则需要移动元素位置，更新putIndex final int putIndex = this.putIndex; for (int i = removeIndex;;) { int next = i + 1; if (next == items.length) next = 0; if (next != putIndex) { items[i] = items[next]; i = next; } else { items[i] = null; this.putIndex = i; break; } } count--; if (itrs != null) itrs.removedAt(removeIndex); } // 删除以后通知阻塞线程，比如put方法 notFull.signal(); }

  总结

  三个删除方法，分别是poll，take，remove

  • poll方法对于队列为空的情况，返回null，否则返回队列头部元素
  • remove方法取的元素是基于对象的下标值，删除成功返回true，否则返回false
  • poll方法和remove方法不会阻塞线程
  • take方法对于队列为空的情况，会阻塞并挂起当前线程，直到有数据加入到队列中
  • 三个删除方法内部都会调用notFull.signal方法通知正在等待队列满情况下的阻塞线程

  LinkedBlockingQueue

  

  内部以一个链式结构(链接节点)对其元素进行存储，链表是单向链表，满足FIFO(先进先出)原则。

  属性

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

  /** The capacity bound, or Integer.MAX_VALUE if none */ // 容量大小 private final int capacity; /** Current number of elements */ // 元素个数 private final AtomicInteger count = new AtomicInteger(); /** * Head of linked list. * Invariant: head.item == null */ // 头节点 transient Node<E> head; /** * Tail of linked list. * Invariant: last.next == null */ // 尾节点 private transient Node<E> last; /** Lock held by take, poll, etc */ // 读锁 private final ReentrantLock takeLock = new ReentrantLock(); /** Wait queue for waiting takes */ // 读锁的条件对象 private final Condition notEmpty = takeLock.newCondition(); /** Lock held by put, offer, etc */ // 写锁 private final ReentrantLock putLock = new ReentrantLock(); /** Wait queue for waiting puts */ // 写锁的条件对象 private final Condition notFull = putLock.newCondition();

  ArrayBlockingQueue只有1个锁，添加数据和删除数据的时候只有1个可以被执行，不允许并行操作

  但LinkedBlockingQueue有2个锁，读和写各有一把，添加数据和删除数据两个操作可以并行。

  创建

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  public LinkedBlockingQueue(Collection<? extends E> c) { this(Integer.MAX_VALUE); final ReentrantLock putLock = this.putLock; putLock.lock(); // Never contended, but necessary for visibility try { int n = 0; for (E e : c) { if (e == null) throw new NullPointerException(); if (n == capacity) throw new IllegalStateException("Queue full"); enqueue(new Node<E>(e)); ++n; } count.set(n); } finally { putLock.unlock(); } }

  内部调用的this和enqueue方法

  1 2 3 4 5 6

  public LinkedBlockingQueue(int capacity) { if (capacity <= 0) throw new IllegalArgumentException(); this.capacity = capacity; // last和head节点都是null last = head = new Node<E>(null); }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  private void enqueue(Node<E> node) { // assert putLock.isHeldByCurrentThread(); // assert last.next == null; last = last.next = node; } static class Node<E> { E item; /** * One of: * - the real successor Node * - this Node, meaning the successor is head.next * - null, meaning there is no successor (this is the last node) */ Node<E> next; Node(E x) { item = x; } }

  enqueue的class方法

  1 2 3

  private void enqueue(Node<E> paramNode){ this.last = (this.last.next = paramNode); }

  另外还画了一个图

  

  数据的添加

  三个方法，分别是add offer put

  add

  LinkedBlockingQueue和ArrayBlockingQueue一样，同样没有实现add方法，所以会直接调用父类AbstractQueue的add方法

  1 2 3 4 5 6

  public boolean add(E e) { if (offer(e)) return true; else throw new IllegalStateException("Queue full"); }

  实际上也就是调用LinkedBlockingQueue的offer方法，失败则抛出异常

  offer

  关于这里使用到的锁实际上涉及到java的monitor MESA模型，这里就不展开讲了，有兴趣的小伙伴戳极客时间-管程：并发编程的万能钥匙，有二十个小伙伴可以免费读哦～打不开的话复制地址用微信打开哦😊

  可重入锁指的是线程可以重复获取同一把锁，ReentrantLock有一个带布尔值fair的构造函数，true表示公平锁，反之则是非公平锁。指的是条件变量的等待队列唤醒策略，公平锁是唤醒等待时间最长的，非公平锁则不会保证

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

  public boolean offer(E e) { // 不允许空元素 if (e == null) throw new NullPointerException(); final AtomicInteger count = this.count; // 如果满了就返回false，but这个大小可是2^31-1=2147483647 if (count.get() == capacity) return false; int c = -1; Node<E> node = new Node<E>(e); // 拿到写锁 final ReentrantLock putLock = this.putLock; // 对写操作加锁 putLock.lock(); try { if (count.get() < capacity) { enqueue(node); // 元素个数+1 c = count.getAndIncrement(); if (c + 1 < capacity) // 如果容量还没满，在对象notFull唤醒正在等待的线程，表示可以再往队列里加数据了 notFull.signal(); } } finally { putLock.unlock(); } if (c == 0) signalNotEmpty(); // todo return c >= 0; }

  put

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

  public void put(E e) throws InterruptedException { if (e == null) throw new NullPointerException(); // Note: convention in all put/take/etc is to preset local var // holding count negative to indicate failure unless set. int c = -1; Node<E> node = new Node<E>(e); // 拿到写锁 final ReentrantLock putLock = this.putLock; final AtomicInteger count = this.count; // 对写操作加锁 putLock.lockInterruptibly(); try { /* * Note that count is used in wait guard even though it is * not protected by lock. This works because count can * only decrease at this point (all other puts are shut * out by lock), and we (or some other waiting put) are * signalled if it ever changes from capacity. Similarly * for all other uses of count in other wait guards. */ // 如果当前容量已经满了，则阻塞并挂起当前线程 while (count.get() == capacity) { notFull.await(); } // 入队操作 enqueue(node); // 元素+1 c = count.getAndIncrement(); if (c + 1 < capacity) // 如果容量还没满，在放锁的条件对象notFull唤醒正在等待的线程 notFull.signal(); } finally { putLock.unlock(); } if (c == 0) signalNotEmpty(); }

  总结

  add offer put方法与ArrayBlockingQueue特性一致，只是底层实现不同

  • add方法：内部实际调用的是offer方法，如果队列已满则抛出IllegalStateException一场，否则返回true

  • offer方法：如果队列已满则返回false，成功返回true

  • put方法：如果队列满了会阻塞线程，直到有线程消费了队列中的元素

  ArrayBlockingQueue中放入数据阻塞的时候，需要消费数据才能唤醒，而LinkedBlockingQueue中放入数据阻塞的时候，因为它内部有2个锁，可以并行执行放入数据和消费数据，不仅在消费数据的时候进行唤醒插入阻塞的线程，同时在插入的时候如果容量还没满，也会唤醒插入阻塞的线程

  数据的删除

  poll

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  public E poll() { final AtomicInteger count = this.count; if (count.get() == 0) return null; E x = null; int c = -1; final ReentrantLock takeLock = this.takeLock; takeLock.lock(); try { if (count.get() > 0) { x = dequeue(); c = count.getAndDecrement(); if (c > 1) notEmpty.signal(); } } finally { takeLock.unlock(); } if (c == capacity) signalNotFull(); // 成功就会返回实际的元素，否则返回null return x; }

  内部调用的dequeue方法

  1 2 3 4 5 6 7 8 9 10 11

  private E dequeue() { // assert takeLock.isHeldByCurrentThread(); // assert head.item == null; Node<E> h = head; Node<E> first = h.next; h.next = h; // help GC head = first; E x = first.item; first.item = null; return x; }

  不是特别好理解的话，就看图吧

  

  take

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  public E take() throws InterruptedException { E x; int c = -1; final AtomicInteger count = this.count; final ReentrantLock takeLock = this.takeLock; takeLock.lockInterruptibly(); try { while (count.get() == 0) { // 阻塞等待 notEmpty.await(); } x = dequeue(); c = count.getAndDecrement(); if (c > 1) notEmpty.signal(); } finally { takeLock.unlock(); } if (c == capacity) signalNotFull(); return x; }

  remove

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  public boolean remove(Object o) { if (o == null) return false; // remove操作的位置不固定，所以需要对两个锁都进行加锁 fullyLock(); try { for (Node<E> trail = head, p = trail.next; p != null; trail = p, p = p.next) { // 判断是否找到对象 if (o.equals(p.item)) { // 修改节点的链接信息，同时调用notFull的signal方法 unlink(p, trail); return true; } } return false; } finally { fullyUnlock(); } }

  内部调用的fullyLock方法 unlink方法以及fullyUnlock方法

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  void fullyLock() { putLock.lock(); takeLock.lock(); } void unlink(Node<E> p, Node<E> trail) { // assert isFullyLocked(); // p.next is not changed, to allow iterators that are // traversing p to maintain their weak-consistency guarantee. p.item = null; trail.next = p.next; if (last == p) last = trail; // 判断当前元素总数是否等于最大值 if (count.getAndDecrement() == capacity) notFull.signal(); } void fullyUnlock() { takeLock.unlock(); putLock.unlock(); }

  总结

  take poll方法的特性与ArrayBlockingQueue一致，唯一不同的是remove方法中会同时对取 拿两个锁进行加锁

  ArrayBlockingQueue因为内部实现是通过数组实现，所以其在初始化的时候必须要指定大小，且不可变，在删除操作的时候会移动元素。

  LinkedBlockingQueue内部实现是通过单向链表实现，本身没有边界，但默认最大值为2^31-1。可同时操作读和写，在删除操作时需要给读写同时加锁。

  DelayQueue

  Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部 是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队 列没有头部，并且 poll 将返回 null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于等于 0 的值时，将发生到期。即使无法使用 take 或 poll 移除未到期的元素，也不会将这些元素作为正常元素对待

  SynchronousQueue

  SynchronousQueue 是一个特殊的队列，它的内部同时只能够容纳单个元素。如果该队列已有一元素的话，试图向队列中插入一个新元素的线程将会阻塞，直到另一个线程将该元素从队列中抽走。同样，如果该队列为空，试图向队列中抽取一个元素的线程将会阻塞，直到另一个线程向队列中插入了一条新的元素。

  拒绝策略

  主要有四种

  ThreadPoolExecutor.AbortPolicy

  默认的ThreadPoolExecutor.AbortPolicy 处理程序遭到拒绝将抛出运行时RejectedExecutionException

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  public static class AbortPolicy implements RejectedExecutionHandler { /** * Creates an {@code AbortPolicy}. */ public AbortPolicy() { } /** * Always throws RejectedExecutionException. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task * @throws RejectedExecutionException always */ public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString()); } }

  ThreadPoolExecutor.CallerRunsPolicy

  线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  public static class CallerRunsPolicy implements RejectedExecutionHandler { /** * Creates a {@code CallerRunsPolicy}. */ public CallerRunsPolicy() { } /** * Executes task r in the caller's thread, unless the executor * has been shut down, in which case the task is discarded. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task */ public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { r.run(); } } }

  ThreadPoolExecutor.DiscardPolicy

  不能执行的任务将被删除

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  public static class DiscardPolicy implements RejectedExecutionHandler { /** * Creates a {@code DiscardPolicy}. */ public DiscardPolicy() { } /** * Does nothing, which has the effect of discarding task r. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task */ public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { } }

  ThreadPoolExecutor.DiscardOldestPolicy

  如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  public static class DiscardOldestPolicy implements RejectedExecutionHandler { /** * Creates a {@code DiscardOldestPolicy} for the given executor. */ public DiscardOldestPolicy() { } /** * Obtains and ignores the next task that the executor * would otherwise execute, if one is immediately available, * and then retries execution of task r, unless the executor * is shut down, in which case task r is instead discarded. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task */ public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) { e.getQueue().poll(); e.execute(r); } } }

  参考资料

  极客时间-Java并发编程实战

  《Java高并发编程详解：多线程与架构设计 (Java核心技术系列) 》

  Java阻塞队列ArrayBlockingQueue和LinkedBlockingQueue实现原理分析

  LinkedBlockingQueue源码解析

  ]]> https://baofeidyz.com/2019/4ddc630f7b39/ 使用dnsproxy自建DNS服务 baofeidyz's blog 技术 折腾 Fri, 19 Jul 2019 01:00:00 GMT 使用dnsproxy自建DNS服务

  为什么我想要自建DNS服务？

  因为我们公司内网有基于Windows的DNS服务。主要因为部分域名是仅限内网解析的，所以我不得不使用公司内网提供的DNS。如果这个DNS服务好用也就没啥了，但问题在于，他总是能解析出一些无法访问的IP，上网体验糟糕。

  我有尝试修改我本地的DNS，或者是尝试将内网的域名写入hosts文件中，最终都无法满足我的需求。

  经人安利，我找到了这个开源项目：https://github.com/AdguardTeam/dnsproxy

  如何使用dnsproxy？

  其实我觉得我有点废话了，大家可以直接看GitHub的上readme

  这个项目，本质上就是将我访问的域名去访问多个DNS服务，并将最快的IP返回作为解析的返回结果。要想把这个服务跑起来十分容易。

  这个是项目的发布地址，有各个平台已经编译好的版本：https://github.com/AdguardTeam/dnsproxy/releases

  紧接着，打开所在目录，找可执行的文件即可。

  1	dnsproxy -u x.x.x.x -u y.y.y.y -u z.z.z.z -u 114.114.114.114 -u 1.1.1.1 -u 8.8.8.8

  需要提醒的是 x.x.x.x、y.y.y.y、z.z.z.z这三个DNS服务是我给我们公司内网DNS服务打的马赛克，请不要直接复用哦。

  如果需要在后台运行，可以使用nohup

  ]]>