m0nkrus

m0nkrus 是俄语软件分享社区的软件修改、打包发布者，发布的内容包括 Photoshop、Premiere Pro、After Effects 等 Adobe 软件，也有 Autodesk 软件。他的这款 Photoshop 安装包已经整合了破解处理，按作者的说明，安装后即可使用。

官网：https://monkrus.ws/，目前会跳转到 https://w18.monkrus.ws/。也可以在他的 Telegram 频道查看更新。

官网首页，2026 年 10 月 8 日截图。

Photoshop 2026

2026 年 10 月 8 日查看时，最新版本是 Photoshop 2026 v27.11，具体版本号为 27.11.0.26。这是 Windows 64 位的多语言版，包含简体中文和繁体中文。

m0nkrus 在评论区回复确认，目前还没有提供 ARM 版本。

Photoshop 2026 v27.11 发布页

Photoshop 发布页，2026 年 10 月 8 日截图。

页面下面有多个下载入口，我试过 PB.WTF，不需要注册就能下载种子文件，用 qBittorrent 打开即可。

PB.WTF 下载页面

另外，发布帖里提到，生成式 AI 功能仍需要付费订阅，别以为装好后所有功能都能用。

毕竟是第三方修改版，安全性自行判断。

效率软件

在用(好用)的软件

Anki

主要用来背单词

AutoHotKey

修改系统快捷键，或者绑定某些快捷键完成自动化操作

CapsLockPlus

我开源的一个 AutoHotKey 脚本，对键盘的 CapsLock 键增强，极大的提升了键盘效率。

Bandizip

用起来最顺手的压缩软件

Everything

全局文件搜索工具, 内存占用小, 搜索速度快。
在功能上与 Listary 有重合

• 一般搜索文件我会使用 Listary 直接在资源管理器中输入就能找到目标文件.
• 当要对某种命名规则(前缀/后缀等)的文件做批量处理时, 会用 Everything, 搜索到目标文件, 批量选中操作

nomacs

看图软件，启动速度快，支持常见图片格式，适合快速翻看文件夹里的图片
比系统自带图片查看器更轻量，配合方向键连续浏览很顺手

FireFox

常用浏览器

Listary

使用频率最高的软件
全局文件搜索工具, 内存小速度快, 支持中文搜索, 异次元 的 这篇文章 介绍的很详细
我最常用的方式是把启动快捷键改为 Ctrl + Space，使用快捷键调起输入框，直接输入文件名，即可打开文件或者定位到文件夹

Geek Uninstaller

软件卸载工具，软件卸载后自动检测垃圾文件及注册表，然后一键清除

NotePad++

NotePad++ 是一个开源的轻量级文本编辑器, 启动速度快, 内存占用小, 文本编辑功能强大, 支持代码高亮, 适合轻量的文本编辑场景.

Logseq

本地优先的双向链接笔记软件，适合用大纲的方式整理笔记

Obsidian

双向链接笔记软件

OpenHashTab

文件哈希校验工具，安装后会集成到文件属性页里
需要校验 MD5、SHA-1、SHA-256 等哈希值时，不用单独打开软件，右键文件查看属性即可

OneNote

微软出品的笔记软件
已经不使用，笔记主要迁移到 Obsidian

1Remote

远程连接管理工具，支持 RDP、SSH 等协议

Alt-Tab Terminator

替换系统自带的 Alt-Tab 窗口切换，窗口列表更直观

WindowsVirtualDesktopHelper

虚拟桌面增强工具，可以给不同虚拟桌面设置独立壁纸
对于经常用多个桌面区分工作场景的情况会更顺手，也更容易一眼分辨当前所在桌面

Aquile Reader

电子书阅读器，界面干净，适合在 Windows 上看 EPUB

PotPlayer

全能视频播放器, 启动速度快, 内存占用小, 配置项丰富, 功能齐全, 免费无广告

QuickLook

文件管理器增强工具，按空格即可预览文件

PixPin

最常用的截图软件，支持截图、贴图、长截图、OCR、标注等功能
操作顺手，功能也更完整，日常截图和临时贴图都够用

Sumatra PDF

一款轻量级的 PDF 阅读器。除了支持 PDF 阅读，还支持 EPUB、MOBI 格式的电子书，以及 XPS、DjVu、CHM 等多种格式。
内存占用小, 启动速度极快。Sumatra PDF 开发者表示「会优先让用户界面更干净」，足以说明它的开发方向。
适合不需要太多复杂的功能，只想看 PDF 文档或电子书的场景

Syncthing

开源文件同步工具，适合多台设备之间同步文件

tailscale

基于 WireGuard 的组网工具，配置简单，适合远程访问自己的设备

火绒

系统安全工具

V2rayN

网络代理软件

TrafficMonitor

Traffic Monitor 是一款用于 Windows 平台的网速监控悬浮窗软件，可以显示当前网速、CPU及内存利用率，支持嵌入到任务栏显示，支持更换皮肤、历史流量统计等功能。

chrome

浏览器

下面是一些好用的 Chrome 插件

Adblock Plus - 免费的广告拦截器

免费网页广告拦截

AutoPagerize

自动加载分页网页, 无需点击”下一页”

Awesome Screenshot 截图与录屏

截图和录屏2合1的工具，支持截取整个页面，快速分享屏幕。

Enhancer for YouTube

海量自定义功能提升您的 YouTube™ 用户体验。

Gitako - GitHub file tree

树形展示 Github 项目结构
替代[[Octotree]] - GitHub code tree

NoScript

Maximum protection for your browser: NoScript allows active content only for trusted domains of your choice to prevent exploitation.

OneNote Web Clipper

支持将网页内容剪切到 OneNote 中

OneTab

一键将网页保存到后台列表, 等需要再打开, 节约内存

Screenity - 屏幕录像和标注工具

屏幕录像工具

Selenium IDE

Selenium Record and Playback tool for ease of getting acquainted with Selenium WebDriver.

Vimium

Chrome 的键盘增强插件, 仅通过键盘即可完成网页滚动/页面打开关闭/标签页切换等等操作

彩云小译

彩云小译双语对照网页翻译插件，针对谷歌浏览器开发的一款网页翻译工具，一键高效获取母语阅读体验。
网页整页对比翻译, 避免谷歌翻译那种只能看到译文不能看到原文的尴尬

沙拉查词

浏览器查词插件, 支持丰富的词典, 划词翻译等功能

简悦

将文字类网页内容生成适合阅读的排版, 支持阅读样式的自定义, 支持对内容导出为各种文件格式, 及导出到各类笔记软件

User-Agent Switcher for Chrome

修改访问网页时的User-Agent值, 可以伪装为其他浏览器

Tampermonkey

Tampermonkey 是一款免费的浏览器扩展和最为流行的用户脚本管理器，它适用于 Chrome, Microsoft Edge, Safari, Opera Next, 和 Firefox。 可以对特定网页执行特定脚本, 以满足屏蔽广告, 转换网页样式, 网页增强等功能

• 知乎网页助手 1、知乎站外链接直接跳转至目标网址；2、自动展开问题全部信息，同时展示所有回答；3、去除知乎网页中的广告；4、知乎网页中短视频下载；5、解除知乎复制限制-划词复制（鼠标左键划词自动添加到剪切板）；6、去除烦人的登录提示；7、自动高清图片显示【注：支持Tampermonke4.0以上版本】【这可能是功能最全面的知乎助手了】
• 护眼脚本 修改网页背景色，让网页背景色偏白的部分变成乡土黄、豆沙绿，浅色灰还有淡橄榄，更加护眼。默认护眼色是乡土黄。
• 去繁留简-繁简转换 将页面繁体字转换成简体字显示
• 博客阅读美化（去广告|自动全文|简洁） 优化特定博客网站的阅读体验: 修改页面布局, 屏蔽广告
• Bilibili Evolved 哔哩哔哩增强脚本: 下载视频, 音乐, 封面, 弹幕 / 简化直播间, 评论区, 首页 / 自定义顶栏, 删除广告, 夜间模式 / 触屏设备支持
• AC-baidu:重定向优化百度搜狗谷歌必应搜索_favicon_双列 绕过百度、搜狗、谷歌、好搜搜索結果中的自己的跳转连接，直接访问原始网页

开发向软件

Git

版本管理工具

Windows Terminal

Windows Terminal 是微软开源的终端软件，美观且实用

WSL2

WSL（Windows Subsystem for Linux）是可以运行在 Windows 上的 Linux 环境，省去了虚拟机的开销

uv

Python 包管理工具，速度很快，可以替代 pip、venv、pip-tools 等工具
现在更倾向用 uv 管理 Python 项目环境，命令简单，依赖安装和虚拟环境创建都很快

JetBrains Toolbox

IDEA

Java 最强 IDE

下面是一些常用的插件

.ignore

.ignore 文件插件

CamelCase

在kebab-case，SNAKE_CASE，PascalCase，camelCase，snake_case或空格之间轻松切换。快捷键 ⇧+⌥+ U 或 Shift + Alt +U。允许禁用某些转换或在首选项中更改其顺序。

CodeGlance

以整个文档的微型图替代侧边滚动条

GitToolBox

使用其他功能扩展Git集成状态显示，自动获取，内联责备注释，提交对话框完成，通知后等…

Lombok

Markdown Image Kit

Markdown Image Kit 是一款在 IDEA 中方便高效得管理 Markdown 文档图片的插件.

Mybatis Log

将提取的SQL语句的动作日志记录切换到可执行的SQL语句。
默认快捷键ctrl + shift + H

MyBatisCodeHelperPro

收费但功能强大的 MyBatis 插件

RestfulToolKit

一套 RESTful 服务开发辅助工具集。

1. 根据 URL 直接跳转到对应的方法定义 ( Ctrl \ or Ctrl Alt N );
2. 提供了一个 Services tree 的显示窗口;
3. 一个简单的 http 请求工具;
4. 在请求方法上添加了有用功能: 复制生成 URL;,复制方法参数…
5. 其他功能: java 类上添加 Convert to JSON 功能，格式化 json 数据 ( Windows: Ctrl + Enter; Mac: Command + Enter )。

   Translation

   翻译插件，快捷键Ctrl + Shift + Y

generateAllSetter

快捷生成对象的所有 setter 方法，方便编写测试代码

Navicat

数据库图形管理工具
更多使用JetBrians 的 DataGrip

Visual Studio Code

轻量级代码编辑工具

Xshell

ssh 工具

MobaXTerm

免费 ssh 工具

记录一下在国内环境下成功订阅 Google AI Pro 年度会员的完整流程。

遇到的问题

最初尝试使用美区 Google 账户直接在网页端购买，但在添加支付方式时遇到了问题：添加国内招商银行 Visa 卡失败。

后偶然发现可以通过 App Store 进行支付，从而绕过直接绑定信用卡的限制。

解决方案

通过 Apple 生态系统完成订阅，具体流程如下：

1. 准备美区 Apple 账号余额

由于需要在美区 App Store 进行支付，首先需要为美区 Apple 账号充值。

访问 Apple 官网购买 Apple ID 礼品卡（Gift Card），购买了 $100 的礼品卡，账单信息填写免税州。

购买成功后，使用礼品卡兑换码在美区 Apple 账号中充值。

参考教程：如何购买和使用美区 Apple ID 礼品卡

2. 下载 Google One APP

使用美区 Apple 账号登录 App Store，搜索并下载 Google One 应用。

注意：不是 Gemini APP，而是 Google One APP，Google AI Pro 订阅服务包含在 Google One 会员体系中。

3. 订阅 Google AI Pro

1. 打开 Google One APP，登录 Google 账号
2. 在 APP 中找到 Google AI Pro 订阅选项
3. 选择年度订阅计划，此时可以看到折扣价格：$99.99/year
4. 点击订阅，支付方式会默认使用 App Store 付款（之前充值的 Apple 账号余额）
5. 确认支付，完成订阅

4. 验证订阅状态

订阅成功后，重新打开 Gemini 网页版或 APP，看到账户已经升级为 Pro 账户，正常 Gemini 3、Nano Banana Pro 等。

注意事项

1. 地区限制：Google AI Pro 服务需要在支持的地区使用，建议配合网络工具使用
2. Apple 账号：需要提前准备好美区 Apple 账号，如果没有可以自行注册
3. 汇率与税费：实际支付金额可能因汇率和税费略有差异，建议礼品卡充值时多准备一些余额
4. 订阅管理：订阅后可以在 App Store 的订阅管理中查看和管理 Google AI Pro 订阅
5. 续费提醒：年度订阅到期后会自动续费，如需取消请提前在 App Store 中关闭自动续费

本文将介绍如何在 Proxmox VE 9.1.1 版本中屏蔽这个登录后的订阅提示弹窗。

操作步骤

1. 备份原始文件

在进行任何修改之前，强烈建议先备份原始的 JavaScript 文件，以便在出现问题时能够快速恢复：

cp /usr/share/pve-manager/js/pvemanagerlib.js \
   /usr/share/pve-manager/js/pvemanagerlib.js.bak

这条命令会在同目录下创建一个 .bak 后缀的备份文件。

2. 修改订阅检查代码

使用 sed 命令直接修改 JavaScript 文件中的订阅检查逻辑：

sed -i \
's/Proxmox.Utils.checked_command(Ext.emptyFn);/Ext.emptyFn();\/\* subscription check disabled \*\//g' \
/usr/share/pve-manager/js/pvemanagerlib.js

这条命令的作用是将订阅检查函数替换为一个空函数，从而跳过弹窗提示。修改后的代码会添加注释 /* subscription check disabled */ 以便识别。

3. 重启 Web 服务

修改完成后，需要重启 PVE 的 Web 代理服务使更改生效：

systemctl restart pveproxy

等待服务重启完成后，清除浏览器缓存（或使用 Ctrl+F5 强制刷新），重新登录 Proxmox VE 管理界面，订阅提示窗口将不再出现。

注意事项

1. 系统更新影响：当 Proxmox VE 进行系统更新时，pve-manager 包可能会被更新，导致修改被覆盖。此时需要重新执行上述步骤。

2. 版本兼容性：本方法适用于 Proxmox VE 9.1.1 版本，其他版本的文件路径或代码结构可能有所不同，请根据实际情况调整。

3. 官方订阅支持：如果你在生产环境中使用 Proxmox VE，建议购买官方订阅以获得企业级支持和稳定的更新源。

4. 恢复方法：如果修改后出现异常，可以使用以下命令恢复原始文件：

   cp /usr/share/pve-manager/js/pvemanagerlib.js.bak \
      /usr/share/pve-manager/js/pvemanagerlib.js
   systemctl restart pveproxy
   

看到有推荐 kiss-translator 于是尝试使用。

由于默认的 Gemini 配置与 Gemini AI Studio 不兼容，于是摸索在自定义接口中配置。

在【接口设置】中，点开一个Custom，接口名称填一个易于分别的名字。

URL填写：https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-lite:generateContent

如果是自搭建的 GeminiBalance，填写 http://ip:port/v1beta/models/gemini-2.5-flash-lite:generateContent

模型这里选择的是 gemini-2.5-flash-lite，翻译效果足够，速度快，不容易触发请求限制。

Key填写自己的 API Key

重点是 Request Hook 和 Response Hook

Request Hook：

(text, from, to, url, key) => [
  url,
  {
    headers: {
      "Content-type": "application/json",
      "x-goog-api-key": key,
    },
    method: "POST",
    body: JSON.stringify({
      contents: [
        {
          parts: [
            {
              text: `Translate the following source text from ${from} to ${to}.
              Output translation directly without any additional text.
              Source Text: ${text}`,
            }
          ]
        }
      ]
    })
  }
];

Response Hook:

(res, text, from, to) => [res['candidates'][0]['content']['parts'][0]['text'], to === res.src]

点击【点击测试】按钮，提示测试成功表示配置正确

核心原理

• [[Spring核心接口]]
  • BeanDefinition
  • 抽象 BeanDefinition
  • BeanFactory
  • ApplicationContext
  • BeanPostProcessor
  • FactoryBean
• Spring启动
  • Spring扫描
  • Spring初始化所有非懒加载单例Bean
    • 合并 BeanDefinition
    • BeanFactory.getBean()
• Bean生命周期
• Spring推断构造方法
• 依赖注入
• 解决循环依赖
• Spring AOP
  • AOP
  • 代理模式
  • JDK动态代理
  • CGLIB动态代理
  • ProxyFactory
  • TargetSource
• Spring事务

实战相关

• @Qualifier使用
• Spring动态获取Bean

例如

public interface Azh3ngService {
    void foo();
}
public class AaAzh3ngServiceImpl implements Azh3ngService {
    @Override
    public void foo() {
        System.out.println("aa");
    }
}
public class BbAzh3ngServiceImpl implements Azh3ngService {
    @Override
    public void foo() {
        System.out.println("bb");
    }
}

在实际业务中，往往根据某些参数区分调用实现。
在 Spring 中可以使用以下几种方式完成。

if/else方式

假设需要根据参数code区分，调用Aa/BbAzh3ngServiceImpl的具体实现 简单做法是

1. 直接注入两种不同的实现的 Bean
2. 使用if{}else{}区分调用具体 Bean

   @Component
   public class Azh3ngController {
       
    @Resource private Azh3ngService aaAzh3ngServiceImpl;
    @Resource private Azh3ngService bbAzh3ngServiceImpl;
       
    public void test(String code) {
        if ("a".equals(code)) {
            return aaAzh3ngServiceImpl.foo();
        } else if ("b".equals(code)) {
            return bbAzh3ngServiceImpl.foo();
        } else {
            throw new RuntimeException("System Exception");
        }
    }
   }
   

   这种方式简单粗暴，但是缺点也非常明显，假如新增了一个实现类，所有用这种方式使用 Azh3ngService 的代码都需要修改。

使用Map接收Spring的自动注入

Spring 在自动注入时，会判断注入的对象是否为 Collection 或 Map，如果是，会继续判断其指定的泛型类型，进而找出所有匹配类型的 Bean 注入 Collection 或 Map 中。

@Component
public class Azh3ngController {

    @Resource
    private Map<String, Azh3ngService> azh3ngServiceMap;

    public void test(String code) {
        Azh3ngService azh3ngService = azh3ngServiceMap.get(code + "Azh3ngServiceImpl");
        if (azh3ngService == null) {
            // throw Exception or return
            return;
        }
        azh3ngService.foo();
    }
}

当新增了一个实现类，无需再到所有使用的地方进行注入和添加 if/else，但缺点是：当参数异常导致无法获取到准确的 Bean 时，无法统一控制后续的逻辑。

ApplicationContext动态获取Bean

Spring提供了ApplicationContext可以实现动态获取 Bean，无需到所有使用的地方进行注入和添加 if/else，也可以统一处理参数异常导致的 Bean 获取失败的情况

import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class ServiceFactory implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    /**
     * 实现 ApplicationContextAware 接口的回调方法，设置上下文环境
     *
     * @param applicationContext applicationContext
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        ServiceFactory.applicationContext = applicationContext;
    }

    public static <T> T getBean(Class<T> clazz, String code) {
        if (clazz == null) {
            return null;
        }
        String targetServiceName = code + clazz.getSimpleName() + "Impl";
        Map<String, T> beansOfType = applicationContext.getBeansOfType(clazz);
        T t = beansOfType.get(targetServiceName);
        if (t == null) {
            throw new NullPointerException("System Exception");
            // 或者返回默认实现
            // return beansOfType.get("default" + clazz.getSimpleName() + "Impl");
        }
        return t;
    }
}

@Component
public class Azh3ngController {
    
    public void test(String code) {
        Azh3ngService azh3ngService = ServiceFactory.getBean(Azh3ngService.class, code);
        azh3ngService.foo();
    }
}

使用代理对象区分并执行具体实现

当参数存储在 ThreadLocal 或者某种缓存中，可以使用代理对象对参数进行判断并获取具体实现类，并执行相应的逻辑 假设参数存储在 Session 中：

@Configuration
public class Azh3ngConfig {
    @Bean
    public ProxyFactoryBean azh3ngServiceProxy(BeanFactory beanFactory) {
        ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
        proxyFactoryBean.setTargetSource(new TargetSource() {
            @Override
            public Class<?> getTargetClass() {
                return Azh3ngService.class;
            }

            @Override
            public boolean isStatic() {
                return false;
            }

            @Override
            public Object getTarget() throws Exception {
                HttpServletRequest httpServletRequest = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
                Object code = httpServletRequest.getSession().getAttribute("code");
                code == null ? "default" : (String) code;
                Azh3ngService azh3ngService = (Azh3ngService) beanFactory.getBean(code + getTargetClass().getSimpleName() + "Impl");
                return azh3ngService;
            }

            @Override
            public void releaseTarget(Object target) throws Exception {
            }
        });
        proxyFactoryBean.addInterface(Azh3ngService.class);
        return proxyFactoryBean;
    }
}

@Component
public class Azh3ngController {
    
    @Resource private Azh3ngService azh3ngServiceProxy;
    
    public void test() {
        azh3ngServiceProxy.foo();
    }
}

@Component 
public class FooService implements BaseService {
}
@Component 
public class BarService implements BaseService {
}
@Component
public class SomeBean {
    @Autowired
    private BaseService barService; // 根据变量名称会找到 BarService
}

但是当 Spring 无法通过变量名确定一个 Bean 时，将会抛出 NoUniqueBeanDefinitionException 异常，如下：

@Component
public class SomeBean {
    @Autowired
    private BaseService service; // Spring 启动抛出异常 NoUniqueBeanDefinitionException
}

通过 @Qualifier 注解的使用，可以解决此问题

基础使用

@Component 
@Qualifier("foo")
public class FooService implements BaseService {
}
@Component 
@Qualifier("bar")
public class BarService implements BaseService {
}

@Component
public class SomeBean {
    @Autowired
    @Qualifier("bar")
    private BaseService service; // 根据 @Qualifier("bar") 会找到 BarService
}

进阶使用

1. 定义两个注解：

@Target({ElementType.TYPE, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier("foo")
public @interface Foo {
}

@Target({ElementType.TYPE, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier("bar")
public @interface Bar {
}

1. 定义一个接口和两个实现类，表示负载均衡：

@Component 
@Foo
public class FooService implements BaseService {
}
@Component 
@Bar
public class BarService implements BaseService {
}

1. 使用：

@Component
public class SomeBean {
    @Autowired
    @Bar
    private BaseService service; // 通过注解 @Bar 找到 BarService
}

参考

https://www.baeldung.com/spring-qualifier-annotation

1. 编程式事务管理：编程式事务管理使用 TransactionTemplate 可实现细粒度的事务控制
2. 声明式事务管理：基于 Spring AOP 实现。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务

开发中更常使用声明式事务，因为不会入侵代码，通过 @Transactional 注解即可以完成事务管理
声明式事务基于 Spring AOP 实现：向 Spring 中添加 BeanPostProcessor 扫描被 @Transactional 注解的类，生成代理对象，通过代理对象完成事务管理

使用示例

编程式事务使用示例

使用 TransactionTemplate 进行编程式事务管理的示例代码：

@Autowired
private TransactionTemplate transactionTemplate;
public void testTransaction() {
    transactionTemplate.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
            try {
                // ....  业务代码
            } catch (Exception e){
                //回滚
                transactionStatus.setRollbackOnly();
            }
        }
    });
}

使用 TransactionManager 进行编程式事务管理的示例代码：

@Autowired
private PlatformTransactionManager transactionManager;

public void testTransaction() {

  TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
          try {
               // ....  业务代码
              transactionManager.commit(status);
          } catch (Exception e) {
              transactionManager.rollback(status);
          }
}

声明式事务使用示例

@Transactional 注解标注在类上，则相当于类中每个方法都添加了此注解；当方法上标注了 @Transactional 注解，则方法的事务属性会覆盖类中的事务属性

@Transactional
public class TestTransactional {
    public void testTransactional1() {}
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void testTransactional2() {}
}

核心接口/类

TransactionAttributeSource

TransactionAttributeSource 接口用于判断类是否被事务管理，常见实现类为 AnnotationTransactionAttributeSource，解析 @Transactional 注解得到相应的事务属性。

TransactionManager

TransactionManager 是 Spring 事务事务管理的主要接口，常见子类包括 PlatformTransactionManager 和 ReactiveTransactionManager。
PlatformTransactionManager 的常见实现类为 DataSourceTransactionManager，提供了获取 DataSource、获取事务、开启、挂起、恢复、提交、回滚等各类事务操作的具体实现。

TransactionSynchronizationManager

TransactionSynchronizationManager 是一个事务管理的核心类，通过 TransactionSynchronizationManager 可以管理当前线程的事务，可以获取当前事务的信息，包括事务名，事务传播机制等。
还可以在事务结束或者开始之前实现自定义逻辑（TransactionSynchronization）
代码示例：

// Return the name of the current transaction, or {@code null} if none set.
TransactionSynchronizationManager.getCurrentTransactionName();
// Return the isolation level for the current transaction, if any.
TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();

TransactionSynchronization

TransactionSynchronization 可以监听当前 Spring 事务所处于的状态，在事务提交，回滚、挂起、恢复时执行自定义逻辑
代码示例：

@Component
public class UserService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private UserService userService;

    @Transactional
    public void test() {
        TransactionSynchronizationManager.registerSynchronization(
                new TransactionSynchronization() {
                    @Override
                    public void suspend() {
                        System.out.println("test被挂起了");
                    }

                    @Override
                    public void resume() {
                        System.out.println("test被恢复了");
                    }

                    @Override
                    public void beforeCommit(boolean readOnly) {
                        System.out.println("test准备要提交了");
                    }

                    @Override
                    public void beforeCompletion() {
                        System.out.println("test准备要提交或回滚了");
                    }

                    @Override
                    public void afterCommit() {
                        System.out.println("test提交成功了");
                    }

                    @Override
                    public void afterCompletion(int status) {
                        System.out.println("test提交或回滚成功了");
                    }
                });
        jdbcTemplate.execute("insert into t1 values(1,1,1,1,'1')");
        System.out.println("test");
        userService.a();
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void a() {
        TransactionSynchronizationManager.registerSynchronization(
                new TransactionSynchronization() {
                    @Override
                    public void suspend() {
                        System.out.println("a被挂起了");
                    }

                    @Override
                    public void resume() {
                        System.out.println("a被恢复了");
                    }

                    @Override
                    public void beforeCommit(boolean readOnly) {
                        System.out.println("a准备要提交了");
                    }

                    @Override
                    public void beforeCompletion() {
                        System.out.println("a准备要提交或回滚了");
                    }

                    @Override
                    public void afterCommit() {
                        System.out.println("a提交成功了");
                    }

                    @Override
                    public void afterCompletion(int status) {
                        System.out.println("a提交或回滚成功了");
                    }
                });
        jdbcTemplate.execute("insert into t1 values(2,2,2,2,'2')");
        System.out.println("a");
    }
}

事务传播机制

在 Spring 中对于事务的传播行为定义了七种类型分别是：REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、NEVER、NESTED
Spring 源码中这七种类型的枚举定义在 org.springframework.transaction.annotation.Propagation

REQUIRED

Propagation.REQUIRED 是 Spring 默认的事务传播机制；如果当前存在事务，则加入当前事务，如果不存在则创建新事务。
注意：当事务方法 1 Propagation.REQUIRED 调用事务方法 2 Propagation.REQUIRED 时，如果事务方法 2 抛出异常，在事务方法 1 中捕获异常后不向外抛出，但整个事务依旧会回滚。
因为在事务方法 2 回滚时，会判断 globalRollbackOnParticipationFailure = true(默认)，则会在数据库连接上设置回滚标记，当事务方法 1 执行完成后，执行提交事务 时，会判断回滚标记，如果为 ture，则执行回滚事务

REQUIRES_NEW

不论当前是否存在事务，总是会新建一个事务，如果存在当前事务，则挂起当前事务
创建的新事务独立存在，独立提交和回滚不会影响其他事务

NESTED

如果当前事务存在，则在开启一个嵌套事务，在嵌套事务中执行，否则开启一个事务
注意：REQUIRES_NEW 是新建一个事务并且新开启的这个事务与原有事务无关，而 NESTED 则是当前存在事务时（暂且把当前事务称之为父事务）会开启一个嵌套事务（称之为一个子事务）。
在 NESTED 情况下父事务回滚时，子事务也会回滚，而在 REQUIRES_NEW 情况下，原有事务回滚，不会影响新开启的事务。
同时 NESTED 提供 savepoint 机制，当数据库支持 savepoint 则可以实现内嵌的事务失败时，仅回滚到 savepoint，而不是回滚整个事务

SUPPORTS

如果当前存在事务，则加入事务；如果当前不存在事务，则以非事务方式运行，这个和不写效果一样

MANDATORY

当前存在事务，则加入当前事务，如果当前事务不存在，则抛出异常。

NOT_SUPPORTED

始终以非事务方式执行，如果当前存在事务，则挂起当前事务

NEVER

不使用事务，如果当前事务存在，则抛出异常

Spring 整合事务

在 Spring 中使用声明式事务，往往是添加 @EnableTransactionManagement 注解启用 Spring 事务。
@EnableTransactionManagement 注解向 Spring 中添加了两个 Bean：

1. AutoProxyRegistrar
2. ProxyTransactionManagementConfiguration

AutoProxyRegistrar

org.springframework.context.annotation.AutoProxyRegistrar
AutoProxyRegistrar 向 Spring 容器中注册了 InfrastructureAdvisorAutoProxyCreator 类型的 Bean。
InfrastructureAdvisorAutoProxyCreator 继承 Spring AOP#AbstractAdvisorAutoProxyCreator，也即它是个 BeanPostProcessor，并且相当于开启了 Spring AOP。

ProxyTransactionManagementConfiguration

org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration
ProxyTransactionManagementConfiguration 是一个配置类，内部定义了三个 Bean：

1. BeanFactoryTransactionAttributeSourceAdvisor ：一个 Spring AOP#Advisor
2. AnnotationTransactionAttributeSource ：相当于 BeanFactoryTransactionAttributeSourceAdvisor 中的 Spring AOP#Pointcut
3. TransactionInterceptor ：相当于 BeanFactoryTransactionAttributeSourceAdvisor 中的 Spring AOP#Advice

AnnotationTransactionAttributeSource

AnnotationTransactionAttributeSource 可以判断类或者方法上是否存在 @Transactional 注解

TransactionInterceptor

TransactionInterceptor 是 Spring 定义的事务方法拦截器，也就是事务的代理逻辑
当某个类中存在 @Transactional 注解时，会产生创建代理对象作为 Bean，代理对象在执行某个方法时，会进入到 TransactionInterceptor.invoke() 方法

Spring 事务详细执行流程

• org.springframework.transaction.interceptor.TransactionInterceptor#invoke
  • （事务执行详细）org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction
    • （获取 TransactionManager）org.springframework.transaction.interceptor.TransactionAspectSupport#determineTransactionManager
    • （开启事务）org.springframework.transaction.interceptor.TransactionAspectSupport#createTransactionIfNecessary
    • 执行目标对象的方法
    • （回滚事务）org.springframework.transaction.interceptor.TransactionAspectSupport#completeTransactionAfterThrowing
    • （清除事务信息）org.springframework.transaction.interceptor.TransactionAspectSupport#cleanupTransactionInfo
    • （提交事务）org.springframework.transaction.interceptor.TransactionAspectSupport#commitTransactionAfterReturning

开启事务

• TransactionAspectSupport.createTransactionIfNecessary()
  • AbstractPlatformTransactionManager.getTransaction()
    • AbstractPlatformTransactionManager.startTransaction()
  • TransactionAspectSupport.prepareTransactionInfo()

简述：

• 判断当前是否存在事务
  • 是则根据事务传播机制做出相应处理；
  • 否则继续判断事务传播机制，或抛出异常，或挂起并新建事务
• 将挂起的事务缓存到新建的事务中

详述：

1. 调用 TransactionManager.getTransaction()
   1. 尝试获取当前线程的事务（DataSourceTransactionManager.doGetTransaction()）
   2. 判断当前线程是否存在事务(DataSourceTransactionManager.isExistingTransaction())
      1. 如果有，判断当前事务的传播机制（AbstractPlatformTransactionManager.handleExistingTransaction()）做出相应处理，并返回结果
      2. 否则继续执行
   3. 判断事务传播机制
      1. 如果是 MANDATORY，抛出异常
      2. 如果是 REQUIRED 或 REQUIRES_NEW 或 NESTED
         1. 挂起空事务
         2. 开启事务（ TransactionManager.startTransaction()）
            1. 缓存事务的状态信息（当前事务信息、挂起的事务信息等)
            2. 创建数据库连接（DataSourceTransactionManager.doBegin()））
               1. 如果当前线程中所使用的 DataSource 还没有创建过数据库连接，则新建数据库连接
               2. 设置事务隔离级别
               3. 设置 readOnly 属性
               4. 设置 AutoCommit 为 false
               5. 设置数据库连接的过期时间
               6. 把新建的数据库连接缓存到 TreadLocal （TransactionSynchronizationManager）中
            3. 将新建的数据库连接信息（当前事务名、readOnly、隔离级别、wasActive）缓存到 TreadLocal（TransactionSynchronizationManager）中（AbstractPlatformTransactionManager.prepareSynchronization()）
2. 构建 TransactionInfo 并返回（TransactionAspectSupport.prepareTransactionInfo()）
   1. 新建 TransactionInfo（包含事务管理器、事务属性、连接点信息(方法名)）
   2. TransactionInfo 设值 transactionStatus
   3. 组装事务链
      1. 将当前线程中的 TransactionInfo 设值到新建的 TransactionInfo.oldTransactionInfo
      2. 将新建的 TransactionInfo 设置到当前线程中

挂起事务

org.springframework.transaction.support.AbstractPlatformTransactionManager#suspend
简述：
如果存在 TransactionSynchronization（代表存在事务），则执行其 suspend() 方法，并挂起当前事务，将被挂起的事务信息打包并返回

详述：

1. 判断 TransactionSynchronization 是否处于激活状态，如果是：
   1. 执行所有事务同步器的 suspend() 方法（AbstractPlatformTransactionManager.doSuspendSynchronization()）
      1. 获取并清空线程中的 List<TransactionSynchronization>
      2. 返回 List<TransactionSynchronization>
   2. 挂起事务（DataSourceTransactionManager.doSuspend()）
      1. 移除并返回线程中（TransactionSynchronizationManager）中的数据库连接
   3. 获取并清空当前线程中（TransactionSynchronizationManager）的设置(当前事务名、readOnly、隔离级别、wasActive)
   4. 将被挂起的事务属性打包成 SuspendedResourcesHolder
   5. 返回
2. 如果不存在事务同步器，但存在事务
   1. 挂起当前事务（DataSourceTransactionManager.doSuspend()）
      1. 移除并返回线程中（TransactionSynchronizationManager）中的数据库连接
   2. 将被挂起的事务属性打包成 SuspendedResourcesHolder
   3. 返回
3. 如果即不存在事务同步器，又不存在事务
   1. 返回空

提交事务

org.springframework.transaction.interceptor.TransactionAspectSupport#commitTransactionAfterReturning
简述：判断事务是否需要回滚，如果是，则执行 回滚事务，根据事务状态执行事务提交、关闭数据库连接、将被挂起的事务恢复

详述：

• 判断事务是否被设置为强制回滚，是则执行 回滚事务，返回
• 判断事务是否被标记为需要回滚，是则执行 回滚事务，返回
• 判断如果存在 TransactionSynchronization，执行其 beforeCommit() 和 beforeCompletion() 方法
• 判断事务是否有 savepoint，如果有则释放 savepoint
• 否则判断是否为新事务
  • 如果是，获取数据库连接，执行提交（DataSourceTransactionManager#doCommit）
• 判断如果存在 TransactionSynchronization，执行其 afterCompletion() 方法

回滚事务

org.springframework.transaction.interceptor.TransactionAspectSupport#completeTransactionAfterThrowing
简述：判断抛出的异常是否与回滚异常相同，相同则执行回滚，根据事务传播机制判断执行回滚 savepoint 或 回滚事务 或 标记事务需要回滚

详述：

• 判断抛出的异常是否与回滚异常相同
  • 是则执行回滚（AbstractPlatformTransactionManager.rollback() -> AbstractPlatformTransactionManager.processRollback()）
    • 判断
      • 存在 savepoint，则回滚至 savepoint
      • 是新事务，则执行回滚
      • 否则将事务标记为需要回滚，在事务提交时执行回滚
    • 如果存在 TransactionSynchronization，执行其 afterCompletion() 方法
  • 否则执行提交（AbstractPlatformTransactionManager.commit()）

Spring 事务强制回滚

如果在方法中增加这一行代码：
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
在提交事务时会做判断，如果为 true，则会执行事务回滚操作

创建代理对象

代码示例：

public interface Azh3ngInterface {
    void test();
}

public static class Azh3ngInterfaceImpl implements Azh3ngInterface {
    public void test() {
        System.out.println("test...");
    }
}

public class TestProxyFactory {
    public static void main(String[] args) {
        Azh3ngInterfaceImpl target = new Azh3ngInterfaceImpl();
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAdvice(new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("before...");
                Object result = invocation.proceed();
                System.out.println("after...");
                return result;
            }
        });
        Azh3ngInterface azh3ngService = (Azh3ngInterface) proxyFactory.getProxy();
        azh3ngService.test();
        /*
          output:
          before...
          test...
          after...
         */
    }
}

通过使用 ProxyFactory，可以不再关心用 CGlib 还是 jdk 动态代理，ProxyFactory 会自动判断，如果 Azh3ngInterfaceImpl 实现了接口，那么 ProxyFactory 底层就会用 JDK 动态代理，如果没有实现接口，就会用 CGlib 技术，上面的代码，就是由于 Azh3ngInterfaceImpl 实现了 Azh3ngInterface 接口，所以最后产生的代理对象是 Azh3ngInterface 类型

Advice

Advice 可以理解为自定义的代理逻辑。 在调用 proxyFactory.addAdvice() 时可以传入各式的 Advice，可以分类为：

• Before Advice（org.springframework.aop.MethodBeforeAdvice）：方法之前执行
• After returning advice（com.tuling.aop.advice.Azh3ngAfterReturningAdvice）：方法 return 后执行
• After throwing advice（org.springframework.aop.ThrowsAdvice）：方法抛异常后执行
  • ThrowsAdvice 接口没有定义方法，需要开发者根据规范自定义方法，可以区分控制不同的异常处理不同逻辑
• After (finally) advice（``）：方法执行完 finally 之后执行，这是最后的，比 return 更后
• Around advice（org.aopalliance.intercept.MethodInterceptor）：功能最强大的 Advice，可以自定义执行顺序 在添加 Advice 后，ProxyFactory 生成的代理对象，会根据添加的顺序执行所有 Advice（[[责任链模式]]）

Pointcut

Pointcut 中文译为切点，可以理解为通过一些过滤条件，筛选出需要被代理的方法

Advisor

Advisor 是 Pointcut 和 Advice 的组合，通过 Pointcut 指定（筛选）被代理的方法，通过 Advice 自定义代理逻辑
在单独使用 Advice 时无法细粒度的控制不同方法执行不同的逻辑，Advisor 可以做到。
假设一个 Azh3ngInterfaceImpl 类中有两个方法，按上面的例子，这两个方法都会被代理和增强，通过使用 Advisor，可以控制到具体代理某个或某些方法，比如：

public class Azh3ngInterfaceImpl {
    public void test1() {
        System.out.println("test1...");
    }
    public void test2() {
        System.out.println("test2...");
    }
}

public class TestProxyFactory {
    public static void main(String[] args) {
        Azh3ngInterfaceImpl target = new Azh3ngInterfaceImpl();
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAdvisor(new PointcutAdvisor() {
            @Override
            public Pointcut getPointcut() {
                return new StaticMethodMatcherPointcut() {
                    @Override
                    public boolean matches(Method method, Class<?> targetClass) {
                        // 仅当方法名为 “test1” 时，才执行 Advice
                        return method.getName().equals("test1");
                    }
                };
            }

            @Override
            public Advice getAdvice() {
                return new MethodInterceptor() {
                    @Override
                    public Object invoke(MethodInvocation invocation) throws Throwable {
                        System.out.println("before...");
                        Object result = invocation.proceed();
                        System.out.println("after...");
                        return result;
                    }
                };
            }

            @Override
            public boolean isPerInstance() {
                return false;
            }
        });
        Azh3ngInterfaceImpl azh3ngInterfaceImpl = (Azh3ngInterfaceImpl) proxyFactory.getProxy();
        azh3ngInterfaceImpl.test1();
        azh3ngInterfaceImpl.test2();
        /*
           output:
           before...
           test1...
           after...
           test2
         */
    }
}

选择 cglib 或 jdk 动态代理

ProxyFactory 在生成代理对象之前需要决定使用 JDK 动态代理还是 CGLIB 技术

• org.springframework.aop.framework.ProxyFactory#getProxy()
  • org.springframework.aop.framework.ProxyCreatorSupport#createAopProxy
    • org.springframework.aop.framework.AopProxyFactory#createAopProxy
      • org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy

// config就是ProxyFactory对象
// optimize为true,或proxyTargetClass为true,或用户没有给ProxyFactory对象添加interface
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
    Class<?> targetClass = config.getTargetClass();
    if (targetClass == null) {
        throw new AopConfigException("TargetSource cannot determine target class: " + "Either an interface or a target is required for proxy creation.");
    }
    // targetClass是接口，直接使用Jdk动态代理
    if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
        return new JdkDynamicAopProxy(config);
    }
    // 使用Cglib
    return new ObjenesisCglibAopProxy(config);
} else {
    // 使用Jdk动态代理
    return new JdkDynamicAopProxy(config);
}

createAopProxy(AdvisedSupport config) 方法接受的参数类型为 AdvisedSupport extends ProxyConfig，同时 ProxyFactory extends ProxyCreatorSupport extends AdvisedSupport，实际传入的也是 ProxyFactory。

1. 选择 CGLIB：

• 运行环境不是 GraalVM
• 并且
  • ProxyFactory 的 optimize 为 true（是否优化，默认为 false。在以前 CGLIB 代理方式运行效率比 JDK 动态代理高，当设置了 optimize = true 则使用 CGLIB，但随着 JDK 版本升级，效率逐渐提升）
  • 或
  • ProxyFactory 的 proxyTargetClass 为 true（是否直接代理指定类，默认为 false，当设置为 true，则不再关心当前类是否有实现接口）
  • 或
  • hasNoUserSuppliedProxyInterfaces(config) == true（开发者没有具体指定代理的接口，通常为 true）
• 并且被代理的类不是接口
• 并且被代理的类不是由 JDK 生成的代理对象

2. 选择 JDK 动态代理

• 运行环境是 GraalVM
• 或
• optimize == false && proxyTargetClass == false && hasNoUserSuppliedProxyInterfaces(config) == false
• 或
• 被代理的类是接口
• 或被代理的类是由 JDK 生成的代理对象

小结： 除非被代理的类是接口，或者被代理的类是由 JDK 生成的代理对象，否则 ProxyFactory 默认会选择使用 CGLIB 代理方式生成代理对象。