Glader's Blog - 中文版

LangChain4j 框架的学习

Glader — Sun, 28 Dec 2025 15:00:00 GMT

1. LangChain4j 简介

概念

LangChain4j 是一个开源的 Java 库/框架，用来简化在 Java 应用中集成和使用大型语言模型的过程。它的设计目标是让 Java 开发者能够像使用 Python 的 LangChain 那样，轻松构建复杂的 AI 应用（比如聊天机器人、智能助手、检索增强生成系统等）。

特点

LLM 集成：提供统一的 API，让你可以调用多种主流的大语言模型（如 OpenAI、Google、Anthropic、国产模型等），而无需直接对接各自的低级接口。

模块化与扩展性：框架采用模块化设计，不同的组件可以单独引入，例如模型提供商、向量数据库、记忆管理、工具调用等。

RAG 支持（检索增强生成）：将外部文本数据转化为向量，结合向量数据库进行语义检索，并将结果注入模型上下文以提升回答质量。

工具与 Agents：支持函数调用、外部工具集成以及智能体工作流（Agents），构建更复杂的 AI 任务流程。

与 Java 生态集成：可以与常见的 Java 框架（如 Spring Boot、Quarkus）结合使用。

2. Java 语言整合 LangChain4j

引入依赖

我们首先创建一个基本的 Java 项目，我这里以 Maven 项目为例。

首先引入 LangChain4j 的核心框架依赖和适配实现依赖 (这里使用 OpenAI 的适配实现)，如下所示：

<dependency>
	<groupId>dev.langchain4j</groupId>
	<artifactId>langchain4j</artifactId>
	<version>${langchain4j.version}</version>
</dependency>

<dependency>
	<groupId>dev.langchain4j</groupId>
	<artifactId>langchain4j-open-ai</artifactId>
	<version>${langchain4j.version}</version>
</dependency>

具体版本的特点，以及其他接口规范的依赖（如阿里、Ollama等）可以参考官方开源仓库或官方文档，他们的使用方法基本和 OpenAI 的一致。

然后我们再引入 Junit 的依赖，便于进行单元测试：

<dependency>
	<groupId>org.junit.jupiter</groupId>
	<artifactId>junit-jupiter</artifactId>
	<version>5.11.4</version>
	<scope>test</scope>
</dependency>

文生文快速入门 Demo

然后我们写一个单元测试就可以快速掌握 LangChain4j 的使用方法：

@Test
public void test1() {
	ChatModel model = OpenAiChatModel.builder()
				.apiKey(System.getenv("OPENAI_API_KEY"))
				.modelName("gpt-4o-mini")
				.build();
	String answer = model.chat("你好");
	System.out.println(answer);
}

如果你有 OpenAI 的 api 密钥，可以直接运行该测试单元，查看结果，就可以输出模型返回的结果。

需要注意的是，ChatModel API 是在 LangChain4j 1.0.0-beta4 版本中引入的。在此之前的版本中，应使用 ChatLanguageModel 作为对话模型的规范接口。

如果我们使用的是其他的一些第三方的 API，如果其也满足 OpenAI 的接口规范，我们可以使用 OpenAiChatModel 中的 baseUrl 方法，来填写第三方 API 接口地址，具体接口地址格式需要根据第三方接口的接口文档来进行规范，但不应包含具体的资源路径，例如，如果我们使用硅基流动的接口：

@Test
public void test1() {
	ChatModel model = OpenAiChatModel.builder()
				.baseUrl("https://api.siliconflow.cn/v1")
				.apiKey(System.getenv("SILICONFLOW_API_KEY"))
				.modelName("Qwen/Qwen3-30B-A3B-Instruct-2507")
				.build();
	String answer = model.chat("你好");
	System.out.println(answer);
}

运行后结果如下：

可以看到，成功打印出模型返回的结果，还带着一个非常可爱的 emoji 表情 😊。

上述红色警告可以暂时忽略，这是因为当前项目尚未配置具体的日志实现。从 LangChain4j 核心框架的依赖树可以看出，它仅引入了 slf4j 作为日志门面，而未绑定任何具体的日志实现。后续在集成 Spring Boot 项目时，Spring Boot 默认提供的日志实现会自动补齐这一部分：

如果不打算集成 Spring Boot 项目，可以手动引入 Logback 作为日志实现来消除该警告。实际上，Spring Boot 默认已经集成并自动配置了 Logback 作为日志实现，因此在 Spring Boot 项目中通常不会遇到该问题。

但是我们现在仅仅做测试，不用日志系统也是没问题的。

文生图快速入门 Demo

对于文生图，使用的是 ImageModel，我这里使用阿里的 Qwen-Image 的文生图模型，这里我们直接调用 ImageModel 下的 generate 方法，传入我们的文本描述即可，比如我想生成一个“猫耳萌妹子”的图片，我们就传入这个字符串，返回的是一个 Response 数据，我们可以使用 response.content().url() 获得生成的图片的直链。

@Test
public void test2() {
    ImageModel model = OpenAiImageModel.builder()
            .baseUrl("https://api.siliconflow.cn/v1")
            .apiKey(System.getenv("SILICONFLOW_API_KEY"))
            .modelName("Qwen/Qwen-Image")
            .build();
    Response<Image> response = model.generate("猫耳萌妹子");
    System.out.println(response.content().url());
}

运行结果如下：

我们把打开链接，下载图片，得到的图片如下：

可见质量非常不错，非常符合我们的要求。

在此基础上，其他模态方向的能力（例如文生语音、图生文、图生视频等）读者可以结合所选平台的 API 文档进一步探索。需要注意的是，不同厂商对多模态能力的接口设计差异较大：有的平台提供 OpenAI-compatible 的扩展端点，有的平台则采用各自的多模态协议或工作流编排接口。实际落地时建议优先选择接口稳定、文档清晰且生态成熟的方案。

3. LangChain4j 整合 Spring Boot

快速入门 Demo

使用 LangChain4j 整合 Spring Boot，首先要求我们的 Spring Boot 版本必须 3.2 版本及以上，且 JDK 版本要求 17 及以上。原文细节

LangChain4j 主要提供了两类 Starter，分别是：

集成类 Starter：用于对接常见的模型提供方、向量数据库、Embedding 服务等第三方组件，提供相应的自动装配与配置能力，便于在 Spring Boot 中开箱即用。
声明式 AI Services Starter：用于启用和增强声明式 AI Service 能力（如 @AiService），支持以接口/注解方式定义 AI 能力，并由框架完成实现生成、依赖注入与运行时编排。

集成类 Starter

这样说比较干燥，我们来先看第一类 Starter。这一类的 Starter 的统一具体格式为：langchain4j-{integration-name}-spring-boot-starter，其中 {integration-name} 表示具体的集成对象（例如某个大模型提供方、Embedding 服务或向量数据库等）。例如我这里用 OpenAI 的统一接口规范，就可以引入如下依赖：

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
    <version>1.10.0-beta18</version>
</dependency>

这里的 {integration-name} 就是 open-ai，对于其他提供方的具体名称格式，可以参考官方仓库。

引入依赖之后，下面就是振奋人心的书写配置信息的阶段。我们可以在 application.properties 中书写，也可以在 application.yml 等格式文件中书写。

倘若在 application.properties 中书写，基本需要加入以下内容：

langchain4j.open-ai.chat-model.api-key=${OPENAI_API_KEY}
langchain4j.open-ai.chat-model.model-name=gpt-4o
langchain4j.open-ai.chat-model.log-requests=true
langchain4j.open-ai.chat-model.log-responses=true
...

这里为什么要用三个点，这是上述四个是基本的配置信息，第一个是密钥信息，第二个是模型信息，第三个是开启把发给模型的请求内容打到日志里，第四个是开启把模型返回的响应内容打到日志里。

还有一些其他的配置项也可以参与配置，具体请参考官方的 api 文档。

比如，我现在要用硅基流动的接口，所以我还需要一个 base-url 的配置项，所以总体配置就是：

langchain4j.open-ai.chat-model.api-key=${SILICONFLOW_API_KEY}
langchain4j.open-ai.chat-model.model-name=Qwen/Qwen3-30B-A3B-Instruct-2507
langchain4j.open-ai.chat-model.base-url=https://api.siliconflow.cn/v1
langchain4j.open-ai.chat-model.log-requests=true
langchain4j.open-ai.chat-model.log-responses=true

然后我们写一个测试 Controller，如下：

@RestController
public class ChatController {

    private ChatModel chatModel;

    public ChatController(ChatModel chatModel) {
        this.chatModel = chatModel;
    }

    @GetMapping("/chat")
    public String model(@RequestParam(value = "message", defaultValue = "Hello") String message) {
        return chatModel.chat(message);
    }
}

在这种情况下，Controller 只依赖接口 ChatModel，具体实现由 starter 自动创建一个实例OpenAiChatModel，来实现自动装配和注入，非常的方便。

然后我们编写测试单元进行测试：

@Autowired
private ChatController chatController;
@Test
void test4(){
    System.out.println(chatController.model("你好，你是谁？"));
}

运行结果如下：

可以看到，不仅有我们 sout 的输出结果，还有请求与响应内容的日志打印，这是我们前面在配置文件里开启的两个 log 的结果。

在实际的项目开发中，我们可以根据我们的需求个性化定义工具类，例如：

@AllArgsConstructor
@Component
public class AIUtil {
    private final ChatModel chatModel;

    public String generateText(String content){
        return chatModel.chat(content);
    }
}

这样就非常的优雅。记得要加上 @Component 注解交给 IoC 容器管理。

我们前面的所有测试，都是等接口完全生成完文本之后，才获得结果，然后打印，但是我们在网页中使用 AI 进行对话的时候，它的输出往往是流式的，例如：

可以看到，他是一个词一个词的往外崩的，并不是把所有内容都获取完毕才返回给我们。这种输出方式通常被称为流式输出，其核心思想是：模型在生成内容的过程中，每产生一个 token（或一个文本片段），就立刻返回给调用方，而不是等待完整响应生成完成。

对于 Web 场景下的 AI 对话来说，流式输出几乎是“标配”，它可以显著提升用户体验：

更低的首字延迟：用户几乎立刻就能看到模型开始“说话”
更自然的交互感：更接近真人输入的节奏
更适合长文本生成：避免长时间白屏等待

接下来，我们就来看一下 LangChain4j + Spring Boot 场景下，如何优雅地实现流式输出。

在 LangChain4j 中，流式输出并不是通过 ChatModel 来完成的，而是通过专门的 Streaming 接口，例如 StreamingChatModel。当使用符合对应模型提供商规范的接口时，LangChain4j 会在底层通过 SSE（Server-Sent Events） 与模型建立流式连接，并将模型在生成过程中产生的 token 增量 逐个回调给调用方。

好在这些复杂的底层细节，我们并不需要手动处理。

LangChain4j 的 Spring Boot Starter 已经为我们封装好了对应的自动配置能力，会根据配置文件自动创建并注册 StreamingChatModel 相关的 Bean。

首先，我们需要在 application.properties 中补充流式模型的配置。与前面同步调用使用的 chat-model 不同，这里使用的是 streaming-chat-model 前缀，如下：

langchain4j.open-ai.streaming-chat-model.api-key=${SILICONFLOW_API_KEY}
langchain4j.open-ai.streaming-chat-model.model-name=Qwen/Qwen3-30B-A3B-Instruct-2507
langchain4j.open-ai.streaming-chat-model.base-url=https://api.siliconflow.cn/v1
langchain4j.open-ai.streaming-chat-model.log-requests=true
langchain4j.open-ai.streaming-chat-model.log-responses=true

然后我们改造一下工具类：

@AllArgsConstructor
@Component
public class AIUtil {
    private final StreamingChatModel streamingChatModel;

    public void generateText(String content, StreamingChatResponseHandler handler){
        streamingChatModel.chat(content,handler);
    }
}

就是把原来的 ChatModel 改成 StreamingChatModel，然后 chat 方法里传入一个回调处理器：StreamingChatResponseHandler。改动非常微小。

现在 Spring Boot 做流式返回已经不需要自己手写 SSE 细节了，我们只需要引入 Spring WebFlux 的依赖，即可方便地通过返回 Flux 实现服务端数据的自动分片、实时推送与连接管理，Spring 会负责底层的 SSE 协议封装与刷新逻辑。

Spring WebFlux 的依赖格式如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

我们以最快的速度写一个 Service 和 Controller 进行测试，如下：

@Service
public class ChatServiceImpl implements ChatService {

    @Autowired
    private AIUtil aiUtil;

    @Override
    public Flux<String> chat(String content) {
        return Flux.create(e->aiUtil.generateText(content, new StreamingChatResponseHandler() {
            @Override
            public void onPartialResponse(String partialResponse) {
                e.next(partialResponse);
            }

            @Override
            public void onCompleteResponse(ChatResponse chatResponse) {
                e.next(" 输出完毕。");
                e.complete();
            }

            @Override
            public void onError(Throwable throwable) {
                e.next(throwable.getMessage());
            }
        }));
    }
}

@RestController
public class ChatController {

    @Autowired
    private ChatService chatService;

    @GetMapping(value = "/chat", produces = "text/event-stream;charset=UTF-8")
    public Flux<String> chat(@RequestParam("message") String content) {
        return chatService.chat(content);
    }
}

接着，我们打开 ApiFox 进行测试，我们输入我们的测试 url：http://localhost:8080/api/chat?message=你好，你是谁，可以看到返回的结果一个词一个词的蹦了出来：

从运行结果可以看出，web 端能够逐段接收实时返回的内容，这正是 StreamingChatResponseHandler 各个回调方法协同工作的结果。下面我们逐一分析这些回调在流式输出中的作用。

StreamingChatResponseHandler 的几个回调方法分别对应了模型生成过程中的不同阶段：在模型尚未完全生成结果时，onPartialResponse 会被多次触发，每次返回一小段内容，我们在这里通过 FluxSink.next() 将数据立即推送给下游，从而实现前端页面中文字的实时输出；当模型生成结束后，会回调 onCompleteResponse，用于标识本次生成已经完成，实际使用中通常在这里结束流；如果在生成过程中发生异常，则会触发 onError，用于将错误信号传递给前端。正是通过 Flux.create 将这种回调式的流转为 Flux，Spring WebFlux 才能够自动以流式的方式将数据持续写入 HTTP 响应中，最终实现无需手写 SSE 的流式输出效果。

除上述三个主要的回调方法之外，还有一个 onPartialThinking 方法。这个方法是做什么的呢？

我们发现，现在其实很多模型都是带思考过程的，就是先进行思考推理，这个回调其实就是来处理推理过程返回的内容的，这里就不再继续讨论，原理和 onPartialResponse 类似，感兴趣的朋友可以继续探究，事实上在后面我们还有更简洁的回调写法，在后面我们再继续探究。

声明式 AI Services Starter

LangChain4j 提供了一个 Spring Boot starter，用于自动配置 AI 服务、RAG、工具等。

我们已经完成了底层模型客户端的自动装配，但如果仍然停留在直接注入 ChatModel、手写 Prompt 和回调逻辑这一层，整体使用方式依然偏向命令式。AI Services Starter 的意义在于进一步抽象这些样板代码，让你可以像编写普通 Spring Service 一样，通过声明式接口来使用大模型能力。你只需要定义方法签名和注解，LangChain4j 就会在运行时自动生成实现，负责 Prompt 构建、模型调用以及结果映射等细节。配合 Spring Boot 的自动配置，模型参数和密钥都可以集中在 application.yml 中统一管理，也便于在不同环境或模型之间切换。当引入 RAG 或工具调用时，这种方式的优势会更加明显，相关编排对业务代码几乎是透明的，使代码始终保持简洁、清晰和可维护。

接下来，我们快速来演示一下在代码中的具体使用。

首先我们要导入 langchain4j-spring-boot-starter 的依赖，如下：

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>1.10.0-beta18</version>
</dependency>

<!--        langchain4j-reactor 是 LangChain4j 对 Reactor（Mono / Flux）的官方适配层，-->
<!--        因为我们流式输出用到了 Flux，这里需要引入下面这个适配层依赖，如果你的项目中不需要流式-->
<!--        输出，则不需要引入下面这个依赖，只需要引入上面的依赖即可。-->
<dependency>
  <groupId>dev.langchain4j</groupId>
  <artifactId>langchain4j-reactor</artifactId>
  <version>1.10.0</version>
</dependency>

然后我们把 ChatServiceImpl 注释掉或删除掉就可以了，我们不用手动去实现这么繁琐的代码，我们直接回到 ChatService 接口中，给它添加上 AiService 注解，如下：

@AiService
public interface ChatService {
    Flux<String> chat(String content);
}

其它代码不需要改动，我们再去运行去 ApiFox 测试一下：

可以看到和我们料想的一样，可以正确给出流式响应，而且不需要我们自己去书写那些繁琐的实现类代码了。

那我们回过头来，去看一下 @AiService 的源码，看看它到底为我们做了什么。源码如下：

@Service
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface AiService {
    AiServiceWiringMode wiringMode() default AiServiceWiringMode.AUTOMATIC; // 装配模式：自动或手动指定依赖
    String chatModel() default "";                 // 同步 ChatModel 的 Bean 名称
    String streamingChatModel() default "";        // 流式 StreamingChatModel 的 Bean 名称
    String chatMemory() default "";                // ChatMemory Bean 名称，用于对话记忆
    String chatMemoryProvider() default "";        // ChatMemoryProvider Bean 名称，按会话创建记忆
    String contentRetriever() default "";          // ContentRetriever Bean 名称，用于 RAG 检索
    String retrievalAugmentor() default "";        // RetrievalAugmentor Bean 名称，封装完整 RAG 增强流程
    String moderationModel() default "";           // ModerationModel Bean 名称，用于内容安全审查
    String toolProvider() default "";               // ToolProvider Bean 名称，用于统一提供工具
    String[] tools() default {};                   // 指定要注入的工具 Bean 名称列表
}

可以看到，AiService 中，又封装了 Service 注解，因此，使用 AiService，就相当于使用了 Service 注解，因此会被 Spring 扫描并纳入 IoC 管理。不过当它标注在接口上时，Spring 注入的并不是接口本身，而是 LangChain4j 根据注解配置在运行时生成的代理实现，关于动态代理的知识点，可以参考我的另一篇博客；这个代理会负责 Prompt 组装、模型选择（chat/streaming）、记忆/RAG/工具等能力的编排，从而让接口方法看起来像普通 Service 调用，但底层实际是在调用大模型。我们来看一下它动态代理部分的源码，位于 dev.langchain4j.service.DefaultAiServices 下：

@Internal
class DefaultAiServices<T> extends AiServices<T> {
    ...
    public T build() {
        validate();
        Object proxyInstance = Proxy.newProxyInstance(
                context.aiServiceClass.getClassLoader(),
                new Class<?>[]{context.aiServiceClass},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // Object / default 方法处理
                        if (method.isDefault()) {
                            return InvocationHandler.invokeDefault(proxy, method, args);
                        }
                        if (method.getDeclaringClass() == Object.class) {
                            ...
                        }
                        // 构建一次 AI 调用上下文
                        InvocationContext invocationContext = InvocationContext.builder()
                                .invocationId(UUID.randomUUID())
                                .interfaceName(context.aiServiceClass.getName())
                                .methodName(method.getName())
                                .build();
                        // 核心入口：将接口方法调用转为 AI 调用
                        return invoke(method, args, invocationContext);
                    }
                    public Object invoke(Method method, Object[] args, InvocationContext invocationContext) {
                        // Prompt / Memory / RAG / Guardrails 等准备
                        ...
                        // 判断是否为流式返回
                        Type returnType = method.getGenericReturnType();
                        boolean streaming =
                                returnType == TokenStream.class || canAdaptTokenStreamTo(returnType);
                        if (streaming) {
                            // 流式：返回 TokenStream 或适配后的类型（如 Flux）
                            TokenStream tokenStream = new AiServiceTokenStream(...);
                            return returnType == TokenStream.class
                                    ? tokenStream
                                    : adapt(tokenStream, returnType);
                        }
                        // 非流式：同步调用模型并解析结果
                        ChatResponse response = chatModel.execute(...);
                        return serviceOutputParser.parse(response, returnType);
                    }
                }
        );
        return (T) proxyInstance;
    }
    ...
}

同时，我们注意到 AiService 中还提供了很多注解属性供我们使用，我们这里只做快速入门，其他属性的具体作用，后期我会单独开文章进行详细的讲解。

Differentiable Auxiliary Learning for Sketch Re-Identification 的解读

Glader — Sat, 27 Dec 2025 10:00:00 GMT

这篇论文是 AAAI-2024 的文章，文章的标题是"Differentiable Auxiliary Learning for Sketch Re-Identification" (可微分辅助学习在草图重识别中的应用)。

论文提出了一种名为 DALNet 的网络架构。该方法通过对真实照片进行背景去除和边缘检测强化，生成一个”类草图“的中间辅助模态，以此来桥接并对齐草图与照片模态。由于负责生成这一辅助模态的模块是可训练且可微分的，支持端到端优化，因此该方法被命名为”可微分辅助学习”（Differentiable Auxiliary Learning, 简称 DAL）。

1. 动机

如上图，论文的动机非常明确，可以分为两大点：

草图与行人图像之间模态间差异太大，能否构建一个中间模态来辅助打破两种模态的差异鸿沟。
草图与行人图像各自模态内差异也很大，首先同一个行人的草图可能有不同画师绘制，风格多样，抽象程度差异大；并且同一个行人在不同摄像头下的照片，会受到背景杂波、光照变化以及视角姿态差异的严重干扰。这导致即便是同一个人的照片，在特征空间中也可能相距甚远，增加了匹配难度。

为解决第一个问题，论文构建了一个“类草图”的中间辅助模态作为桥梁。该模态通过对真实照片进行背景去除与边缘检测增强生成，从而有效地辅助建立了模态间的特征对齐。论文在特征学习阶段加入多模态协同约束：用跨模态的 circle loss 让草图、照片与类草图三者关系整体对齐。

为解决第二个问题，论文又引入模态内的 circle loss 专门压缩同一模态中同身份的分布、拉开不同身份的距离，从而对草图来说，减弱不同画师风格造成的影响；对真实图像来说，减弱光照背景与视角姿态变化等带来的特征漂移问题。

2. 方法

模型的总体框架图如上图所示，整体来说，训练阶段首先使用 Dynamic Auxiliary Generator (DAG) 模块生成一个类草图的辅助模态图像 (这个模块是可循练的，通过 $L_{SR}$ 损失来优化这个模块，使得生成的辅助图像自适应逼近目标草图风格)，然后把草图、辅助图像和真实图像三个模态的图像进行编码，提取特征，然后把辅助模态的特征融合到另外两个模态当中去，并通过交叉注意力机制，强化草图与真实图像之间共享语义信息、实现细粒度交互融合。最后结合分类损失与跨模态/模态内 circle loss 来共同约束三模态的特征关系与分布，下面我来分析一下各部分的细节。

Dynamic Auxiliary Generator (DAG)

这是动态辅助生成器模块，作用就是输入一张真实图像，输出一张类草图的辅助图像。其原理具体如下图所示：

首先，将真实行人图像输入预训练的 U²-Net（该网络参数保持冻结）得到前景分割的掩码矩阵；再利用该掩码对原图进行逐像素筛选，从而保留行人主体并去除背景，得到背景被抠除的行人图像。U²-Net 的具体结构如上图右侧所示，之所以叫 U²-Net，是因为它在整体上是一个 U-Net 式的编码器-解码器结构，但其每个编码与解码阶段内部又嵌套了一个更小的 U-Net（即 RSU 模块，Residual U-block），相当于“U 中套 U”，形成两层 U 形结构的级联，因此用 U 的平方来命名。

U²-Net 会在解码过程中从不同尺度的侧输出层生成多张掩码（side maps），这些掩码分别对应不同分辨率下对前景的预测：浅层侧输出更关注边缘与细节，高层侧输出更关注整体结构与语义区域；训练时通常对这些侧输出施加深度监督以稳定收敛、提升多尺度分割能力，最后再将多尺度侧输出进行融合（如拼接后卷积或加权融合）得到一张最终的高质量前景掩码，用于后续的背景抠除。

得到抠除背景的行人图像后，此时仍然是一个 RGB 的彩色图像，因此首先要通过一个 1×1 的卷积块将其转化为单通道的灰度图像，然后经过一个 3×3 的卷积核，进行边缘检测，强化轮廓线条，使灰度图更加逼近于草图，从而生成类草图的辅助模态图像。这其中，这个 3×3 的卷积核是可循练的，这个也是 DAG 模块唯一可训练优化的地方，通过损失函数 $L_{SR}$ 进行约束，该损失函数的定义我会在下面的特征提取模块中进行详细的分析。卷积核初始化为中心数字为 9，周围 8 个数字为 -0.8，先提供一个稳定的“边缘增强”先验，再在训练过程中根据下游检索目标自适应调整卷积核权重，使生成的 Auxiliary 更符合草图域的轮廓表达方式。

Featrue Extraction

然后是特征提取模块，如下图所示，整体采用一个三流的 ResNet-50 作为 backbone，分别对 Photo、Auxiliary 和 Sketch 三种模态进行特征编码：每个模态先经过各自的前端 ResBlocks (使用的 ResNet-50 的前两个阶段) 提取低层局部特征，得到三路的全局表征；随后再把三路特征送入同一套“权重共享”的后续 ResBlocks (使用的是 ResNet-50 后面剩余的阶段)，学习更高层、更接近语义的共享表示，为后面的模态交互对齐做准备。

具体来看，定义 $P={x_i^P}_{i=1}^{N_p}$ 为真实图像的样本集合，$N_p$ 表示样本数量，$A$ 与 $S$ 集合也是同理，分别表示类草图集合和草图集合。

现将 Photo、Auxiliary 和 Sketch 放入各自的前端 ResBlocks 得到三个编码后的特征图，对这些特征图进行 Gem Pooling 池化操作，分别得到三个池化后的特征向量 $I^P$,$I^A$ 和 $I^S$。具体公式如上图的 $I_k^u$ 所示，其中 $u$ 表示模态，$k$ 表示当前为第 $k$ 个通道，$H$ 和 $W$ 分别代表特征图的高和宽，$p$ 是一个可学习的参数，$p$ 接近为 $1$ 时，池化会更像“平均池化”（对整幅特征图做更均匀的聚合）；而当 $p$ 逐渐变大时，聚合过程会越来越接近“最大池化”（更强调响应最强的位置）。之所以使用 GeM Pooling，是因为它用一个可学习的 $p$ 在平均池化与最大池化之间自适应折中：既能保留全局结构信息，又能突出对行人检索更关键的局部判别区域（如衣服纹理、轮廓细节等），从而在跨模态匹配时获得更稳健、判别性更强的全局表征。

得到的三个特征向量后，论文计算风格细化损失函数 $$L_{SR}$$（其形式与 InfoNCE 类似），具体公式如上图所示，目的是把 DAG 生成的辅助模态 Auxiliary 从“照片风格”拉向“草图风格”，从而优化 DAG 模块的卷积核参数，但又不破坏它继承自 Photo 的人体结构信息。具体做法是：以辅助模态的风格特征 $$I^A$$ 作为锚点，把同一身份对应的草图风格特征 $$I^S$$ 当作唯一的正样本；分母中只放入 $$I^S$$ 与一组照片风格特征 $${I_i^P}_{i=1}^{N}$$ 来做对比，而不额外加入其他草图特征，是因为这里并不是要学习“草图之间”的可分性（那属于身份判别和检索损失去处理），而是要明确地把 $$I^A$$ 从 Photo 域中区分出来并向 Sketch 域靠拢：如果分母再引入大量“其他草图”，优化会变成让 $$I^A$$ 同时远离这些草图（包括与目标草图风格相近的草图），容易削弱“向草图域靠近”的牵引力，甚至引入不必要的身份与风格混杂。因而该损失的对比集合被刻意设计为“一个草图正样本 + 多个照片负样本”，通过温度系数 $$\xi$$ 的 softmax 归一化最大化 $$I^A$$ 与 $$I^S$$ 的相似度、最小化 $$I^A$$ 与各 $$I_i^P$$ 的相似度，从而实现“去照片风格化 + 向草图风格对齐”的风格迁移约束。实验细节里给出温度系数 $$\xi$$ 取值为 0.07。

之后，三路的特征图送入同一套“权重共享”的后续 ResBlocks，学习更高层、更接近语义的共享表示，具体表示为 $f^P$,$f^A$ 和 $f^S$，为后面的模态交互对齐做准备。这里注意，送入到后续的 ResBlocks 的是原来三路生成的特征图，而不是池化后的 $I^u$。

Modality Interactive Attention (MIA)

然后是模态交互注意力模块。具体如下图所示。该模块又具体分为两个模块组成，一个是 Bilinear Align 模块，一个是 Auxilirary Cross-Attention 模块。

双线性对齐模块（BAM）如上图所示，其核心作用是利用辅助模态的特征图 $$f^A$$ 去和另外两个模态的特征图 $$f^P$$、$$f^S$$ 计算相似度权重 $$S_{uA}$$（其中 $u\in{P,S}$）。可以把 $$S_{uA}$$ 理解为一张“注意力打分图”：它刻画了在每个空间位置、每个通道上，当前模态特征与辅助模态特征的匹配程度，匹配高的位置会被赋予更大的权重，从而在后续对特征进行加权时突出更可靠、更一致的行人结构线索。具体计算时，先将 $$f^A$$ 与目标模态的 $$f^u$$ 在通道维进行拼接，然后送入双线性对齐单元建模两者的二阶交互关系，得到对齐后的响应，再通过 $$sigmoid$$ 函数 $$\sigma(\cdot)$$ 将其归一化到 $$[0,1]$$ 范围，形成相似度概率 $$S_{uA}$$，用于对 $$f^u$$ 做注意力加权增强并输出对齐特征。

双线性对齐具体步骤如上图所示，首先要先对张量进行 reshape。原来的 $f^p$、$f^A$ 和 $f^S$，实际上都是 $(N,C,H,W)$ 形状的张量。其中 $N$ 表示批次大小，$C$ 表示通道数，$H$ 和 $W$ 分别表示特征图的高和宽。首先把形状调整成 $(N,C,HW)$，然后进行堆叠拼接，得到一个 $(N,2C,HW)$ 在通道上拼接的结果，如上图的红框内所示，我以上方的红框内的 $f^P$ 与 $f^A$ 的为例，这两个特征图 reshape 后，都用一系列的长条表示，其中向屏幕内部延伸的长度可以抽象为 $HW$，垂直方向的数量可以表示为通道数 $C$，两个特征图堆叠起来就是一共有 $2C$ 个长条 (上半部分 C 个橙色，下半部分 C 个绿色)，之后进入一个线性层，把通道压缩到 $C/4$,目的是在不丢失关键信息的前提下先“降维压缩”两模态拼接后的通道表达，做一次轻量的瓶颈变换：因为拼接后通道数变成了 $2C$，如果直接在高维空间做双线性交互，参数量和计算量都会很大，而且容易过拟合；因此先用第一层线性层把通道压到 $C/4$，相当于做特征筛选与信息蒸馏，保留最有助于两模态对齐的相关成分。然后再进入一个线性层，把通道还原回 $C$,目的是为了把压缩后的“对齐关系”重新映射回与原 backbone 特征一致的通道维度，方便后续与原特征进行融合/逐元素运算，并且输出的维度与后续模块（如相似度估计和注意力加权）保持匹配。

计算得到的 $$S_{uA}$$ 会再 reshape 回 $$(N,C,H,W)$$ 的形状，以便与原始特征图 $$f^u$$ 在空间位置与通道维上一一对应。随后按照对齐公式 $$f_{ali}^u = S_{uA}\odot f^u + f^u$$ 对特征进行加权增强：其中 $$S_{uA}$$ 作为注意力权重，对与辅助模态更一致的区域赋予更高响应、抑制不一致或噪声区域，并通过残差项保留原始信息。最终得到的 $f_{ali}^P$ 和 $f_{ali}^S$ 就是经过 Auxiliary 引导对齐后的 Photo 和 Sketch 特征图，为后续 ACA 的跨注意力交互提供更“干净”、更可对齐的表示。

同时，为了让后续 ACA 做跨注意力交互时，辅助模态也能以“对齐后的、更干净的表示”参与双向匹配（例如把 $$f_{ali}^A$$ 作为 Key/Query 与 $$f_{ali}^P$$ 或 $$f_{ali}^S$$ 进行交互），论文也对辅助模态本身做了一次同样的加权残差增强，得到对齐后的辅助特征 $$f_{ali}^A$$。具体定义为用草图与辅助模态的相似度权重 $$S_{SA}$$ 去加权 $$f^A$$：$$f_{ali}^A = S_{SA}\odot f^A + f^A$$。

最终得到的结果就是这样的了，深浅表示对特征的关注程度，越深关注越强，越浅则越弱。至于为什么有的是虚线框，论文里没有解释，我查阅一些画图的资料，了解到虚线可能表示三种模态下的一些公共特征。

Auxilirary Cross-Attention Module (ACA)

ACA 的目的不是再去“算一个相似度分数”，而是基于 BAM 得到的对齐特征，真正让三种模态之间发生信息交换与融合：论文强调它“利用辅助模态去引导模型学习模态共享表征的分布”，并且能在 photo 与 sketch 之间实现显著的信息交互与融合。

如上图所示，具体计算以 “photo 与 auxiliary 的交互” 为例：把 BAM 输出的对齐特征 $$f_{ali}^P$$ 和 $$f_{ali}^A$$ 分别视为 Query 与 Key（记作 $$Q^P$$ 和 $$K^A$$），然后用标准的缩放点积注意力得到从 photo 指向 auxiliary 的匹配权重 $W_{P\rightarrow A} = \text{Softmax}\left(\frac{Q^P (K^A)^T}{\sqrt{d_K}}\right)$，其中 $$d_K$$ 是 Key 的通道维度。同时再交换 Query与Key 得到反向的匹配权重$W_{A\rightarrow P} = \text{Softmax}\left(\frac{Q^A (K^P)^T}{\sqrt{d_K}}\right)$。

有了双向权重后，论文用一个“往返一致”的方式来精炼 photo 特征：以 $$V^P=f_{ali}^P$$ 作为 Value，将 $$W_{P\rightarrow A}$$ 与 $$W_{A\rightarrow P}$$ 相乘后再去加权 $$V^P$$，最后做 LayerNorm，得到被辅助模态突出后的 photo 特征 $\hat f^P = \text{Norm}\left(W_{P\rightarrow A} W_{A\rightarrow P} V^P\right),\quad V^P=f_{ali}^P.$ 这里可以理解为：先用 $$W_{P\rightarrow A}$$ 找到 photo 中哪些位置或模式能在 auxiliary 中找到对应，再用 $$W_{A\rightarrow P}$$ 把这种对应关系“映射回来”确认一致性，从而更稳健地强化两者共有的结构语义，抑制各自的噪声与不一致区域。

同理，把 $$f_{ali}^S$$ 与 $$f_{ali}^A$$ 做同样的双向 cross-attention，就能得到在 auxiliary 潜在表征引导下精炼后的 sketch 特征 $\hat f^S$。

Multi-Modality Collaborative Learning

多模态协同学习，这部分主要围绕两类损失来设计：一类是类别损失，用于保证三种模态的特征具备清晰的身份判别性；另一类是 circle loss 系列的度量学习损失，其中跨模态 circle loss 用来约束不同模态但同一身份的样本在特征空间中相互靠近、不同身份相互分离，从整体上实现模态间对齐；同时再引入模态内 circle loss，专门压缩同一模态内部同身份样本的分布、拉开不同身份距离，以缓解草图风格差异和照片视角/光照/背景变化带来的类内离散问题。两者配合，使模型同时完成模态间与模态内的对齐。

类别损失

如上图所示，类别（身份）损失用的是 $$L_{ID}$$，目的是用“身份监督”把三种模态拉到同一个可分的身份空间里，让同一人的 Photo / Auxiliary / Sketch 学到一致的身份模式。论文把它写成两部分相加：$$L_{ID}=L_{id}(F)+L_{id}(\hat F)$$，其中 $$F={f^P,f^A,f^S}$$ 表示三种模态经过共享 ResBlocks 输出的特征图集合，$$\hat F={\hat f^P,\hat f^S}$$ 表示经过 MIA 细粒度交互增强后的 Photo 与 Sketch 特征图集合，而 $$L_{id}$$ 就是标准的交叉熵分类损失（用真实身份标签做 softmax 分类监督）。这样设计的直观含义是：一方面直接约束共享骨干提取到的三模态基础表征在身份层面对齐；另一方面也约束经过辅助模态引导交互后的增强表征仍然保持正确的身份判别性，避免注意力交互把特征“对齐”到错误的人或引入身份无关的偏移。

Circle Loss 损失

如上图所示，论文基于 2020 年提出的 circle loss，进行一波改进，适用于草图和图像，并设计了两个损失函数，一个是 $L_{CM}$，这个是用于模态间的对齐；另一个是 $L_{IM}$ 这个是用于模态内的对齐。

论文用 circle loss 来做度量学习约束，而不是常见的 triplet loss，核心原因是：Sketch Re-ID 同时存在“跨模态差异巨大且每个身份样本极少”的问题，单纯用 triplet 往往只在少量三元组上做局部约束，容易出现优化不稳定、对难样本依赖强、以及只顾跨模态而忽略模态内分布的现象；circle loss 则以“成对相似度优化”的统一形式，把一个 batch 中的多对正负样本一起纳入优化，并通过自适应权重 $$\alpha_i^+,\alpha_j^-$$ 更强调那些“更难”的正负对，从而更适合在有限样本下学习更稳健的度量空间。

我先说一下我对原始 circle loss 的一个理解，原始公式如上图的红框内所示。它把“相似度”当作优化对象：对同一身份形成的正样本对，相似度记为 $Z_i^+$（希望它尽可能大）；对不同身份形成的负样本对，相似度记为 $Z_j^-$（希望它尽可能小）。因此它的核心就是同时做两件事：一边把所有 $Z_i^+$ 往 1 拉（拉近同类），一边把所有 $Z_j^-$ 往 0 甚至更小拉（推远异类）。它把正对和负对分别放进指数函数里做加权求和：正对那一项的指数部分大致是 $-\gamma \alpha_i^+(Z_i^+ - \delta(+))$，当某个正对相似度 $Z_i^+$ 还不够大、低于期望阈值 $\delta(+)$ 时，括号是负的，指数项就会变大，对损失贡献变大，从而反向传播会强力推动这个正对去变得更相似；反过来如果 $Z_i^+$ 已经很大，超过 $\delta(+)$，这项贡献就变小，说明“容易正样本”不会再被过度优化。负对那一项的指数部分则是 $\gamma \alpha_j^-(Z_j^- - \delta(-))$，当某个负对相似度 $Z_j^-$ 偏大、超过阈值 $\delta(-)$ 时，这项会迅速变大，损失会更关注这些“难负样本”，从而推动它们的相似度下降；如果负对本来就很小（已经被分开），它的贡献就会被自动压低。这里的 $\delta(+)=1-m$、$\delta(-)=m$ 由间隔 $m$ 控制，相当于给正负对各自设定一个“达标线”，要求正对相似度尽量超过 $1-m$，负对相似度尽量低于 $m$；$\gamma$ 是尺度系数，用来控制优化的“力度/陡峭程度”。而最关键的自适应权重就是 $\alpha_i^+=[1+m-Z_i^+]+$ 和 $\alpha_j^-=[Z_j^-+m]+$：它会让相似度不理想的正对（$Z_i^+$ 小）和最容易混淆的负对（$Z_j^-$ 大）获得更大的权重，从而把训练重点自然转移到“难样本对”上，这就是 circle loss 同时实现“拉近同类、推远异类”且更稳定的原因。

在此基础上，论文把 circle loss 的“成对相似度优化”思想进一步推广到三模态场景，并针对草图 Re-ID 的两个核心矛盾分别做了对应设计。首先是模态间对齐的 $L_{CM}$：它不再只在同一模态里构造正负对，而是直接在不同模态之间计算相似度来构造正负对，也就是把 $Z_i^+$ 和 $Z_j^-$ 变成跨模态的余弦相似度 $Z_i^{uv+}(f^u,f^v)$、$Z_j^{uv-}(f^u,f^v)$（$u\neq v,;u,v\in{S,P,A}$），并对 $AS$、$AP$、$PS$ 三组模态两两施加 circle loss 约束后相加。这样做的直观目的就是：同一身份的 sketch、photo、auxiliary 在特征空间里要彼此靠近，不同身份要分开；而且因为 auxiliary 处在“类草图”的中间态，它同时参与 $AS$ 和 $AP$ 的对齐，会在优化过程中起到桥梁作用，间接降低 $PS$ 的对齐难度。具体如上图里的绿色方框里的公式所示。

但如果只用 $L_{CM}$，模型往往会把优化重心放在“跨模态差异”上，导致每个模态内部同一身份的分布仍然可能很散（比如同一个人不同摄像头的 photo 仍相距很远，或者不同画师的 sketch 风格差异仍很大），从而学到次优的潜在空间。因此论文又加了模态内对齐的 $L_{IM}$：它仍然使用 circle loss 的形式，但构造正负对时是在同一模态内部做约束，并且为了在样本少的情况下制造更有力度的监督，它把同一模态里交互前的特征 $f^u$与交互后的特征 $\hat f^u$配对来构造正样本对（同一身份应当一致），同时选取最容易混淆的异身份配对作为负样本对。这样一来，$L_{CM}$ 负责把不同模态拉到同一度量空间、完成模态间对齐，$L_{IM}$ 负责在各自模态内部压缩类内离散、拉开类间间隔；两者配合，就能同时缓解“跨模态鸿沟”和“模态内差异大”这两个问题。具体如上图里的蓝色方框里的公式所示。

在实验的具体细节里，各参数的设置为 $m_{cm}=0.25$，$m_{im}=0.5$，$\gamma=64$。

总的损失函数就是上述四个损失函数之和，即 $L=L_{ID}+L_{CM}+L_{IM}+λL_{SR}$，其中 $λ = 0.6$。

3. 实验

数据集配置

如上图，论文用到了如上 5 个数据集。

消融实验

如上表1表示在 PKU-Sketch 和 ShoeV2 数据集上的进行消融实验，其中 B 表示 Baseline。论文说明这里的 Baseline 是“只用 identity loss 训练的 ResNet-50”；Aux. 表示是否引入辅助模态。$L_{Cir}$ 表示原始的 circle loss，后面的就是论文设计的损失函数和模块，可以发现，使用论文所提出的完整的模型和损失函数时，所有指标最高。

如上表2是为了验证 DAG 模块是否参与联合训练更新对整个模型的影响，$G_f$ 表示固定参数，$G_j$ 表示参数参与训练优化，这里就是指的是那个卷积核的参数。$L_{SR}$ 指的就是那个风格细化损失。可以发现，当使用 $L_{SR}$ 损失函数在训练时优化 DAG 模块的参数才能使得模型效果最好，指标最高。

对比实验

如上表3~表5是在不同数据集上与当前的 SoTA 模型进行对比，可以看到不管是在哪个数据集上，本文提出的模型各个指标最高。

可视化展示

图3是在做“注意力可视化对比”。论文用 XGrad-CAM 把两条不同视角的草图 query，以及各自 top-4 的检索照片结果的注意力热力图画出来，并用红框和绿框分别标记错误检索和正确检索。结论很直观：Baseline 的注意力容易忽视草图与照片之间真正相关的区域，尤其在场景和姿态变化时会被一些相似局部干扰；而 DALNet 能同时关注到更“跨模态共享”的人体线索（比如脸部关键区域、衣服纹理、包、胸牌等），所以正确检索（绿框）更多。

图4是在做“特征分布对齐过程的可视化”。论文随机选了 PKU-Sketch 的 10 个身份，用 t-SNE 把三种模态的特征分布在训练不同 epoch 下画出来（亮度区分不同身份）。现象是：epoch=0 时 photo（橙）和 sketch（灰）分布差异很大；训练推进后 auxiliary（绿）像“桥”一样把两者连起来；到 epoch=50 时 photo 和 sketch 逐渐收敛，同时类内更紧、类间更开；最终 epoch=100 时 auxiliary 特征会聚到各自身份中心，说明模型学到了更强的身份判别性，并把三模态分布对齐起来。

结论

本文针对草图行人检索中跨模态鸿沟大与模态内变化剧烈的问题，提出 DALNet：先由 DAG 从真实照片生成“类草图”辅助模态作为桥梁，再用三流共享骨干提取特征，并通过 MIA 在辅助模态引导下实现细粒度跨模态交互融合，最后用分类损失与改进的 circle loss（同时包含跨模态与模态内）联合优化，实现模态间与模态内的同步对齐。

创新点在于引入可训练的动态辅助模态生成与风格细化约束来缩小模态差异，并设计“辅助引导的交互注意力和跨模态与模态内的 circle loss”这一整套协同学习机制，使特征分布对齐更稳定、检索性能更强。

Modalities collaboration and granularities interaction for fine–grained sketch-based image retrieval 的解读

Glader — Sat, 22 Nov 2025 10:00:00 GMT

论文的题目为：Modalities collaboration and granularities interaction for fine–grained sketch-based image retrieval 。

可以翻译为：细粒度草图图像检索中的模态协同与粒度交互。

这篇论文发表在 Pattern Recognition 2026 上。

1. 动机

如上图，论文动机就两个：

如图 a，现有方法只关注单模态特征提取，忽略了草图（结构轮廓）和照片（纹理颜色）之间的互补性，且同实例跨模态差异大、不同实例单模态内差异小的特点使直接对齐困难。草图和真实图像之间的互补信息未充分利用。
如图 c，固定大小的块划分会产生边界噪声并割裂完整特征，同时缺少跨粒度特征交互，无法利用多尺度上下文信息增强判别性。

整篇论文就是为了解决这两个问题的。

2. 方法

上面是论文提出的方法总体框架图，框架名称简称为 MCGI，大致可以分为 3 个大模块：CMFL、CMIC和 CGPI。其中 CGPI 又分为三个小模块：MGPM、CGII 和 MGPC。

CMFL (Cross-Modality Feature Learning)

跨模态特征学习模块，这个不是论文的创新点，可以说这就是一个基线模块，这部分论文用的 ViT-B/16 编码器，草图或图像切割成 token 加上位置编码和 [CLS] token 后分别进入编码器的 L 个层（12 层），然后输出的 $f_{cls}^{s,L}$ 和 $f_{cls}^{p,L}$ 这两个 [CLS] token (前者表示草图的，后者表示真实图像的)，然后把这两个 [CLS] token 分别放入 $W_s$ 和 $W_p$ 这两个分类器，对分类结果计算交叉熵损失 $L_{ce}^s$ 和 $L_{ce}^{p}$。同时进行基本的跨模态对齐，论文使用的是三元组损失并且进行互对齐，计算得到的三元组损失分别为 $L_{tri}^s$ 和 $L_{tri}^{p}$，具体公式如下图所示：

CMIC (Cross-Modality Information Compensation)

跨模态信息补偿模块，这是论文提出的第一个创新点，用来解决动机里面的问题 1。方法是对第 l 层（论文取 l = 11）的输出 token 进行交换，交换方法时保留 [CLS] token 不交换，只交换 N 个 patch token，交换前的 token 集合表示为 $F^{s,l}$ 和 $F^{p,l}$（前者表示草图的，后者表示真实图像的），交换后的 token 集合表示为 $\bar{F}^{s,l}$ 和 $\bar{F}^{p,l}$。然后交换完的 token 集合通过剩下的 $L - l$ 层得到输出，分别取两侧的 [CLS] token，分别为的 $\bar{f}{cls}^{s,L}$ 和 $\bar{f}{cls}^{p,L}$ ，用这两个 token 再去如法炮制按照 CMFL 那样计算交叉熵损失得到 $L_{ce}^{s,2}$ 和 $L_{ce}^{p,2}$。

但是有一个问题，我们在训练阶段虽然知道草图和图像是一一配对的，但是在推理阶段不知道配对关系，因此论文设计了一个关系知识蒸馏，把 CMFL 模块输出的两个 [CLS] token: $f_{cls}^{s,L}$ 和 $f_{cls}^{p,L}$ 分别传入两个 MLP 来模拟交换 token 后的输出，并设计损失函数 $L_{rkd}^{s}$ 和 $L_{rkd}^p$ 进行蒸馏，具体公式如下，$\psi_D$ 表示距离函数，$\mu$ 表示距离的归一化因子，$l_{\delta}$ 表示 Huber 损失函数。

CGPI (Cross-Granularity Prototype Interaction)

跨粒度原型交互模块，这是论文的第 2 个创新点，这个就是来解决动机里的问题 2 的。该模块又分为以下三个小模块。

MGPM (Multi-Granularity Prototype Learning Module)

多粒度原型学习模块。该模块论文中简称有两种，分别是 MGPM 和 MGPL。论文的框架图中写的是 MGPM，后面的文字介绍中写的 MGPL，为了统一且便于讲解，我这里使用 MGPM 这种简写方式。

该模块取第 L - 1 层的 patch token 输出 (不含 [CLS] token)，草图和真实图像的输出分别为 $[f_1^{s,L-1},f_2^{s,L-1},...,f_n^{s,L-1}]$ 和 $[f_1^{p,L-1},f_2^{p,L-1},...,f_n^{p,L-1}]$，然后分别平均分成 $M$ 组 (论文里取 $M = 7$)，每组有 $\frac{n}{M}$ 个 token，然后，逐步聚合这些组形成不同粒度的特征序列 $[f_1^{s,L-1},f_{1:2}^{s,L-1},...,f_{1:M}^{s,L-1}]$ 和 $[f_1^{p,L-1},f_{1:2}^{p,L-1},...,f_{1:M}^{p,L-1}]$，其中 $1 : i$ 表示前 $i$ 个组的 token 拼接在一起。

为了增强这些多粒度特征的判别性，论文引入可学习的多粒度共享原型 $P = [P_1, P_2, ..., P_M]$，将每个粒度的原型与对应的 local tokens 拼接：$Z_s = [C(P_1, f_1^{s,L-1}), C(P_2, f_{1:2}^{s,L-1}), ..., C(P_M, f_{1:M}^{s,L-1})]$ 和 $Z_p = [C(P_1, f_1^{p,L-1}), C(P_2, f_{1:2}^{p,L-1}), ..., C(P_M, f_{1:M}^{p,L-1})]$，其中 $C(·)$ 表示拼接操作。这些原型的作用类似于 [CLS] token，每个原型 $P_i$ 负责聚合第 $i$ 个粒度的全局特征表示。

然后把 $Z_s$ 和 $Z_p$ 分别送入第 $L$ 层 Transfomer Encoder 得到 $F^s$ 和 $F^p$，具体详细图解流程与公式如下图所示。

CGII (Cross-granularity information interaction)

跨粒度信息交互模块，这个模块是用来继续处理上一个模块的输出的，该模块通过引入两个外部记忆单元 $M_k$ 和 $M_v $作为 Key 和 Value，将多粒度原型特征 $F_s$ 和 $F_p$ 作为 Query，计算跨粒度的注意力权重来捕获不同粒度之间的上下文关联。通过多头注意力机制聚合不同粒度的信息，输出增强后的多粒度特征 $\tilde{F}_s = [\tilde{P}_1^s, \tilde{P}_2^s, ..., \tilde{P}_M^s]$ 和 $\tilde{F}_p = [\tilde{P}_1^p, \tilde{P}_2^p, ..., \tilde{P}M^p]$，最后与全局 [CLS] token 拼接得到完整的增强特征集 $f_s^{en} = [f{cls}^{s,L}, \tilde{P}_1^s, \tilde{P}_2^s, ..., \tilde{P}M^s]$ 和 $f_p^{en} = [f{cls}^{p,L}, \tilde{P}_1^p, \tilde{P}_2^p, ..., \tilde{P}_M^p]$。具体流程如下所示：

MGPC (Multi-Granularity Prototype-aware Contrastive Loss)

多粒度原型感知对比损失模块，该模块使用上一个模块输出的 $f_{en}^s$ 和 $f_{en}^p$，计算对比损失 $L_{mgpc}$ 来进一步对齐跨模态的多粒度特征表示。该损失通过增加正样本对（配对的草图-照片）在多粒度特征空间中的相似度，同时减小负样本对的相似度，促进草图和照片在多粒度层面的特征对齐。具体流程和公式如下：

总体损失，便是上述所有损失加权求和，其中取 $\lambda_1 = 0.6$，$\lambda_2 = 1.0$。这两个参数调优在后面实验会进行探讨。

3. 实验

数据集设置

实验设置如下，用到了四个数据集：

分别是椅子数据集、鞋子数据集、衣服数据集和行人数据集。

与当前先进的方法对比

上图三个表展示了在不同数据集下，与当前先进的方法进行的对比，可以发现改论文的模型总体效果更好，尤其是在椅子和鞋子数据集上，在所有指标上都具有提升。

消融实验

如上图，第一个表是在鞋子数据集上进行的消融实验分析，探讨论文提出的四个创新性的模块的作用，可以发现只有所有模块都使用时，指标是最高的，这说明每个模块都不可或缺。

第二个表是对各损失函数进行消融分析，也是在鞋子数据集上进行实验分析，可以发现，移除任意一种损失函数都会导致模型性能出现不同程度的下降。这些结果验证了所提出的每个损失函数对模型整体性能的有效贡献。

超参数分析

如上图所示，(a) 图展示了在不同层进行 token 交换对模型性能的影响。实验结果表明，随着层数 $l$ 的增加，各准确率和 mAP 均呈现出逐步上升的趋势，并在 $l = 11$ 时达到峰值，因此论文 $l$ 取 $11$。

(b) 图展示了多粒度数量 $M$ (也就是前面的分组数量) 对模型性能的影响。实验结果显示，当 $M$ 取 $7$ 时，各项指标整体最好，且 mAP 最高。

后面两个折线图分别是来实验 $\lambda_1$ 与 $\lambda_2$ 的取值对实验的影响的，可以发现 $\lambda_1=0.6$，$\lambda_2=1.0$ 时效果最好。

实验展示

上图展示了该论文提出的方法在四个数据集上的检索结果可视化，其中绿色方框表示检索正确的图像，红色方框表示检索错误的图像。方法能够将正确的目标图像排在更靠前的位置。这一改进在椅子、鞋子、服装和行人等不同类型的数据集上均有体现，证明了该论文框架具有良好的泛化能力。

4. 总结

MCGI 框架通过利用跨模态互补信息和跨粒度上下文关联来解决细粒度草图图像检索问题，从而弥合模态差异并增强特征判别性。

跨模态信息补偿（CMIC）模块通过 token 交换和知识蒸馏整合草图和照片的互补信息，以学习模态鲁棒的特征表示。

跨粒度原型交互（CGPI）模块分层提取多粒度特征并建模其上下文交互，以捕获判别性的细粒度信息。

在四个基准数据集上的大量实验证明了最先进的性能，在 QMUL-Chair-V2 上达到 78.6% 的 Rank-1 准确率，在 QMUL-Shoe-V2 上达到 44.5%，在 Clothes-V1 上达到 96.0%，在 Sketch Re-ID 上达到 91.5%。

消融研究验证了各个组件的有效性，其中 CMIC 提高了模态鲁棒性，CGPI 通过分层特征学习和跨粒度交互增强了细粒度判别性。

略微探讨 Spring 事务

Glader — Wed, 19 Nov 2025 16:00:00 GMT

1. 什么是事务

事务的定义

事物通常是指一组要被视为整体执行的活动或事件。

举个例子，比如银行转账，A 账户向 B 账户进行转账 100 元，此时要求下面两种操作：

A 账户余额减少 100 元
B 账户余额增加 100 元

这两个操作必须一起成功或一起失败。如果 A 账户余额减少了，B 账户没有增加，亦或者 A 账户余额没变，B 账户余额增加了，这就会出现数据不一致的问题，也就是银行系统出现了错误，账务记录不再可靠。

事务就是来解决类似于上述情况的问题，这便就是事务存在的意义：确保操作要么全部成功，要么全部失败，避免部分完成导致的数据错误，从而保证数据的一致性与完整性。

事务的性质

事务具有 ACID 四种特性，即原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）。

原子性：事务不可分割。

一致性：事务前后数据保持有效状态。

隔离性：多个事务互不干扰。

持久性：提交后数据永久保存。

2. MySQL 中的事务

注意事项

MySQL 并非所有存储引擎都支持事务：

支持事务：InnoDB（默认）
不支持事务：MyISAM（不支持事务，数据操作无法回滚）

使用事务前，请确保表是 InnoDB 引擎。

基本事务操作

在 MySQL 中，我们可以使用 START TRANSACTION 或 BEGIN 进行开启事务，然后执行 SQL 操作。然后使用 COMMIT 进行事务的提交或使用 ROLLBACK 进行事务的回滚。

下面我们以上面的银行转账进行举例，首先创建一张简化的用户余额数据表，并初始化一定的数据：

CREATE TABLE accounts (
    id CHAR(1) PRIMARY KEY,
    balance DECIMAL(10,2) NOT NULL
) ENGINE=InnoDB;

INSERT INTO accounts (id, balance) VALUES
('A', 1000.00),
('B', 500.00);

注意：正常项目中主键通常用整数类型，这里为了符合上面的题目例子，方便解释设置为 char 类型。

接下来我们在 console 中输入 START TRANSACTION 开启事务。

现在我们我们创建一个转账的操作，并执行：

-- 扣减 A 账户余额
UPDATE accounts
SET balance = balance - 100
WHERE id = 'A';

-- 增加 B 账户余额
UPDATE accounts
SET balance = balance + 100
WHERE id = 'B';

此时我们使用 SELECT * FROM accounts 来查看当前的表状态：

可以发现已经操作成功了，A 与 B 的余额发生了变化，但是我们此时再回到 IDEA 的数据库工具面板中查看表格数据，却发现余额没有变化：

这便是事务隔离性的体现。这些修改只在事务内部可见。在 同一个会话中，事务未提交前对数据的修改是可见的，但对于其他会话，这些修改仍然不可见，直到事务提交后才会对外生效。我们在 IDEA 中打开数据库工具面板查看表格数据，这相当于开启了一个新的会话，这和刚才的事务是相互独立的，因此数据并没有发生变化。

此时如果我们使用 COMMIT 提交事务，此时数据才正式的写到数据库表中去持久化，这便是事务的持久性。

此时，我们就会发现在 IDEA 的数据库工具中查看表格数据就被修改了：

同理，使用 ROLLBACK 就可以撤销事务中所有未提交的操作，将数据恢复到事务开始之前的状态。这样，即使在事务内进行了多次修改，也不会影响数据库的实际数据，实现 原子性 和 一致性。

3. Spring 中的事务

示例 Demo

我们编写如下代码：

@Mapper
public interface AccountsMapper {
    @Update("UPDATE accounts " +
            "SET balance = balance + #{delta} " +
            "WHERE id = #{id}")
    void updateByDelta(@Param("id") Character id, @Param("delta") BigDecimal delta);
}

@Service
public class AccountsService {
    @Autowired
    private AccountsMapper accountsMapper;

    public void transfer(Character id1, Character id2, BigDecimal delta) {
        accountsMapper.updateByDelta(id1,BigDecimal.ZERO.subtract(delta));
        System.out.println(1 / 0);
        accountsMapper.updateByDelta(id2,delta);
    }

}

在 AccountsService 中我们定义了一个简易的 transfer 转账方法。在该方法中，我们故意写了一个 1/0，让其抛出运行时异常，运行后我们查看抛出异常后，数据库中的数据有没有发生变化。

我们创建一个测试单元：

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    private AccountsService accountsService;
    @Test
    void  testTransaction(){
        accountsService.transfer('A','B',new BigDecimal("100"));
    }
}

运行后我们发现，抛出了一个异常：

此时我们去查看数据库表，我们发现，出问题了：

A 账户的余额减少了 100 元，B 账户的余额却没有增加，总的余额 1500 缺无缘无故少了 100 元，这就对数据的一致性与完整性造成了问题。

在 AccountsService 代码中，首先成功运行了 accountsMapper.updateByDelta(id1,BigDecimal.ZERO.subtract(delta));,但是之后抛出异常后，下面的 accountsMapper.updateByDelta(id2,delta); 就不执行了，因此就造成了上述问题。而我们希望的是，这两个 update 要么同时成功，要么同时失败才可以。因此，必须把这两个 update 封成一个事务去执行，一旦其中一个失败，则全部 ROLLBACK 回滚。

`@Transactional` 的基本用法

在 Spring 框架中，事务管理是通过 Spring 的事务抽象来实现的，它可以让我们在业务代码中方便地管理事务，而不需要直接操作数据库的 START TRANSACTION、COMMIT 或 ROLLBACK。

在 Spring 框架中，我们往往使用 @Transactional 注解来声明某个方法或类需要在事务中执行。Spring 会在方法执行前自动开启事务，方法执行成功后提交事务，如果在执行过程中出现 RuntimeException 或 Error，事务会自动回滚，从而保证操作的原子性和一致性。

@Transactional 既可以加在方法上，又可以加在类上。如果加在方法上，则只对该方法生效，事务仅在执行该方法时开启；如果加在类上，则作用于类中所有公共方法，相当于给每个公共方法都加了事务。但在实际开发中，通常是只加在需要用的方法上，而不是直接加在类上。

下面我们把刚才的 AccountsService 中的 transfer 方法上，加上 @Transactional 的注解，如下：

@Service
public class AccountsService {
    @Autowired
    private AccountsMapper accountsMapper;

    @Transactional
    public void transfer(Character id1, Character id2, BigDecimal delta) {
        accountsMapper.updateByDelta(id1,BigDecimal.ZERO.subtract(delta));
        System.out.println(1 / 0);
        accountsMapper.updateByDelta(id2,delta);
    }

}

为了对比，我先把数据库的数据还原成 900 与 600。

再次运行单元测试，抛出异常后，查看数据库结果：

刷新后，可以看到，数据没有任何变动修改,这说明事务成功回滚了。当 transfer 方法执行到 1/0 抛出 ArithmeticException 异常时，Spring 检测到运行时异常，自动触发了事务回滚，撤销了之前对 A 账户的扣款操作，保证了数据的一致性。

如果我们此时把 1/0 的代码删掉，然后再去运行，此时没有任何异常，因此会 COMMIT 成功，刷新数据库表如下图所示。

`@Transactional` 的高级用法

`rollBackFor` 属性

OK，刚才前面说的是遇到运行时异常时自动回滚，那如果异常不是运行时异常，还会不会自动回滚？我们来测试一下。我们修改 transfer 代码如下：

@Service
public class AccountsService {
    @Autowired
    private AccountsMapper accountsMapper;
    @Transactional
    public void transfer(Character id1, Character id2, BigDecimal delta) throws Exception {
        accountsMapper.updateByDelta(id1,BigDecimal.ZERO.subtract(delta));
        if(true){
            throw new Exception("手动抛出异常~");
        }
        accountsMapper.updateByDelta(id2,delta);
    }
}

使用 if(true) 可以让编译器认为下面的语句可能会被执行到，因此不会编译报错，相当于“骗”了一下编译器。

单元测试里我们捕获异常，如下：

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    private AccountsService accountsService;
    @Test
    void  testTransaction(){
        try {
            accountsService.transfer('A','B',new BigDecimal("100"));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

运行单元测试后刷新并查看数据库表我们发现，又出问题了：

还是和最初始的那样，即使加了 @Transactional，也出现了之前的情况，A 的余额减少，B 的余额没增加，这是因为什么？

就像我们刚才所说的，@Transactional 默认只能对运行时异常自动回滚，因为 ArithmeticException 是 RuntimeException 的子类，因此可以自动回滚，但是 Exception 不是运行时异常，因此无法自动回滚。

怎么办，难道我们就没有办法解决这个问题了吗？我们马上去看一下 @Transactional 的源码，来看看这个注解里有没有什么属性我们可以设置。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    @AliasFor("transactionManager")
    String value() default "";

    @AliasFor("value")
    String transactionManager() default "";

    String[] label() default {};

    Propagation propagation() default Propagation.REQUIRED;

    Isolation isolation() default Isolation.DEFAULT;

    int timeout() default -1;

    String timeoutString() default "";

    boolean readOnly() default false;

    Class<? extends Throwable>[] rollbackFor() default {};

    String[] rollbackForClassName() default {};

    Class<? extends Throwable>[] noRollbackFor() default {};

    String[] noRollbackForClassName() default {};
}

我们发现了 Class<? extends Throwable>[] rollbackFor() default {};，听这名字一看 rollbackFor，为...而回滚，这不正是我们想要的吗？他的传入值是一个 Class 数组的形式，我们立马回到我们的 transfer 方法，添加上这个属性，如下：

@Service
public class AccountsService {
    @Autowired
    private AccountsMapper accountsMapper;

    @Transactional(rollbackFor = {Exception.class})
    public void transfer(Character id1, Character id2, BigDecimal delta) throws Exception {
        accountsMapper.updateByDelta(id1,BigDecimal.ZERO.subtract(delta));
        if(true){
            throw new Exception("手动抛出异常~");
        }
        accountsMapper.updateByDelta(id2,delta);
    }
}

然后我们把数据库数据还原成 800 和 700，再去进行单元测试，结果如下：

这下就非常完美了，异常也抛出了，数据也没有被修改，说明 ROLLBACK 回滚了。

事务传播行为

好，但是我们又有一个问题。我们在项目中，往往会有储存操作日志的业务逻辑，下面我们创建一个 accounts_log 表。

CREATE TABLE accounts_log (
    id BigInt PRIMARY KEY AUTO_INCREMENT,
    message TEXT NOT NULL
) ENGINE=InnoDB;

请注意，我这是简化的 log 表，正常项目开发没这么简单，还有很多别的字段，如日志类型等。

然后创建一个实体类：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class AccountsLog {
    private Long id;
    private String message;
}

创建一个 Mapper：

@Mapper
public interface AccountsLogMapper {
    @Insert("INSERT INTO accounts_log VALUES(#{id},#{message})")
    void insert(AccountsLog accountsLog);
}

创建一个 Service：

@Service
public class AccountsLogService {
    @Autowired
    private AccountsLogMapper accountsLogMapper;
    
    public void insert(AccountsLog accountsLog) {
        accountsLogMapper.insert(accountsLog);
    }

}

改造 transfer 代码：

@Service
public class AccountsService {
    @Autowired
    private AccountsMapper accountsMapper;

    @Autowired
    private AccountsLogService accountsLogService;

    @Transactional(rollbackFor = {Exception.class})
    public void transfer(Character id1, Character id2, BigDecimal delta) throws Exception {
        String message = id1 + "给"
                + id2 + "发起转账" + delta + "元, ";
        try {
            accountsMapper.updateByDelta(id1,BigDecimal.ZERO.subtract(delta));
            if(true){
                throw new Exception("手动抛出异常~");
            }
            accountsMapper.updateByDelta(id2,delta);
            message = "成功了！";
        } catch (Exception e){
            message += "但是失败了！";
            throw e;//继续抛出异常，要不然 @Transactional 检测不到
        }finally {
            accountsLogService.insert(new AccountsLog(null,message));
        }
    }

}

我们要求转账不论是否成功，都要记录日志，如果只这样写，我们运行单元测试后发现：

异常抛出了，但是 accounts_log 表里却没有数据，这是因为虽然 accountsLogService.insert 是在 finally 里被调用，但是该操作仍然在同一个事务方法下被约束，只要有异常，所有修改都会被回滚，包括 finally 中的操作。那么我们如何解决这个问题呢？

在 Transactional 的源码中我们看到有一个属性 Propagation propagation() default Propagation.REQUIRED;，这个属性用于控制事务的传播行为，即当一个事务方法被另一个事务方法调用时，如何处理事务的问题。

Spring 定义了 7 种事务传播行为:

传播行为	说明
REQUIRED (默认)	如果当前存在事务，则加入该事务；如果没有事务，则创建一个新事务
REQUIRES_NEW	总是创建新事务，如果当前存在事务，则将当前事务挂起
SUPPORTS	如果当前存在事务，则加入该事务；如果没有事务，则以非事务方式执行
NOT_SUPPORTED	以非事务方式执行，如果当前存在事务，则将当前事务挂起
MANDATORY	如果当前存在事务，则加入该事务；如果没有事务，则抛出异常
NEVER	以非事务方式执行，如果当前存在事务，则抛出异常
NESTED	如果当前存在事务，则在嵌套事务内执行；如果没有事务，则创建一个新事务

对于我们的日志记录需求，应该使用 Propagation.REQUIRES_NEW，它会创建一个完全独立的新事务，不受外层事务回滚的影响。

我们修改 AccountsLogService 如下：

@Service
public class AccountsLogService {
    @Autowired
    private AccountsLogMapper accountsLogMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void insert(AccountsLog accountsLog) {
        accountsLogMapper.insert(accountsLog);
    }

}

此时我们再去运行单元测试查看数据库表结果：

相当完美，我们的日志添加成功了。对于当前这个例子，在进行内层事务时，外层事务会挂起，等待内层事务声明周期结束后，才重新唤醒外层事务。

但是在正式的项目开发中，我们大部分情况是使用默认的传播方式的（约 85 % ~ 90 % 的情景），其次使用较多的就是 REQUIRES_NEW (约 5 % ~10 %)，其他传播方式使用的概率不是很大，感兴趣的小伙伴可以自行去了解。

Spring Bean 的作用域与生命周期

Glader — Mon, 20 Oct 2025 15:31:53 GMT

Spring Bean 的作用域默认是单例 (Singleton)，同时支持修改为多例 (Prototype)。那么怎么具体来实现呢？

Singleton

先来了解一下什么是单例。

我们举一个不太恰当的例子，我们在写一个配置类 ArrayListConfig，用来把 ArrayList 交给 IOC 容器管理，如下：

@Configuration
public class ArrayListConfig {

    @Bean
    public ArrayList<String> arrayList() {
        return new ArrayList<String>();
    }

}

注意，事实上，我们正常开发做项目的时候是不会让 IOC 来管理 ArrayList 的生命周期的，这里仅仅为了方便演示，便于学习。

好，我们现在创建好了这个配置类，然后我们写一个单元测试：

@Autowired
private ArrayList<String> arrayList1;
@Autowired
private ArrayList<String> arrayList2;
@Test
void test1(){
    arrayList1.add("1");
    arrayList2.add("2");
    System.out.println(arrayList1);
    System.out.println(arrayList2);
}

那么大家思考一下，打印输出的结果会是什么呢？

他输出的都是 [1, 2]，这就是 Singleton。在 IOC 容器启动时，就会创建一个 Bean 实例，之后我们自动装配后获得的对象，都是指向同一个 Bean 实例，因此才会输出同样的内容。

那么我们如何才能够实现这两个 ArrayList 指向不同的 Bean 实例呢？这就要求我们使用多例 Prototype 了。

Prototype

多例很简单，我们只需要使用注解 @Scope 即可，例如：

@Configuration
public class ArrayListConfig {

    @Bean
    @Scope("prototype")
    public ArrayList<String> arrayList() {
        return new ArrayList<String>();
    }

}

如上图，此时便达到我们想要的效果了，这就是多例。

实际上，单例是 @Scope("singleton")，但我们一般省略不写。

@Scope 也可以结合 @Compoment 等在定义类时直接实现单例或多例，这里便不再演示。

注意，多例 Bean 有时候也称为原型 Bean。

Bean 的生命周期

不知道大家有没有思考过 Bean 的生命周期这一问题。

就比如，我们交给 IOC 容器管理的 Bean，他都是什么时候创建的呢？就比如我们上面的那个 ArrayList，他是在我们第一次使用的时候创建的，还是容器一启动的时候就创建好了？

为了便于测试，现在我先手动创建一个类，并交给 IOC 容其管理，代码如下：

@Component
public class Kunkun {
    public Kunkun() {
        System.out.println("坤坤诞生了！");
    }
}

然后我们写个单元测试：

@Test
void test2(){
    
}

如上，我们发现，即使没有使用 Kunkun（我们也没有 @Autowired 一个 Kunkun），Kunkun 的构造函数也被调用了，这说明默认情况下，容器启动时初始化单例 Bean。

那么有些时候，提前把所有 Bean 对象都创建好是比较浪费资源的，那么我们能不能这样，就是我们第一次使用这个 Bean 的时候，再去创建，之后再用直接就从 IOC 容器中拿就可以了，能否这样呢？是可以的，我们只需要加上 @Lazy 这个注解就可以了，例如：

@Component
@Lazy
public class Kunkun {
    public Kunkun() {
        System.out.println("坤坤诞生了！");
    }
}

这个时候我们再去运行刚才的单元测试 Test2 就不会有任何输出了。

那么此时我们修改一下单元测试，如下：

@Autowired
private Kunkun kunkun;

@Test
void test2(){
    
}

我们此时运行发现：

这说明，此时 Kunkun 的 Bean 对象在使用时，才进行了创建。

请注意，我们上述讲的都是针对单例 Bean 的情况，如果是多例 Bean 呢？

我们不妨在刚才的类里加一个 @Scope("prototype")，如下：

package top.mygld.demo.test;

import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class Kunkun {
    public Kunkun() {
        System.out.println("坤坤诞生了！");
    }
}

此时我们仍然不声明并创建 Kunkun，来看看启动时有没有出现 Kunkun 的构造方法。

经过测试，发现的确没有任何关于 Kunkun 构造方法的输出，这说明对于多例 Bean，不会在 IOC 容器启动时就被初始化创建。

那么我们 @Autowired 两个 Kunkun，如下：

@Autowired
private Kunkun kunkun1;
@Autowired
private Kunkun kunkun2;
@Test
void test3(){

}

运行后输出：

可以看到，构造方法调用成功了，我们不难得出结论，对于多例 Bean，默认就是懒加载方式，如果你还想加 @Lazy，当然也是不会报错的，但是加上没什么用。

好了，聊完了单例和多例 Bean 的创建，我们再聊聊销毁。

先看单例 Bean 的销毁：

有一个注解 @PreDestroy，被它所注解的方法，在 Bean 销毁时会自动执行，例如：

@Component
public class Kunkun {
    public Kunkun() {
        System.out.println("坤坤诞生了！");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("Kunkun 被销毁~");
    }
}

我们随便写个单元测试，@Autowired 一个 Kunkun 看看效果：

可以发现，对于单例 Bean，在容器被销毁时，Bean 实例也会被销毁。

那么我们再把他变成多例 Bean 实验一下：

package top.mygld.demo.test;

import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;

@Component
@Scope("prototype")
public class Kunkun {
    public Kunkun() {
        System.out.println("坤坤诞生了！");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("Kunkun 被销毁~");
    }
}

在单元测试中 @Autowired 两个 Kunkun，并测试：

我们发现，只有构造方法被调用了，但容器被销毁后，Bean 对象并没有被销毁。这是因为对于多例 Bean，容器并不会去管理它的销毁，必须手动强制去销毁，如下：

@Autowired
private Kunkun kunkun1;
@Autowired
private Kunkun kunkun2;
@Test
void test3(){
    kunkun1.preDestroy();
    kunkun2.preDestroy();
}

总结

默认作用域
- Spring Bean 默认是 单例（Singleton），整个容器共享一个实例。
- 可以通过 @Scope("prototype") 或“多例（Prototype）”来每次获取都创建新实例。
创建时机
- 单例 Bean：容器启动时创建（非 @Lazy 时）
- 多例 Bean：每次获取时创建，默认就是按需创建（懒加载）
- @Lazy：用于延迟单例 Bean 初始化，对多例 Bean 无实际意义
销毁机制
- 单例 Bean：容器关闭时自动销毁，支持 @PreDestroy 或 DisposableBean.destroy()
- 多例 Bean：容器不管理销毁，需要手动调用销毁方法
使用场景
- 单例：全局共享对象、服务类、配置类
- 多例：临时对象、短期使用对象、频繁创建的计算或任务对象
关键点
- 单例 Bean 生命周期长，容器全权管理
- 多例 Bean 生命周期短，开发者负责资源释放
- @Lazy 主要优化单例 Bean 的初始化，减少启动开销

第三方 Bean 注入 IoC 容器

Glader — Mon, 13 Oct 2025 16:00:30 GMT

在实际开发过程中，我们往往需要集成各类第三方库来提高开发效率或扩展系统功能。然而，在使用 Spring 或 Spring Boot 框架时，如何将这些第三方库中的组件正确地注册到 IoC 容器中，常常成为需要解决的问题。

手动注册 @Bean

以第三方工具包 HuTool 举例，首先我们先引入 HuTool 的 Maven 依赖，如下：

<dependency>    
    <groupId>cn.hutool</groupId>    
    <artifactId>hutool-all</artifactId>    
    <version>5.8.41</version>
</dependency>

在 HuTool 中，如果我们要使用 cn.hutool.http.HttpUtil 工具类，我们希望能够像这样使用：

@Autowired
private HttpUtil httpUtil;

但很明显，直接这样写会报错：

No qualifying bean of type 'cn.hutool.http.HttpUtil' available

因为 Hutool 的类都是静态方法，没有注册到 Spring 容器中。

我们可以手动在配置类中创建 Bean，使用 @Bean 注解，如下：

@Configuration
public class HutoolConfig {
    @Bean
    public HttpUtil getHttpUtil() {
        return new HttpUtil();
    }
}

然后我们进行单元测试：

@Autowired
private HttpUtil httpUtil;
@Test
void test1(){
    System.out.println(httpUtil.get("https://www.baidu.com"));
}

如果在配置类中创建 Bean 时，你有需要传入形参，如果 IOC 容器中有这个形参的类型，则可以自动注入。例如：

@Configuration
public class SecurityConfig {
    @Bean
    public AuthenticationManager getAuthenticationManager(HttpSecurity http) throws Exception {
        return http.getSharedObject(AuthenticationManagerBuilder.class)
                   .build();
    }
}

他相当于省略了

@Autowired
HttpSecurity http;

@ComponentScan —— 扩展扫描路径

如果第三方库中的某些类已经使用了 @Component、@Service、@Repository 等注解，但这些类不在我们默认的扫描路径下，可以通过 @ComponentScan 来扩展扫描范围。

@SpringBootApplication
@ComponentScan(basePackages = {
    "com.example.myapp",           // 你的项目包路径
    "com.baomidou.mybatisplus.extension.plugins"  // 第三方库包路径
})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

basePackages 是一个数组，一旦使用 @ComponentScan，@SpringBootApplication 中的默认扫描路径便失效，我们必须在 basePackages 配置上我们项目的包路径，然后再去添加第三方库的包路径。

@Import 直接导入配置类

使用 @Import 可以直接导入配置类或普通类到 Spring 容器中：

// 第三方配置类
public class RedissonConfig {
    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress("redis://127.0.0.1:6379")
              .setPassword("your-password");
        return Redisson.create(config);
    }
}

// 在主配置类中导入
@Configuration
@Import(RedissonConfig.class)
public class ApplicationConfig {
}

或者直接在启动类上使用：

@SpringBootApplication
@Import({RedissonConfig.class, OtherConfig.class})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

导入普通类

@Import 还可以直接导入没有任何注解的普通类：

// 第三方普通类
public class DataConverter {
    public String convert(Object data) {
        return JSON.toJSONString(data);
    }
}

// 导入配置
@Configuration
@Import(DataConverter.class)
public class ConverterConfig {
}

导入后可以直接注入使用：

@Service
public class DataService {
    @Autowired
    private DataConverter dataConverter;
    
    public String processData(Object data) {
        return dataConverter.convert(data);
    }
}

ImportSelector 动态注册 Bean

ImportSelector 允许我们根据条件动态选择要导入的配置类，这在需要根据环境或配置动态注册 Bean 时非常有用。

// 自定义 ImportSelector
public class ElasticsearchImportSelector implements ImportSelector {
    
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 可以根据注解属性、环境变量等动态决定导入哪些配置类
        Map<String, Object> attributes = importingClassMetadata
            .getAnnotationAttributes(EnableElasticsearch.class.getName());
        
        String mode = (String) attributes.get("mode");
        
        if ("rest".equals(mode)) {
            return new String[]{
                "com.example.config.ElasticsearchRestClientConfig"
            };
        } else if ("transport".equals(mode)) {
            return new String[]{
                "com.example.config.ElasticsearchTransportConfig"
            };
        }
        
        // 默认配置
        return new String[]{
            "com.example.config.ElasticsearchDefaultConfig"
        };
    }
}

// 配置类
public class ElasticsearchRestClientConfig {
    @Bean
    public ElasticsearchClient elasticsearchClient() {
        RestClient restClient = RestClient.builder(
            new HttpHost("localhost", 9200)
        ).build();
        
        ElasticsearchTransport transport = new RestClientTransport(
            restClient, new JacksonJsonpMapper()
        );
        
        return new ElasticsearchClient(transport);
    }
}

// 在配置类中使用
@Configuration
@Import(ElasticsearchImportSelector.class)
public class SearchConfig {
}

更复杂的示例：条件导入

public class ConditionalImportSelector implements ImportSelector {
    
    @Override
    public String[] selectImports(AnnotationMetadata metadata) {
        List<String> imports = new ArrayList<>();
        
        // 检查类路径中是否存在某个类
        if (ClassUtils.isPresent("com.example.ThirdPartyClass", null)) {
            imports.add("com.example.config.ThirdPartyConfig");
        }
        
        // 检查系统属性
        if ("true".equals(System.getProperty("enable.cache"))) {
            imports.add("com.example.config.CacheConfig");
        }
        
        // 检查环境变量
        String profile = System.getenv("SPRING_PROFILES_ACTIVE");
        if ("prod".equals(profile)) {
            imports.add("com.example.config.ProdConfig");
        }
        
        return imports.toArray(new String[0]);
    }
}

使用 DeferredImportSelector

如果需要在所有 @Configuration 类处理完之后再进行导入，可以实现 DeferredImportSelector 接口：

public class DeferredElasticsearchImportSelector implements DeferredImportSelector {
    
    @Override
    public String[] selectImports(AnnotationMetadata metadata) {
        // 延迟导入逻辑
        return new String[]{"com.example.config.ElasticsearchConfig"};
    }
}

@EnableXxx 组合注解

@EnableXxx 是一种高层封装的配置方式，它通常组合了 @Import 和其他注解，为用户提供一个简单的开关来启用某个功能模块。

@EnableXxx 可以放在启动类上，也可以放在配置类上。

Spring AOP

Glader — Wed, 08 Oct 2025 11:00:00 GMT

1. Spring AOP 示例注解解释

@Before

在目标方法执行前运行。常用于记录日志、参数校验、权限控制等。当匹配到定义的切点表达式后，Spring 会在目标方法调用前先执行该方法。

@Around

环绕通知，包裹目标方法的整个执行过程。通过 ProceedingJoinPoint.proceed() 显式调用目标方法，可以在调用前后添加自定义逻辑。这是最灵活的通知类型，可以控制方法是否执行、修改参数或处理返回值。

@After

在目标方法执行结束后执行，无论是否发生异常都会触发。类似于 finally 代码块，常用于资源释放、通用日志等场景。

@AfterReturning

在目标方法正常返回后执行，如果目标方法抛出了异常则不会调用。常用于处理返回结果或输出执行成功日志。

@AfterThrowing

当目标方法抛出异常时执行。可用于记录异常信息、发送报警、异常统计等。

@Pointcut

@Pointcut 用于抽取切点表达式，即将原本写在每个注解中的 execution(...) 规则提取出来，单独定义成一个可复用的方法。这样在多个通知中就可以直接通过方法名来引用，避免重复书写表达式，使切面更加清晰易维护。

一般定义方式如下：

@Pointcut("execution(* top.mygld.demo.service.impl..*(..))")
public void serviceMethods() {}

然后在其他通知中直接使用：

@Before("serviceMethods()")
@After("serviceMethods()")

2. Spring AOP 代码示例（使用 @Pointcut 抽取）

package top.mygld.demo.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class TestAspect {

    // 抽取切点表达式，匹配 service.impl 包下所有方法
    @Pointcut("execution(* top.mygld.demo.service.impl..*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void before() {
        log.info("before ....");
    }

    @Around("serviceMethods()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("around ... before ....");
        Object result = joinPoint.proceed();
        log.info("around ... after ....");
        return result;
    }

    @After("serviceMethods()")
    public void after() {
        log.info("after ....");
    }

    @AfterReturning("serviceMethods()")
    public void afterReturning() {
        log.info("afterReturning ....");
    }

    @AfterThrowing("serviceMethods()")
    public void afterThrowing() {
        log.info("afterThrowing ....");
    }

}

这些注解的执行顺序大致为：当方法正常执行时：@Around → @Before → 方法执行 → @AfterReturning → @After → @Around 当方法抛出异常时：@Around → @Before → 方法执行 → @AfterThrowing → @After → @Around

通过这些注解的组合，可以灵活地在不同阶段切入业务逻辑，实现统一的日志、监控或安全控制。而使用 @Pointcut 则让多个通知共享同一套匹配规则，结构更清晰、可维护性更高。

当然如果每个方法要单独配置不同的切入点表达式，就可以分开写，例如:

@AfterReturning("execution(* top.mygld.demo.dao.impl..*(..))")
public void afterReturning(){
    log.info("afterReturning ....");
}

@AfterThrowing("execution(* top.mygld.demo.service.impl..*(..))")
public void afterThrowing(){
    log.info("afterThrowing ....");
}

3. 多个通知的执行顺序

在 Spring AOP 中，多个通知的执行顺序遵循以下规则：

同一切面类中：

默认按照通知类型的自然调用顺序执行： @Around → @Before → 目标方法 → @AfterReturning/@AfterThrowing → @After → @Around
若存在多个同类型通知（例如多个 @Before），则按照方法名的字母顺序执行。
在 @Before 中，方法名字母顺序越小越先执行；在 @After 中，方法名字字母顺序越小越后执行。

不同切面类之间：

默认按类名的字母顺序执行，规则和 1 中相同。
可通过 @Order 注解或实现 Ordered 接口来控制优先级。
@Order 数值越小，优先级越高（即越早执行 @Before，越晚执行 @After）。

例如：

@Aspect
@Component
@Order(5)
public class LogAspect1 {}

@Aspect
@Component
@Order(7)
public class LogAspect2 {}

执行过程概览：

外层切面 @Around
    ↓
  内层切面 @Around
      ↓
    @Before（由外到内）
        ↓
     目标方法执行
        ↓
    @AfterReturning / @AfterThrowing（由内到外）
        ↓
    @After（由内到外）
    ↓
  内层 @Around 结束
↓
外层 @Around 结束

这一机制确保在存在多个切面或通知时，AOP 的执行顺序是可预测且可精确控制的。

4. 切入点表达式

execution

execution 主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：

execution(访问修饰符? 返回值包名.类名.?方法名(方法参数) throws 异常?)

带 ? 的表示可以省略的部分。

1.访问修饰符：可省略（比如：public、protected) 2.包名.类名：可省略（但是不建议） 3.throws异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

*：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的参数，也可以通配包、类、方法名的一部分

execution(* top.*.service.*.update*(*))

.. ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数

execution(* top.mygld..UserService.*(..))

annotation

根据注解去匹配方法，只对添加对应注解的方法有效，例如我们先创建一个注解：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogOperation {
}

然后把注解加在要匹配的方法上：

@LogOperation
@Override
public List<User> findAll() {
    return userDao.findAll();
}

然后在切面类中使用 @annotation(注解引用)：

@Before("@annotation(top.mygld.demo.anno.LogOperation)")
public void before(){
    log.info("before");
}

这样在 idea 中可以点击前面的 m 图标，便可验证匹配成功。

5. 连接点

在 Spring 中用 JoinPoint 抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

对于 @Around 通知，获取连接点信息只能使用 ProceedingJoinPoint。对于其它四种通知，获取连接点信息只能使用 JoinPoint，它是 ProceedingJoinPoint 的父类型。

下面以 @Before 进行演示：

@Before("@annotation(top.mygld.demo.anno.LogOperation)")
public void before(JoinPoint jp){
    log.info("before");
    //1. 获取目标对象
    Object target = jp.getTarget();
    log.info("target: {}", target);
        
    //2. 获取目标类
    String name = target.getClass().getName();
    log.info("name: {}", name);
        
    //3. 获取目标方法
    String methodName = jp.getSignature().getName();
    log.info("methodName: {}", methodName);
        
    //4. 获取目标方法参数
    Object[] args = jp.getArgs();
    log.info("args: {}", args);
}

ProceedingJoinPoint 可以执行目标方法，而 JoinPoint 不可以，前者是后者的子类。

volatile 关键字

Glader — Wed, 01 Oct 2025 16:00:00 GMT

volatile 关键字

现在有如下两个代码：

public class MyThread extends Thread{
    public static int a = 0;
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("线程开始执行，当前 a = " + a);
        a = 1;
        System.out.println("线程执行结束，当前 a = " + a);
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
        while(true){
            if(MyThread.a == 1){
                System.out.println("检测到 a = 1");
                break;
            }
        }
    }
}

那么你认为，如果我运行主类，得到的结果是什么？

根据我们先前的知识，我们肯定会认为，代码运行后，首先创建了 t 线程，然后 t 线程启动，t 线程与主线程同时执行，此时主线程处于无限循环，等待并监听 MyThread 中的共享成员 a 的值，当线程 t 睡眠 1 秒后修改 a 的值变为 1，之后主线程监听到 a 的值变成 1，跳出循环，结束整个程序。也就是说整个程序依次打印输出：

线程开始执行，当前 a = 0
线程开始执行，当前 a = 1
检测到 a = 1

然后程序结束运行。这是我们根据代码思考出来的运行结果，但事实真的是这样吗？我们尝试一下：

我们发现，程序只只输出了线程 t 中的内容，输出完成后程序并没有结束，而是仍然在一直运行，即使我们等了很久很久，也没有停止运行，这是为什么呢？

其实，这种问题，我们称之为多线程的可见性，指的是一个线程对共享变量的修改，其他线程能否立即看到。

可见性的原因产生有很多，当前这种情况主要是因为：现代 CPU 一般会将变量值缓存在寄存器或本地缓存中，而不是每次都从主内存读取。

简单来说，对于 static 修饰的这种共享变量，为了避免多个线程同时直接去修改主内存中的数据而导致一系列的问题，Java 会在读取这个共享变量的时候，先复制一份这个变量的副本到当前线程的工作内存中，如果当前线程不对这个副本的数据进行修改，则不会重新进行获取；只有当前线程对这个副本的数据进行了修改，线程才会去同步这个修改到这个真正的共享变量中去。

所以，上面的问题就很好分析了，这是因为 t 线程首先睡眠了 1 秒，这保证了主线程先去执行了 if(MyThread.a == 1)，这使得主线程获得了一份 a 变量的副本，a 的值是 0。当 t 线程睡眠结束后把 a 改成 1 后，虽然同步到了共享变量里，但主线程因为没有对 a 进行过修改，所以主线程一直没有去重新获取 a 的最新数据，一直都是用的原来 a = 0 的副本，这就导致了主线程的死循环。

那么我们容易想到，我们重新让主线程获取一下 a 的值不就行了？这显然是可以的，那么如何重新获得 a 的值呢？其实有以下几种方法：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.start();
        while(true){
            Thread.sleep(1);
            if(MyThread.a == 1){
                System.out.println("检测到 a = 1");
                break;
            }
        }
    }
}

我们可以在 while 里面加上一句 Thread.sleep(毫秒数)，其中这个 毫秒数 可以任意填写，这不重要，重要的是我们使用了 sleep 这个方法，首先会让主线程进行阻塞，一旦阻塞结束进入就绪态后，就会重新获取共享变量中的数据，结果如下：

这次我们可以看到，程序达到了我们的运行的目的，并且程序也正常结束了。除此之外，我们还有别的方法：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.start();
        while(true){
            synchronized (Main.class) {}
            if(MyThread.a == 1){
                System.out.println("检测到 a = 1");
                break;
            }
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.start();
        while(true){
            Thread.currentThread().resume();
            if(MyThread.a == 1){
                System.out.println("检测到 a = 1");
                break;
            }
        }
    }
}

这两种方法分别是运用了同步代码块运行结束后会重新获取共享变量数据的特点和强制刷新线程后重新获取共享变量的数据特点，且第二种方法已经被淘汰了。

那么有没有直接解决共享变量数据不一致问题的方法？当然有，就是 volatile 关键字，只要共享变量被 volatile 修饰，线程在写入时会将值刷新到主内存，读取时会强制从主内存获取最新值，然后存入线程的工作内存（副本）中使用，而不是一直使用旧的本地副本。

如下：

public class MyThread extends Thread{
    public static volatile int a = 0;
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("线程开始执行，当前 a = " + a);
        a = 1;
        System.out.println("线程执行结束，当前 a = " + a);
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.start();
        while(true){
            if(MyThread.a == 1){
                System.out.println("检测到 a = 1");
                break;
            }
        }
    }
}

可以看到成功达到了要求。

当然，volatile 对于未被 static 修饰的普通成员也有效果，大家可以自行尝试。

实际上，volatile 还可以禁止指令重排，虽然重排对多线程的执行影响远远不如随机性大，但这个作用也需要记一下。

实词与成语积累

Glader — Tue, 30 Sep 2025 09:00:50 GMT

筚路蓝缕：架着简陋的柴车，穿着破烂衣服去开辟山林，形容创业艰苦。
栉风沐雨：形容人经常在外面不顾风雨地辛苦奔波。
艰苦卓绝：坚忍刻苦的精神超过寻常。
餐风宿露：形容旅途或野外生活艰苦的联合式成语。
倒逼：反向推动，逆向促进。
消弭：消除。
对冲：降低。
并列结构两个必须都适合搭配才可以。
融会贯通：各方面的知识或道理融合贯穿起来，全面透彻理解。强调融合起来容易透彻理解。
蔚然成风：形容一种事物逐渐发展盛行，形成一种良好风气。
无出其右：没有能超过他的。
独树一帜：比喻与众不同，独成一家。
三足鼎立：比喻三方面对立的局势。
盛极一时：形容一时特别兴盛和流行。
尔虞我诈：相互欺骗。
万马奔腾：群众性活动声势浩大。
经天纬地：主要形容人，形容人的才能极大，能做非常伟大的事业。
汪洋恣肆：形容文章，言论，书法气势豪放。
纵横捭阖：政治或外交作用手段分化或拉拢。
金戈铁马：战士持枪驰马的英姿。
秣马厉兵：形容喂饱战马，磨快兵器，指做好战斗准备或事前准备工作。
戎马倥偬：形容军务繁忙，置身战场。
制度护佑：固定搭配，制度上保护劳动者。
固定搭配，延误时机，荒废学业。
激浊扬清：冲去污水，让清水上来，比喻清除坏的，发扬好的。
去芜存菁：除去杂质，保留精华。
长处一词无比较之意，优势则有。
相形见绌：与同类事物相比显露出不足。
回天乏术：比喻局势或病情严重到无法挽救的程度。
左支右绌：原指弓射箭的姿势，左手支持，右手屈曲，指力量不足，应付了这方面，那一方面又出了问题。
独木难支：单个主体力量单薄，维持不住全局。
捉襟见肘：整理一下衣襟，就漏出了胳膊肘，形容衣服破烂，生活窘困，也比喻顾此失彼，应付不过来。
力所不逮：能力达不到，心有余而力不足之意。
简捷：简单快捷。
鳞次栉比：强调排列有次序，多用于房屋等整齐的东西，数量多。
星罗棋布：强调分布范围广，应形状整齐与不整齐都能用。
波诡云谲：形容房屋的构造像云彩波浪一样千姿百态，后形容事物变化莫测。
浩如烟海：形容典籍，图书等极为丰富。
空洞：没有内容或内容不切实际。
雅俗共赏：文艺作品既通俗又优美，任何层次的人都能欣赏。
曲高和寡：比喻言论或作品不通俗，能了解的人很少。讽刺意味。
视觉体验是观众感受，视觉呈现是客观表现。
收效甚微：指付出努力但没有什么结果。
山重水复：重重山河阻隔。
卧薪尝胆：在逆境中磨炼意志，刻苦自厉，发愤图强。
厚积薄发：多多积蓄，慢慢放出，形容只有充分准备才能办好事情。
自强不息：努力上进，永不懈怠。
兢兢业业：形容小心谨慎，认真踏实，丝毫不敢懈怠。
步步为营：形容防守严密，行动谨慎。
有的放矢：比喻做事有明确的目的。
举足轻重：所处地位非常重要，一举一动对全局有重大影响。
尾大不掉：比喻属下势力强大，或组织庞大，涣散，难以指挥调度，现比喻机构庞大，指挥不灵。
血本无归：形容经济活动导致本金完全损失。
责无旁贷：自身应承担的责任不可推卸给他人。
洞若观火：清楚的就像看火一样，形容事物透彻分明。
当仁不让：应该做的事情，主动承当，不推辞，不退避。
义不容辞：形容为了正义事业，敢于挺身而出，不做推辞。
弃若敝屣：像扔掉破鞋一样把它抛弃，比喻毫不可惜。
故步自封：比喻守着老一套，不求进步。
束之高阁：把东西捆起来，放在高高的架子上，指弃置不用或置之不理。
一锤定音：比喻做事干脆，说了算数。
标本兼治：对事物的表象和本质方面的问题都进行治理。
开源节流：比喻增加收入，节省开支。
素昧平生：彼此一向不了解，也指与某人从来不认识。
曲意逢迎：违背自己的意愿，想方设法奉承讨好别人。
沽名钓誉：用不正当手段捞取名誉。
检视：检验查看。
首鼠两端：迟疑不决或动摇不定（语出《史记·魏其武安侯列传》。首鼠：踌躇）。
推波助澜：借助外力加剧矛盾
莫衷一是：形容事物的情况或观点多种多样，没有一个一致的结论或意见
春风化雨：比喻良好的教育和适宜的环境。多用来称颂老师和长辈对学生及晚辈潜移默化的教诲。
和风细雨：比喻以和缓态度进行劝说或批评的行为方式
隔靴搔痒：原指隔着靴子抓挠皮肤瘙痒处，现比喻言语或行动未触及本质、未解决关键问题。
扬汤止沸：处理问题仅采取表面措施而未触及根本
洋洋盈耳：形容读书声或讲话声、乐曲声等悦耳动听
舌灿莲花：形容人口才好，口齿伶俐，能言善道，有如莲花般地美妙。
旁征博引：指说话、写文章引用材料作为依据或例证
口若悬河：形容人善于言谈，能言善辩，把话说得很流利，而且滔滔不绝。
无可厚非：没有什么可以过分指责的，表示有错误，但可以原谅，也比喻还有一定的道理，不能全部否定
无可非议：没有什么可以指摘的，表示言行合乎情理，没有错误
无可讳言：没有什么不可以直说的。指可以坦率地说。
匠心独运：独创性地运用精巧的心思。多形容文学、艺术方面的独特构思。
罔顾：不顾及
标新立异：为了显示自己，故意显得与众不同
贪大求全：过分贪图规模大而全面
好大喜功：一心想做大事，立大功
出神入化：形容技艺达到了绝妙的境界，没有体现逼真
栩栩如生：形容文学、艺术作品描摹、刻画人或物的形象十分生动逼真
惟妙惟肖：形容描写或模仿得十分逼真
面面俱到：指各方面都能照顾到
百无一失：形容有充分把握
鞭长莫及：比喻距离太远而无能为力，比喻力量达不到
作壁上观：指双方交战，自己站在壁垒上旁观。后多比喻在一旁观望，不给予帮助
正本清源：从源头上清理、根本上整顿，比喻彻底解决问题
如履薄冰：比喻随时都会发生危险，做事极为小心谨慎
根深蒂固：比喻基础稳固，不容易动摇。有时也指黑恶势力基础牢固，难以铲除。常用于中性或消极语境
交相辉映：各种光亮、色彩等互相映照，多用于形容美好的景象。
休戚与共：形容关系密切，利害相关。
块垒：泛指郁积之物，比喻胸中郁结的愁闷或气愤。
参差向背：一般用来形容 高低不齐、方向不一 的状态
丘壑：指山峰与河谷，也比喻深远的意境。
情愫：只可意会不可言传的心境。
稗官野史：泛称小说及记载不见经传的轶闻琐事的著述。
遗闻轶事：未被广泛知晓却引发人们兴趣的传闻与故事
如火如荼：原比喻军容之盛，现多形容大规模行动气势旺盛、气氛热烈
壁垒：比喻对立的事物和界限。
寅吃卯粮：寅年吃了卯年的粮食。比喻经济困难,入不敷出,预先挪用眼下只能亏空着的财物或还没到手的收入,不顾将来
标杆：比喻榜样
杀鸡取卵：贪图眼前利益，损害长远利益。
大相径庭：着重突出相差很远, 还可表示彼此矛盾很大, 多指事物、举止或言论等区别明显
以讹传讹：把本来就不正确的东西又错误地传开去。结果越传越错。
妄下雌黄：在没有充分了解事实真相之前，我们不能妄下雌黄，随意对他人进行评判。
不着边际：指没有着落。也形容言论空泛，不切实际或离题太远。
乍暖还寒：刚刚变暖，依旧带有几分寒意。形容冬末春初时天气忽冷忽热，冷热不定。
大马金刀：骑着大马，举着金刀。形容豪爽，气派大。也形容说话直率锋利，不留情面。
揶揄：嘲笑，讥讽
不齿：是不愿意提到，表示极端鄙视
不耻：不顾羞耻；不以为有失体面；不以为耻。
侧目：不敢从正面看，斜着眼睛看，形容畏惧而又愤恨。
诟病：意思为侮辱，后引申为指责或嘲骂。
苛求：过严地要求。
噤声：闭口不做声,即禁声。例噤声不语。住口;不许再说下去。
讳言：不敢或不愿说。
悸动：表示因恐惧、紧张或情绪激动引发的心跳加速现象
律动：有规律地行动;有节奏地跳动。
一蹶不振：比喻一遭到挫折就不能再振作起来。
引导与诱导：前者侧重帮助别人思考，后者侧重出于自身利益故意引导别人的思路
胸无城府：形容心胸坦率、坦白，没有什么隐藏。也形容人真诚坦率而没有社会经验。后喻指为人胸怀坦荡，不用心机。
化解风险：固定搭配
汲取经验：固定搭配
难以为继：难以继续下去。
积重难返：长期形成的不良习惯、弊端，不易改变。
辗转：1.也做展转，躺在床上翻来覆去；2.经过许多人的手或经过许多地方。
粉墨登场：原指演员化妆上台演戏。现多比喻坏人经过一番乔装打扮，登上政治舞台（含贬义）或社会生活中演戏
俨然：主要表示庄重、严肃的样子，或者非常地像某物/某人，还可以形容整齐的样子。
已然：表示事情已经成为事实，已经如此。
晴雨表：反映形势的变化。
群策群力：大家共同出主意，共同出力量。指集中并发挥众人的智慧和力量。
从善如流：比喻善于听取别人意见好建议或乐于做好事。
拾人牙慧：拾取人家的一言半语当做自己的话。比喻自己无真知灼见，只是因袭或重复别人的语言或文字。
邯郸学步：比喻模仿不成，反把自己原有的长处失去了。
夸夸其谈：指说话或写文章浮夸、不切实际，浮夸而又滔滔不绝地乱说。
刻舟求剑：比喻拘泥于成例,不知变通。亦比喻思想行动脱离实际,徒劳无获。
耳提面命：谓不但当着面讲,而且是提着他的耳朵向他讲。形容恳切热忱地教诲。今义后谓教诲殷切，要求严格。
望眼欲穿：极目远望，眼珠都快要破了。形容盼望非常急切。也作“眼欲穿”。
望穿秋水：把眼睛都望穿了。形容盼望的程度。秋水：比喻人的眼睛像秋水一样晶莹。
润物无声：引申为通过潜移默化的方式对人施加积极影响，
呆若木鸡：形容呆笨或因恐惧、惊讶而发呆的样子。
钳制：用强力限制，使不能自由行动。
珠联璧合：意思是珍珠联串在一起，美玉结合在一块，比喻杰出的人才或美好的事物聚集在一起的美好样子。
风生水起：风从水面吹过，水面掀起波澜。形容事情做得有生气，蓬勃兴旺。
隐逸：1.避世隐居。2.指隐居的人
飘逸：飘浮轻飞，引申指洒脱自然的气质或艺术作品的清新风格。
孜孜矻矻：形容勤勉不懈的样子。强调不懈怠。
孜孜不倦：勤奋努力，不知疲倦。强调不知疲倦。
皓首穷经：直到年老白头还在钻研经籍。形容勤勉好学，至老不倦。也称白首穷经。
旷日持久：耽搁时日，持续很久。多表示处于胶着状态，空耗时日而无进展。中性词。
绵延不绝：其核心语义指代自然景观连续不断出现的状态，常用于描述山脉、河流等地理景观的连续性特征。
巡回：按一定路线到各处（活动）。
洄游：海洋中一些动物（主要是鱼类）因为产卵、觅食或受季节变化的影响，沿着一定路线有规律地往返迁移。也作回游。
巡游：出外游玩；游逛；巡行察看，来回游弋。
逡巡：有所顾虑而徘徊或不敢前进。
货真价实：形容实实在在，一点不假。
差强人意：勉强使人满意。
彻头彻尾：从头到尾；贯彻始终；完完全全。中性词，可做贬义。
实至名归：有了真正的学识、本领或功业，自然就有声誉。
不折不扣：没有折扣，表示完全、十足的意思。
一脉相通：指事物之间相互关联，犹如一条脉络贯穿下来可以互通。强调事物间的关系。
一脉相承：一个血统或派别世代传承下来。泛指思想、文化、学术等的继承关系。强调继承。
唇齿相依：比喻关系密切，互相依存。
虎视眈眈：像老虎那样凶狠地盯着。形容心怀不善，伺机攫取。
明察秋毫：形容目光敏锐，微小的细节也能捕捉到，也形容洞察一切。
日薄西山：多比喻衰老、病重的人或衰微的事物临近死亡、终结。
百无聊赖：精神上无所寄托，感到什么都没意思。
因势利导：指顺着事情发展的趋势向有利的方向引导。
不卑不亢：既不自卑也不高傲。形容待人的态度和言行恰如其分，自然得体。也形容人说话办事有恰当的分寸。
筚门圭窦：荆条竹苇编的门，穿壁而成、形状如圭（上锐下方）的户；柴门小户。指穷人居住的简陋房舍；也指贫苦人家。
捉襟见肘指力量不够应付不过来，顾此失彼是慌张或忙乱导致。
兰艾同焚：比喻好人坏人同归于尽。
桑枢瓮牖（sang shu weng you）：用桑树做门轴，用瓦罐做窗户。喻义比喻贫苦之家。
钟鸣鼎食：击钟列鼎而食。形容贵族的豪华排场。
岸芷汀兰：岸边的香草，小洲上的兰花，香气浓郁，颜色青葱。岸芷和汀兰都是指水边的美丽的花。岸和汀都是指岸边的意思。形容人像芳兰一样品德高尚，谦让有礼。
粉墙黛瓦：指白色墙壁与青黑色屋瓦，多用以描写传统建筑的外观特征。该词现常见于对徽派建筑及江南民居的景观描述。
空中楼阁：悬在半空中的阁楼。比喻虚幻的事物或脱离实际的空想。
荡气回肠：使意气激荡，情绪回旋。形容音乐、文辞等十分动人。
日新月异：每日每月都出现新的情况，呈现新的面貌。形容新事物不断涌现，面貌不断更新，发展极为迅速。
竿头日上：比喻学业进步很快。
风起云涌：大风起来，乌云涌现。形容气势雄伟。比喻许多事物相继兴起，声势浩大。
如日中天：像太阳正处于天空中央。比喻事物正发展到十分兴盛的阶段。
薪火相传：比喻师生传授，学问和技艺一代代地继承下去。也比喻种族、文化等代代相传。
常备不懈：时刻准备着，毫不忪懈。
自省：自我反省。
仰仗：依靠；依赖。
依仗：凭借、倚靠。
仰仗偏正式、带感激或尊重；依仗偏中性，强调依靠或借助力量，也有轻微贬义。
离弦走板：比喻言行偏离公认的准则。
返本还原：指返回原来的状况。
随俗浮沉：自己没有一定的想法，随着潮流走。
一举两得：指做一件事情同时得到两方面的好处。记住强调得到两方面好处，而不是起到效果。
应运而生：1.后泛指顺应某种时机、条件、需要等而产生。 2.本指顺应天命而产生。
异军突起：比喻与众不同的新派别或势力一下子崛起，独树一帜。
秉笔直书：写史书根据事实记录，不隐讳。
不动声色：在紧急情况下，说话、神态仍跟平时一样没有变化。形容非常镇静。
抽丝剥茧：丝得一根一根地抽,茧得一层一层地剥开。形容对事物分析细致且层次分明。
安身立命：意为生活有着落且精神有寄托，含褒义。
思考与思索：思考是考虑，仅是思维层面，思索是反复思考与探索，有思考后行动的含义。

线程池

Glader — Mon, 29 Sep 2025 07:07:53 GMT

线程池主要核心原理

创建一个池子，池子中是空的
提交任务时，池子会创建新的线程对象，任务执行完毕，线程归还给池子下回再次提交任务时，不需要创建新的线程，直接复用已有的线程即可
但是如果提交任务时，池子中没有空闲线程，也无法创建新的线程，任务就会排队等待

线程池的创建

线程池的创建，主要使用 Executors 工具类中的两个方法，一个是 newCachedThreadPool，一个是 newFixedThreadPool，前者是用来创建一个无长度上限的线程池，后者是用来创建一个有长度上限的线程池，他们都会返回一个 ExecutorService 对象，具体如下：

ExecutorService e1 = Executors.newCachedThreadPool(); //创建一个无上限的线程池
ExecutorService e2 = Executors.newFixedThreadPool(3); //创建一个最多可以容纳5个线程的线程池

向线程池中提交任务

接下来我们测试线程池是否真的能达到像它所说的那样的效果，提交任务常使用的方法是 submit 或 execute 方法，通常通过 execute(Runnable) 提交任务仅执行而不返回结果，而 submit(Runnable) 会返回 Future，可用于获取执行状态或异常信息。

我们做如下测试：

public class Main {
    public static void main(String[] args){
        //创建线程
        ExecutorService e1 = Executors.newCachedThreadPool(); //创建一个无上限的线程池
        //ExecutorService e2 = Executors.newFixedThreadPool(5); //创建一个最多可以容纳5个线程的线程池
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 在运行。");
            }
        };
        e1.submit(r);
    }
}

如上，线程已经在执行了，可以发现程序并没有结束，因此在后面我们要在线程池不需要使用的时候进行销毁，但一般线程池是不需要关闭的。

我们接下来多测试几个线程：

public class Main {
    public static void main(String[] args){
        //创建线程
        ExecutorService e1 = Executors.newCachedThreadPool(); //创建一个无上限的线程池
        //ExecutorService e2 = Executors.newFixedThreadPool(5); //创建一个最多可以容纳5个线程的线程池
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 在运行。");
            }
        };
        e1.submit(r);
        e1.submit(r);
        e1.submit(r);
        e1.submit(r);
        e1.submit(r);
    }
}

如图，我们添加了 5 个任务。为了进一步测试，我们在添加人物之前进行一小段时间的睡眠，验证已经执行完的线程池里的线程对象能不能得到复用，如下：

package top.mygld.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        //创建线程
        ExecutorService e1 = Executors.newCachedThreadPool(); //创建一个无上限的线程池
        //ExecutorService e2 = Executors.newFixedThreadPool(5); //创建一个最多可以容纳5个线程的线程池
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 在运行。");
            }
        };
        e1.submit(r);
        Thread.sleep(500);
        e1.submit(r);
        Thread.sleep(500);
        e1.submit(r);
        Thread.sleep(500);
        e1.submit(r);
        Thread.sleep(500);
        e1.submit(r);
    }
}

如上，线程 1 执行完毕后，被多次复用。

接下来再测试一下 newFixedThreadPool:

package top.mygld.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        //创建线程
        //ExecutorService e1 = Executors.newCachedThreadPool(); //创建一个无上限的线程池
        ExecutorService e2 = Executors.newFixedThreadPool(3); //创建一个最多可以容纳5个线程的线程池
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 在运行。");
            }
        };
        e2.submit(r);
        e2.submit(r);
        e2.submit(r);
        e2.submit(r);
        e2.submit(r);
    }
}

非常完美，如上图，线程最多只能被使用 3 个。

线程池的销毁

已经没有用的线程池，只需要使用 shutdown 方法销毁即可，这里不再演示。

自定义线程池

除了使用 Executors 提供的工厂方法，我们也可以通过 ThreadPoolExecutor 来创建一个更加灵活、可控的线程池。它的构造方法如下：

public ThreadPoolExecutor(
        int corePoolSize,        // 核心线程数
        int maximumPoolSize,     // 最大线程数
        long keepAliveTime,      // 非核心线程的最大存活时间
        TimeUnit unit,           // 存活时间的单位
        BlockingQueue<Runnable> workQueue, // 任务队列
        ThreadFactory threadFactory,       // 线程工厂，用于创建新线程
        RejectedExecutionHandler handler   // 拒绝策略
)

参数含义

corePoolSize 核心线程数，线程池会始终保持的线程数量，即使这些线程处于空闲状态。
maximumPoolSize 最大线程数，当任务过多时，线程池最多能扩展到的线程数量。
keepAliveTime & unit 非核心线程（超过 corePoolSize 的部分）在空闲时的存活时间，超时后会被回收。
workQueue 存放等待执行任务的阻塞队列。常见选择：
- ArrayBlockingQueue（有界队列，数组实现）
- LinkedBlockingQueue（无界队列，链表实现）
- SynchronousQueue（直接提交任务，不存储）
threadFactory 定义线程的创建方式，比如设置线程名、是否为守护线程等。默认工厂即可。
handler 当线程池和队列都满了时的拒绝策略：
- AbortPolicy（默认，抛异常）
- CallerRunsPolicy（由调用者线程执行任务）
- DiscardPolicy（直接丢弃任务）
- DiscardOldestPolicy（丢弃队列中最老的任务）

示例：自定义线程池

package top.mygld.demo;

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) {
        // 自定义线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                2,                      // 核心线程数
                5,                      // 最大线程数
                10, TimeUnit.SECONDS,   // 非核心线程空闲存活时间
                new ArrayBlockingQueue<>(3),  // 有界任务队列，最多存 3 个任务
                Executors.defaultThreadFactory(), // 默认线程工厂
                new ThreadPoolExecutor.AbortPolicy() // 拒绝策略：直接抛异常
        );

        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " 在执行任务");
            try {
                Thread.sleep(2000); // 模拟耗时任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        // 提交 10 个任务，观察线程池如何调度
        for (int i = 1; i <= 10; i++) {
            try {
                pool.execute(task);
            } catch (RejectedExecutionException e) {
                System.out.println("任务 " + i + " 被拒绝了！");
            }
        }

        pool.shutdown(); // 关闭线程池
    }
}

执行流程说明

前两个任务会直接启动 核心线程 处理。
接下来的三个任务会放入 任务队列。
当队列满了之后，线程池会继续创建新线程（最多到 maximumPoolSize=5）。
如果线程池和队列都满了，第 9、10 个任务会触发 拒绝策略，直接抛异常并提示被拒绝。

最大并行数

最大并行数的含义

CPU 层面：对于计算密集型任务，最大并行数通常受 CPU 核心数限制（包括超线程）。比如你的 CPU 有 8 核（16 线程），理论上同时执行 16 个计算任务是最优的。
线程池层面：对于 Java 中的 ExecutorService 或 ThreadPoolExecutor，最大并行数就是线程池 maximumPoolSize 的值。线程池会根据这个值控制同时活跃线程的数量。
操作系统限制： JVM 的线程数也受操作系统限制，通常线程数太多会导致内存溢出或调度开销过大。

获取最大并行数可以通过下述代码获取：

public class Main {
    public static void main(String[] args) {
        int i = Runtime.getRuntime().availableProcessors();
        System.out.println(i);
    }
}

线程池多大合适

CPU 密集型运算

最大并行数 + 1

I/O 密集型运算

$最大并行数 * 期望 CPU 利用率 * \frac{总时间(CPU计算时间+等待时间)}{CPU计算时间}$

面试八股文重点

volatile
JMM
悲观锁、乐观锁、CAS
原子性
并发工具类

这些内容是面试经常会提问的点，后期再做整理。

Java 的动态代理

Glader — Sun, 14 Sep 2025 05:40:00 GMT

1. 概念

所谓 Java 的动态代理，我个人的理解其实就是通过反射机制，创建一个接口的临时实现类，并返回一个实例化对象。

注意：

只能代理接口：JDK动态代理只能为接口创建代理，不能为具体类创建代理
反射调用：每次方法调用都会通过反射机制转发到 InvocationHandler
临时类：代理类是运行时生成的，存在于内存中，不会持久化到磁盘

通俗来讲，比如坤坤是一位大明星，要开演唱会，坤坤只负责唱歌和跳舞，那么布置舞台这些事情，肯定不是坤坤自己来做，所以就需要代理人来做这些。

于是我们可以这样做：

package top.mygld.demo.test;

public class KunKun {
    public String sing(String name){
        System.out.println("坤坤唱了：" + name);
        return "坤坤唱完了";
    }
    public void dance(String name){
        System.out.println("坤坤跳了：" + name + "舞蹈！");
    }
}

package top.mygld.demo.test;

public class ProxyPeople {
    KunKun kunKun = new KunKun();
    public String sing(String name){
        System.out.println("代理人布置场地。" );
        System.out.println("代理人布置场地完成。" );
        return kunKun.sing(name);
    }
    public void dance(String name){
        System.out.println("坤坤跳了：" + name + "舞蹈！");
        kunKun.dance(name);
    }
}

然后我们只需要在主类中运行:

ProxyPeople proxyPeople = new ProxyPeople();
proxyPeople.sing("只因你太美");
proxyPeople.dance("芭蕾舞");

即可。

但是这样写显然不够优雅，于是你想到了用多态的方法：

package top.mygld.demo.test;

public interface People {
    String sing(String name);
    void dance(String name);
}

package top.mygld.demo.test;

public class KunKun implements People{
    @Override
    public String sing(String name){
        System.out.println("坤坤唱了：" + name);
        return "坤坤唱完了";
    }
    @Override
    public void dance(String name){
        System.out.println("坤坤跳了：" + name + "舞蹈！");
    }
}

package top.mygld.demo.test;

public class ProxyPeople implements People{
    KunKun kunKun = new KunKun();
    @Override
    public String sing(String name){
        System.out.println("代理人布置场地。" );
        System.out.println("代理人布置场地完成。" );
        return kunKun.sing(name);
    }
    @Override
    public void dance(String name){
        System.out.println("代理人布置场地。" );
        System.out.println("代理人布置场地完成。" );
        kunKun.dance(name);
    }
}

这样就优雅了许多，但是还不够，这样的话我们需要单独去写一个实现类 ProxyPeople，显得有些多余，因为我们的语句比较简单，那有没有不用去单独写一个实现类的方法？动态代理就是做这个的。

2. Proxy 类

在 java.lang.reflect 包下，有一个 Proxy 类，它有一个 newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 方法，可以临时生成实现类并返回一个对象。

其中，newProxyInstance 第一个参数是一个类加载器，第二个是一个接口的 Class 数组，第三个参数是用来指定代理对象要做什么事情，例如：

package top.mygld.demo.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyUtil {
    public static People createProxyPeople(KunKun kunKun) {
        return (People) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
                new Class[]{People.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                        System.out.println("代理人布置场地。" );
                        System.out.println("代理人布置场地完成。" );
                        if (method.getName().equals("sing")) {
                            return method.invoke(kunKun, objects);
                        }
                        else{
                            method.invoke(kunKun,objects);
                            return null;
                        }
                    }
                });
    }
}

然后 KunKun 的类不需要改动，直接在主类中运行：

People proxyPeople = ProxyUtil.createProxyPeople(new KunKun());
System.out.println(proxyPeople.sing("只因你太美"));
proxyPeople.dance("芭蕾舞");

这里做一个补充，为什么 newProxyInstance 第二个参数是一个数组呢？因为一个代理对象可以同时实现多个接口，例如：

假设设你有多个接口：

interface UserService {
    void saveUser(String name);
}

interface LogService {
    void log(String message);
}

interface CacheService {
    void cache(String key, Object value);
}

你可以创建一个代理对象，同时实现这三个接口：

InvocationHandler handler = new InvocationHandler() {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用方法: " + method.getName());
        
        // 根据方法名或接口类型进行不同处理
        if (method.getName().equals("saveUser")) {
            System.out.println("保存用户: " + args[0]);
        } else if (method.getName().equals("log")) {
            System.out.println("记录日志: " + args[0]);
        } else if (method.getName().equals("cache")) {
            System.out.println("缓存数据: " + args[0] + " -> " + args[1]);
        }
        
        return null;
    }
};

// 同时实现多个接口
Object proxy = Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class, LogService.class, CacheService.class},  // 多个接口
    handler
);

// 可以转换成任意一个接口使用
UserService userService = (UserService) proxy;
LogService logService = (LogService) proxy;
CacheService cacheService = (CacheService) proxy;

userService.saveUser("张三");
logService.log("操作完成");
cacheService.cache("user:1", "张三");

当你传入多个接口时，JVM会生成一个同时实现所有接口的代理类：

// 动态生成的代理类会实现所有接口
public final class $Proxy0 extends Proxy 
    implements UserService, LogService, CacheService {
    
    // 实现UserService的方法
    public void saveUser(String name) throws Throwable {
        super.h.invoke(this, saveUserMethod, new Object[]{name});
    }
    
    // 实现LogService的方法
    public void log(String message) throws Throwable {
        super.h.invoke(this, logMethod, new Object[]{message});
    }
    
    // 实现CacheService的方法
    public void cache(String key, Object value) throws Throwable {
        super.h.invoke(this, cacheMethod, new Object[]{key, value});
    }
}

3. 实际使用场景

这种设计在框架中很常见，比如：

Spring AOP：代理对象需要实现原始接口 + 额外的增强接口
事务管理：业务接口 + 事务管理接口
缓存代理：业务接口 + 缓存管理接口

所以数组设计是为了支持多接口实现的灵活性，即使你只传入一个接口，也要用数组的形式 new Class[]{YourInterface.class}。

这样就可以了，以上就是 Java 动态代理的相关知识点。

Java 反射复习

Glader — Thu, 11 Sep 2025 12:03:00 GMT

1. Java 反射的概念

Java 的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为 Java 语言的反射机制。反射被视为动态语言的关键。

2. 反射 API

(1) 反射中常用的类

java.lang.Class：Java 中类也可以看作一种特殊的对象，Class 便表示的是类的对象。

java.lang.reflect.Constructor：类的构造器。

java.lang.reflect.Field：类的成员变量。

java.lang.reflect.Method：类的成员方法。

(2) 获取类对象的三种方法

现在我在 top.mygld.demo.pojo 包下创建 User 类如下，方便接下来的演示：

package top.mygld.demo.pojo;
public class User {
    private String name;
    private int age;
}

然后接下来在主类中演示类对象的获取。

i）直接通过 类名.class 获取，例如：

Class c = User.class;   //假设User是我们封装好的类

ii）通过 Class.forName("类全名") 获取，例如：

Class c = Class.forName("top.mygld.demo.pojo.User");

iii）通过 具体对象.getClass() 获取，例如：

User user = new User("小明",30);
Class c = user.getClass();

通过上述三种方法获得的对象 c 便是 User 类所对应的类对象，接下来我们可以通过调用 c 中的一些方法，来获取 User 类中的内部信息，进而对内部信息进行操控，这便是 Java 的反射。

(3) 类对象的基本信息

在第（2）步中，我们获取到了类对象 c，那么如果我们直接打印输出 c 会得到什么？我们尝试一下。

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;
public class ReflectionDemo {
    public static void main(String[] args){
        Class c = User.class;
        System.out.println(c);
    }
}

如上图，是输出了 class + 类全名。这说明 Class 类重写了 toString 方法。

此外，Class 类还提供了两个主要的成员方法：getName 和 getSimpleName，分别用来获得类对象的类全名和类简名效果如下。

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;
public class ReflectionDemo {
    public static void main(String[] args){
        Class c = User.class;
        System.out.println(c.getName());
        System.out.println(c.getSimpleName());
    }
}

(4) 通过反射获得目标类的构造器信息

通过反射机制，我们可以获得目标类的构造器（Constuctor）信息，如构造器的个数、构造器的参数情况（无参构造器、有参构造器）、有参构造器的参数个数、参数类型、访问修饰符等等。

为了便于测试，我接下来对 User 类进行改写，如下：

package top.mygld.demo.pojo;
public class User {
    private String name;
    private int age;

    public User(){}

    private User(String name){
        this.name = name;
    }

    protected User(int age){
        this.age = age;
    }

    public User(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

使用 Class 中的 getDeclaredConstructors() 方法可以获得目标类中的所有构造器的构造器对象数组，使用 Constructor 中的 getParameterCount() 可以获得对应构造器中的参数个数，具体如下：

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;

import java.lang.reflect.Constructor;

public class ReflectionDemo {
    public static void main(String[] args){
        Class c = User.class;
        Constructor[] cons = c.getDeclaredConstructors();
        System.out.println("共有 " + cons.length + " 个构造器") ;
        for(Constructor con : cons){
            System.out.println(con + " 参数个数：" + con.getParameterCount());
        }
    }
}

当然如果只想获得 public 修饰的构造器，使用 Class 中的 getConstructors() 方法即可，这里将不再演示。

那么有一个问题，如果我想获得单个指定的构造器对象，该如何获取呢？其实只需要调用 getDeclaredConstructor 的重载方法 getDeclaredConstructor(Class<?>... parameterTypes) 即可，其中 parameterTypes 只需要传入 类名.class 或 基本数据类型.class 即可，具体如下：

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;

public class ReflectionDemo {
    public static void main(String[] args) throws NoSuchMethodException {
        Class c = User.class;
        System.out.println(c.getDeclaredConstructor(int.class));
        System.out.println(c.getDeclaredConstructor(String.class, int.class));
    }
}

当然，如果想获得某个 public 修饰的构造器，也可以使用 Class 中的 getConstructor(Class<?>... parameterTypes) 来获得，其中它的参数可以为空，表示获得 public 修饰的无参构造。

注意：getDeclaredConstructors 和getDeclaredConstructor 不受访问修饰符限制，getConstructors 和getConstructor 只能获取 public 修饰的构造器。

(5) 通过反射创建目标类实例对象

已经获得到了目标类的构造器的对象，此时有人会有疑问了，用这个构造器对象我们能做什么？能做的其实非常多。

首先，通过调用 Constructor 中的 newInstance(Object... initargs) 方法，我们可以实例化一个目标类的对象，例如：

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;
import java.lang.reflect.Constructor;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception{
        Class c = User.class;
        Constructor con = c.getDeclaredConstructor(String.class,int.class);
        User kun = (User) con.newInstance("坤坤", 18);
        System.out.println(kun);
    }
}

那有人要问了，这不脱裤子放屁多此一举吗？我直接 new User("坤坤",18) 不就行了？还需要这么麻烦吗？

那接下来我要说点有意思的，我们观察到，在 User 类中，有一个 private 修饰的的构造方法，我们正常去执行如下代码一定会报错：

User user = new User("坤坤");

这是因为 private User(String name) 是私有的，不可以被外部直接访问，但是，通过反射我们可以临时绕过访问权限，使得能够调用这个构造器。调用 Constructor 中的 setAccessible(boolean) 即可，具体如下：

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;
import java.lang.reflect.Constructor;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception{
        Class c = User.class;
        Constructor con = c.getDeclaredConstructor(String.class);
        con.setAccessible(true);
        System.out.println(con.newInstance("坤坤"));
    }
}

注意，使用 con.setAccessible(true); 仅仅是临时修改了访问权限，并不会对目标类造成影响，该构造器仍然是 private 的。

(6) 通过反射获取目标类成员变量

既然通过反射能获得目标类的构造方法信息，那么肯定也能获取目标类的成员变量（Field）信息。

其实，类比于构造器的获取，成员变量的获取基本类似：

通过调用 Field 中的 getDeclaredFields() 方法可以获得目标类下所有的成员变量信息；调用 Field 中的 getDeclaredField(String name) 可以获得成员变量中变量名为 name 的指定变量；通过调用 Field 中的 getFields() 方法可以获得目标类下所有的 public 修饰的成员变量信息；调用 Field 中的 getField(String name) 可以获得 public 修饰的成员变量中变量名为 name 的指定变量，具体如下：

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception{
        Class c = User.class;
        System.out.println(c.getConstructor());

        Field[] fields = c.getDeclaredFields();
        for (Field f : fields) {
            System.out.println(f);
        }

        Field name = c.getDeclaredField("name");
        System.out.println(name);

        System.out.println(c.getFields().length);
        //因为User中未设置public修饰的成员变量，这里不再演示getField()方法，大家可以自行尝试
    }
}

注意：getDeclaredField 和 getField 方法参数列表均不能为空。

(7) 通过反射修改和获取目标类对象的成员变量的值

在第(6)步中，我们获得了目标类成员变量信息，那么我们能否可以根据这个成员变量对象，去修改或获取目标类对象的成员变量的值？答案是可以的，我们只需要使用 Field 中的 set(Object obj, Object value) 和 get(Object obj) 方法即可，具体如下（由于 User 中成员变量都是 private 的，不能直接修改，需要先通过调用 Field 中的 setAccessible(true) 来临时绕过访问权限）：

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;
import java.lang.reflect.Field;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception{
        Class c = User.class;
        Field name = c.getDeclaredField("name");
        name.setAccessible(true);

        User user = new User("坤坤",18);
        System.out.println(user);

        name.set(user,"鸽鸽");
        System.out.println(user);
        System.out.println(name.get(user));
    }
}

(9) 通过反射获取目标类成员方法

如果你详细看了上述 8 个部分内容，你应该能够猜到，获取成员方法（Method）信息也主要有四个方法：

分别是 Method 中的 getDeclaredMethods、getDeclaredMethod、getMethods 和 getMethod，他们的功能与注意事项应该不言而喻了吧，为了方便演示，我先在 User 中添加若干方法，如下：

package top.mygld.demo.pojo;
public class User {
    private String name;
    private int age;

    public User(){}

    private User(String name){
        this.name = name;
    }

    protected User(int age){
        this.age = age;
    }

    public User(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private void hello(){
        System.out.println("你好，User");
    }
}

然后我再在主类中测试：

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception{
        Class c = User.class;
        Method[] declaredMethods = c.getDeclaredMethods();
        for(Method m : declaredMethods){
            System.out.println(m);
        }

        System.out.println(c.getMethod("setName", String.class));

        Method[] methods = c.getMethods();
        for(Method m : methods){
            System.out.println(m);
        }

        System.out.println(c.getDeclaredMethod("hello"));

    }
}

注意：getDeclaredMethod 和 getMethod 中，第一个参数是成员方法的名字，后面从第二个参数开始，表示这个成员方法的的参数列表的参数类型，如果没有参数列表，则上述方法只写第一个参数即可。

(10) 通过反射调用目标类对象的成员方法

通过反射，我们也可以调用 Method 中的 invoke(目标类对象,参数列表) 方法来调用目标类对象中的成员方法，具体如下：

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;
import java.lang.reflect.Method;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception{
        Class c = User.class;
        Method setName = c.getMethod("setName", String.class);

        User user = (User) c.newInstance();
        System.out.println(user);

        setName.invoke(user, "坤坤");
        System.out.println(user);
    }
}

3. 反射的作用

i) 基本作用：可以得到一个类的全部成分然后操作。（在上述步骤中已经体现）

ii) 可以破坏封装性。（因为可以修改类内部的成员的访问权限，因此会破坏类的封装性）

iii) 可以绕过泛型的约束，例如下述代码的执行结果：

package top.mygld.demo.test;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        ArrayList<String> a = new ArrayList<>();
        a.add("hello");
        Class c = a.getClass();
        Method m = c.getDeclaredMethod("add", Object.class);
        m.invoke(a, 123);
        System.out.println(a);
    }
}

4. 总结

综上，Java 反射的核心知识点主要包括四个方面：类对象（获取 Class 对象及其信息）、构造器（获取和操作类的构造方法）、成员变量（获取和操作类的字段）、以及成员方法（获取和调用类的方法）。

很多框架都是通过反射的方法实现的，例如 Spring Boot。

通过反射，我们还可以自主设计一些框架，假如我要获取任意类的成员变量信息，我可以写一个比较简单的框架函数，如下：

package top.mygld.demo.test;
import top.mygld.demo.pojo.User;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        User user = new User("坤坤",18);
        getInformation(user);
    }
    public static void getInformation(Object object) throws IllegalAccessException {
        Class c = object.getClass();
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            System.out.println(field.getName() + ":" + field.get(object));
        }
    }
}

当然，上述只是举了个例子，这个函数代码可能对某些其他的类不适用。

”反射“为什么叫”反射“，我认为，正常调用某个对象的成员属性或成员方法，都是 对象.成员 的格式，而在反射中的格式基本都是 成员.方法(对象) 的形式，和正常的形式是反着的，所以叫 反射。当然这只是我的一个个人理解，置于为啥真的叫”反射“，感兴趣的可以去查一下资料了~

人工智能大判官

Glader — Mon, 19 May 2025 07:31:53 GMT

写了个纯基于前端的简陋 AI 判官小游戏，一个沙雕小游戏：游戏链接

仓促完成的毕设

Glader — Fri, 28 Mar 2025 15:31:53 GMT

因为要交本科毕业论文初稿了，仓促完成了这个基于 Vue3 + SpringBoot 的智能问卷系统，欢迎大家测试。

AI 接口用的硅基流动邀请赠送的余额，可能随时会用完，如果 AI 生成不能用了，多半是没余额了。

因为写的比较仓促，bug比较多，~~这是正常的...~~

测试网站：毕设测试网站

使用 Netlify 和 Astro 构建静态博客

Glader — Sun, 26 Jan 2025 17:07:51 GMT

1.注册 NetLify

首先打开 NetLify 的官方网站点击此处跳转

选择一种方式注册登录即可，这里我选择 GitHub 登录，即第一种方法

然后我们授权使用 GitHub 登录

之后会弹出填写信息的一些页面，里面的内容依次代表姓名、计划、角色等内容，我们大致写写，并且勾选一下标签即可

如果我们在How are you planning to use Netlify?中选择了Personal选项，即个人项目选项，在最后会让我们起一个项目名称，之后可以用于URL中作为标识，这里我们可以根据自己的个性化需求自行设计。

完成后，点击Continue to deploy，会弹出让我们设置第一个项目，这里我们点击Skip this step for now，即跳过该步骤。

用过上述步骤，我们注册 NetLify 成功。

2.安装 Astro

首先我们访问 Astro 的官方文档网站，点击此处跳转

然后我们点击“安装 Astro”

在新的页面中，显示了有三个前提条件：

根据文档的前提条件表示，我们需要 Node.js 环境，一个文本编辑器和终端。

Node.js 环境的安装配置可以参考下述教程：

Node.js 安装教程，点击跳转

后两者直接使用系统自带的即可，考虑到更舒适的写代码的环境，我们可以下载使用 VSCode 这款文本编辑器，下载与安装方式可以参考如下教程：

VSCode安装教程，点击跳转

上述前提条件都完成后，我们正式开始 Astro 的安装。

我们首先新建一个空白文件夹

紧接着在地址栏处输入cmd并点击回车

在弹出的终端中，输入下述指令，并且在弹出的提示中输入y：

npm create astro@latest

等待一段时间后，会提示选择新项目的目录，我们可以输入./glader-blog，表示在当前目录下创建一个新的文件夹glader-blog，将项目存在这里。

在之后我们连点 3 次回车，进入等待项目初始化

当提示下述内容时，表示项目已经初始化结束，此时我们的文件夹下就会多出了glader-blog目录，我们的项目就存储在其中：

然后我们进入创建好的项目，并使用npm install安装依赖，如下：

Astro 内置了服务器，等待安装完成后，我们运行指令npm run dev即可运行服务器。

我们在浏览器中输入http://localhost:4321即可访问预览。

在浏览器中输入该网址运行后结果如下，这表示 Astro 项目成功安装。

3.熟悉 Astro 的编写环境

为了我们方便地编写代码，我们使用VSCode这款文本编辑器，首先我们打开VSCode,并使用VSCode打开刚才创建好的新项目，即glader-blog，如下，此时右下角会弹出安装 Astro 的扩展，我们点击安装：

如果没有弹出该提示，我们可以点击扩展图标，手中搜索安装：

安装完成后，我们返回项目目录，在左下角会发现多了一个npm脚本选项，我们直接点击里面的内容就可以帮助我们运行 npm 脚本，例如里面有一个dev选项，点击这个就相当于刚才在项目目录下运行了npm run dev。

可以看到，效果和刚才直接在小黑窗中输入命令相同。

4.编写简易博客

在项目目录下的src/pages/下，有一个index.astro文件，这个是网页的主页

我们可以尝试将这个文件中的代码全部删除，然后在这个文件中重新编写一段代码，代码如下:

<html lang="zh-cn">
  <head>
    <meta charset="utf-8" />
    <link rel="icon" type ="image/svg+xml" href="/favicon.svg" />
    <meta name="viewport" content="width=device-width" />
    <meta name="generator" content = {Astro.generator} >
    <title>Astro</title>
  </head>
  <body>
    <h1>Astro</h1>
  </body>
</html>

此时我们在浏览器中可以发现，网页中的内容变成了我们代码中的内容了

Astro 本质上是一个静态网站生成器，他可以兼容 html 的原生代码，为了方便演示，在这里，我们先粗糙的写一个博客的主界面，代码如下所示：

<!DOCTYPE html>
<html lang="zh">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <link rel="stylesheet" href="/styles.css">
  </head>
  <body>
    <!-- 导航栏 -->
    <header>
      <nav>
        <ul>
          <li><a href="/">首页</a></li>
          <li><a href="/about">关于我</a></li>
          <li><a href="/posts">博客文章</a></li>
          <li><a href="/contact">联系我们</a></li>
        </ul>
      </nav>
    </header>

    <!-- 主内容区 -->
    <main>
      <section class="intro">
        <h1>欢迎来到我的博客！</h1>
        <p>这里记录了我对编程、技术和生活的一些思考与分享。</p>
      </section>

      <!-- 最新文章列表 -->
      <section class="posts">
        <h2>最新文章</h2>
        <ul>
          <li><a href="">测试文章1</a></li>
        </ul>
      </section>
    </main>

    <!-- 底部 -->
    <footer>
      <p>&copy; 2025 我的博客. All Rights Reserved.</p>
    </footer>
  </body>
</html>

此时假如我们要写一篇MarkDown格式的博客，我们在src/pages/下，新建一个文件夹posts用来存放我们的文章。然后我们在src/pages/posts/下新建post-1.md。

# 我的第一篇博客文章

 发表于：2022-07-01

 欢迎来到我学习关于 Astro 的新博客！在这里，我将分享我建立新网站的学习历程。

 ## 我做了什么

 1. **安装 Astro**：首先，我创建了一个新的 Astro 项目并设置好了我的在线账号。

 2. **制作页面**：然后我学习了如何通过创建新的 `.astro` 文件并将它们保存在 `src/pages/` 文件夹里来制作页面。

 3. **发表博客文章**：这是我的第一篇博客文章！我现在有用 Astro 编写的页面和用 Markdown 写的文章了！

 ## 下一步计划

 我将完成 Astro 教程，然后继续编写更多内容。关注我以获取更多信息。

写完博客后，我们在index.astro中，给“测试文章1”标签添加超链接，链接到刚才的md文章，如下：

注意：不要加.md，直接写文件名即可，即不要写成/posts/post-1.md

此时在网页中我们点击测试文章1，即可显示我们的博客内容：

更多语法、组件等相关内容，读者可以自行到Astro开发文档官网学习。

5.上传项目到 GitHub

上传项目到 GitHub，首先要先下载安装Git，安装方法可以参考下述教程：

Git安装教程

安装完 Git 后，我们要给 VSCode 配置 Git，并将刚才写的项目上传到 GitHub 仓库，具体教程可参考如下教程：

VSCode 配置 Git，并上传代码至 GitHub 教程

然后我们点击发布分支，然后再点击上传至私有仓库即可。

上传完成后，我们在GitHub上就拥有了这样的一个私有仓库

此外，我们我们要改动我们的代码，我们也可以在这里提交修改

至此，我们就可以在本地编辑我们的博客，然后使用 Git 将我们的代码实时保存到 GitHub 上。

6.将代码托管到 NetLify

我们再次打开 NetLify 的官网，登录好我们刚才注册的账号，我们点击Import from Git，如下：

然后选择 GitHub：

在弹出来的新窗口中授权本次操作，并选择要上传的仓库：

然后点击Install进行安装，之后会弹出输入密码的提示，输入 GitHub 的密码点击确定即可。

此时如下图所示，已上传成功，我们点击该仓库进行配置：

我们只需要在 Site name 中起个名字就行，这个名字以后会放在我们要访问的域名中去，其他的空着不写，直接点击Deploy即可。

然后我们只需等待部署即可，这个可能需要几分钟的时间。

部署完成后，结果如下：

此时我们访问网站https://glader.netlify.app即可显示我们的博客。

至此，我们的博客部署完成。

此外，在 GitHub 中，很多人已经基于 Astro 框架开发了很多便于操作的博客主题，我们上述操作仅仅是学习 Astro 的基本使用方法，在实际博客的制作中，我们可以去 GitHub 中选择自己心仪的博客主题作为模板部署即可。

域名迁移

Glader — Mon, 13 Jan 2025 02:34:50 GMT

将博客迁移到了：blog.mygld.top。

整理 SpringBoot 知识点（二）

Glader — Wed, 01 Jan 2025 18:10:10 GMT

yml 的配置

除了（一）中总结的内容，yml 还有其他的语法，例如可以在 yml 中继续参数引用，例如以下这个例子：

name: Bob
person:
  name: ${name}
  age: 20

@Value("${person.name}")
private String name;
@Value("${person.age}")
private int age;

@Test
void test2(){
	System.out.println(name + ":" + age);
}

运行后输出结果为 Bob:20。

这说明在 yml 中还可以继续参数引用，person.name 赋值为了 name 的值，也就是 Bob。

另外，yml 中的数组也可以写成行内数组的格式，例如：

list: [hello,world]

yml 中还有一个重要的知识点，就是纯量。比如现在在 yml 中定义如下参数：

msg1: 'hello\n world' #不会识别转义字符，会原样输出
msg2: "hello\n world" #会识别转义字符

上述参数的唯一区别就是 msg1 使用的是单引号，而 msg2 使用的是双引号，我们编写如下代码进行测试：

@Value("${msg1}")
private String msg1;
@Value("${msg2}")
private String msg2;

@Test
void test3(){
	System.out.println(msg1);
	System.out.println(msg2);
}

输出结果如下：

hello\n world
hello 
 world

这说明，如果我们使用单引号引用字符串，那么不会识别转义字符，会原样输出；如果使用双引号，则会识别转义字符。

那么思考一下，如果定义：

msg3: hello\n world

会有什么效果？经过本人实验，效果其实加单引号效果一样，不会识别转义字符。

另外，再补充一点，即使我们不使用 @Value 和 @ConfigurationProperties 这两个注解，也有别的办法在代码中随时获得配置中的参数，我们可以使用 Environment 这个类中的 getProperty(参数名) 即可，例如：

@Autowired
private Environment env; //import org.springframework.core.env.Environment;

@Test
void test4(){
	System.out.println(env.getProperty("msg1"));
}

参数名直接用字符串形式就可以，不用再加 $ 或 {} 了。
Environment 导的是 org.springframework.core.env.Environment; 不要导入错了。

Profile 的使用

我们在开发 SpringBoot 应用时，通常同一套程序会被安装到不同环境，比如:开发、测试、生产等。其中数据库地址、服务器端口等等配置都不同，如果每次打包时，都要修改配置文件，那么非常麻烦。profile 功能就是来进行动态配置切换的。

多 Profile 文件方式

如下图，我现在新建如下三个 yml 文件：

我在 application-dev.yml 文件中写入：

server:
  port: 8082

然后在 application-test.yml 文件中写入：

server:
  port: 8081

如果我 application.yml 中什么也不写，运行后结果如下所示：

可以看到当前并没有设置 Profile，并且当前在 8080 端口运行。

那么此时我如果在 application.yml 中写入以下语句：

spring:
  profiles:
    active: dev

那么运行后的结果如下所示：

可以看到此时的 Profile 被设置了，此时激活的是 dev，并且发现项目在 8082 端口运行，这说明 application-dev.yml 中的配置生效了，同理我如果将 application.yml 换成：

spring:
  profiles:
    active: test

那么项目就会运行在 8081 端口，切换成激活了 test 的 Profile，即 application-test.yml 中的配置生效。

通过这个方法，我们可以快速切换适用于不同环境下的配置。

yml 多文档方式

在多 Profile 文件方式中我们发现，我们需要新建多个 yml 或 properties 文件，这样有些许麻烦，那么是否可以将不同环境下的配置写在同一个配置文件中，并用特殊的符号隔开呢？答案是有的，如下：

---
server:
  port: 8081
spring:
  profiles: test
---
server:
  port: 8082
spring:
  profiles: dev
---
spring:
  profiles:
    active: dev

不同的配置文件我们只需要使用 --- 隔开即可。

整理 SpringBoot 知识点（一）

Glader — Fri, 27 Dec 2024 06:18:10 GMT

SpringBoot 中 yml 的配置与获取

在application.yml文件中，自定义配置可以如下所示：

student:
  name: 小坤
  age: 18
  hobbies:
    - 唱
    - 跳
    - rap
    - 篮球

注意：层次之间缩进要对齐，并且冒号后面一定要空格后再写入值，如果是数组，则换行后每一行是一个值，前面加上-，并且-后面也要加上一个空格。

获取配置方法1：使用@Value("${属性}")，在pojo实体类中的运用如下：

@Data
@NoArgsConstructor
@Component
public class Student {
    @Value("${student.name}")
    private String name;
    @Value("${student.age}")
    private Integer age;
}

获取配置方法2：使用@ConfigurationProperties(prefix = "前缀")，在pojo实体类中的运用如下：

@Data
@NoArgsConstructor
@Component
@ConfigurationProperties(prefix = "student")
public class Student {
    private String name;
    private Integer age;
    private List<String> hobbies;
}

注意：倘若使用方法2，则pojo实体类中的属性名称必须和yml配置文件中的名称一模一样。
注意：@Value仅支持简单的字符串解析，不能解析List这种复杂的数据结构。

SpringBoot 整合 MyBatis

MyBatis的起步依赖如下，将其加入到pom.xml中：

<dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>3.0.3</version>
</dependency>

同时也要引入MySQL的驱动依赖，如下：

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
</dependency>

在配置文件application.yml中写入数据源配置，格式如下：

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/{数据库名}
    username: {用户名}
    password: {密码}

假如我们现在有一个数据库名字叫做mybatis，并且其中有一张表user如下：

id	name	age	gender	phone
1	小坤	19	1	18800000001
2	小徐	18	1	18800000002
3	小菜	17	1	18800000003
4	小蔡	16	2	18800000004
5	小鸡	15	1	18800000005
6	小美	14	1	18800000006

接下来，我们要新建一个pojo实体类User，代码如下:

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String name;
    private Short age;
    private Integer gender;
    private String phone;
}

然后在mapper包下新建接口UserMapper,如下：

@Mapper
public interface UserMapper {
    @Select("select * from user where id = #{id}")
    public User selectUserById(Integer id);
}

注意：一定不要忘记加@Mapper。

再然后，在service包下新建接口UserService,如下：

public interface UserService {
    public User selectUserById(Integer id);
}

紧接着，在service包的impl包下，新建实现类UserServiceImpl，实现UserService接口，并加入@Service注解交给IOC容器处理：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public User selectUserById(Integer id) {
        return userMapper.selectUserById(id);
    }
}

最后，在controller包下新建UserController，代码如下：

@RestController
public class UserController {
    
    @Autowired
    private UserService userService;

    @RequestMapping("/selectUserById")
    public User selectUserById(Integer id) {
        return userService.selectUserById(id);
    }

}

注意：上述操作属于MVC架构。

随后，运行项目，在浏览器中输入http://localhost:8080/selectUserById?id=1,查看效果，发现浏览器中输出：

{"id":1,"name":"小坤","age":19,"gender":1,"phone":"18800000001"}

测试 latex 是否可以正常渲染

Glader — Thu, 26 Dec 2024 07:22:30 GMT

本文章仅用于测试 latex 公式是否可以正常渲染，测试内容由 AI 生成：

1. 内联公式

例如，我们可以写出著名的爱因斯坦质能公式：$E=mc^2$，该公式说明能量和质量的关系。

2. 独立显示公式

对于二次方程： $$ ax^2 + bx + c = 0 $$ 其求根公式为： $$ x = \frac{-b \pm \sqrt{b^2-4ac}}{2a} $$

3. 求和与极限

无穷级数的经典结果： $$ \sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6} $$ 同时，我们可以测试一下极限公式： $$ \lim_{x\to 0} \frac{\sin x}{x} = 1 $$

4. 矩阵与特殊公式

以下是一个 2x2 矩阵的例子： $$ \mathbf{A} = \begin{bmatrix} a & b \ c & d \end{bmatrix} $$ 以及举世闻名的欧拉公式： $$ e^{i\pi} + 1 = 0 $$

将 Markdown 和 LaTeX 转为图片的脚本开发

Glader — Mon, 09 Dec 2024 23:54:53 GMT

前几天写了个 QQ 的机器人玩玩，接了一个第三方的 AI 接口。虽然在 LiteLoaderQQNT 中有相关的插件可以渲染 Markdown 和 LaTeX 等格式的文本，但大部分人是没有这些插件的。因此，我想着能否写一个将含有 Markdown 和 LaTeX 格式的文本转化为图片的脚本，于是便有了以下操作。

实现思路

经过查阅资料，了解到可以通过以下步骤实现：

将生成的文本转化为 HTML 网页；
使用 MathJax 将其中的 LaTeX 格式渲染出来；
对页面进行截图并保存。

JavaScript 脚本：网页截图

首先，写一个 JS 脚本，用于将给定的 HTML 网页进行截图，代码如下：

const puppeteer = require('puppeteer');
const path = require('path');
const fs = require('fs');

// 从命令行参数获取输入和输出路径
const args = process.argv.slice(2);
const inputPath = args[0];
const outputPath = args[1];

// 检查是否提供了参数
if (!inputPath || !outputPath) {
  console.error('用法: node script.js <输入路径> <输出路径>');
  process.exit(1);
}

// 将输入路径解析为绝对路径
const resolvedInputPath = path.resolve(__dirname, inputPath);

// 检查输入文件是否存在
if (!fs.existsSync(resolvedInputPath)) {
  console.error('输入文件未找到:', resolvedInputPath);
  process.exit(1);
}

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.setViewport({ width: 1200, height: 100 });

  // 打开页面
  await page.goto('file://' + resolvedInputPath, { waitUntil: 'networkidle0' });

  // 尝试等待 MathJax 渲染完成，最多等待 2 秒
  try {
    await page.waitForFunction(
      'window.MathJax && window.MathJax.Hub && window.MathJax.Hub.getAllJax().length > 0',
      { timeout: 2000 }
    );
  } catch (e) {
    console.log('MathJax 未完全加载，但继续生成图片...');
  }

  // 截图并保存到指定输出路径
  const resolvedOutputPath = path.resolve(__dirname, outputPath);
  await page.screenshot({ path: resolvedOutputPath, fullPage: true });

  console.log('Screenshot Successfully:', resolvedOutputPath);

  await browser.close();
})();

将上述代码保存为 screenshot.js。

配置依赖环境

上述代码依赖 Node.js 环境，首先要配置好 Node.js 的环境变量，同时使用以下命令在相同文件夹下安装 Puppeteer 包：

npm install puppeteer

Python 脚本：Markdown 转 HTML

在相同文件夹下新建一个 md2img.py 的 Python 程序，用于将 Markdown 和 LaTeX 转换为图片。

import markdown
from markdown.extensions import Extension
from markdown.treeprocessors import Treeprocessor

# MathJax
class MathJaxExtension(Extension):
    def extendMarkdown(self, md):
        md.treeprocessors.register(MathJaxProcessor(md), 'mathjax', 175)

class MathJaxProcessor(Treeprocessor):
    def run(self, root):
        for element in root.iter():
            if element.tag == 'span' and 'class' in element.attrib and 'math' in element.attrib['class']:
                element.tag = 'script'
                element.attrib['type'] = 'math/tex'
                element.text = element.text

def replace_brackets(input_string):
    input_string = input_string.replace('\[', '?gzl?')
    input_string = input_string.replace('\]', '?gzr?')
    input_string = input_string.replace('\(', '?gxl?')
    input_string = input_string.replace('\)', '?gxr?')
    return input_string

def covert_brackets(input_string):
    input_string = input_string.replace('?gzl?', '\[')
    input_string = input_string.replace('?gzr?', '\]')
    input_string = input_string.replace('?gxl?', '\(')
    input_string = input_string.replace('?gxr?', '\)')
    return input_string

def convert_markdown_to_html_with_latex(md_text):
    md = markdown.Markdown(extensions=['codehilite', 'fenced_code', MathJaxExtension()])
    html = md.convert(md_text)
    html = covert_brackets(html)
    return f"""
    <html>
    <head>
        <meta charset="UTF-8">
        <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-MML-AM_CHTML"></script>
        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.8.0/styles/default.min.css">
        <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.8.0/highlight.min.js"></script>
        <script>hljs.highlightAll();</script>
        <style>body {{ font-size: 30px; }}</style>
    </head>
    <body>
        {html}
    </body>
    </html>
    """

def markdown_to_html(md_text, html_out_path):
    html_output = convert_markdown_to_html_with_latex(replace_brackets(md_text))
    with open(html_out_path, 'w', encoding='utf-8') as f:
        f.write(html_output)
    print("HTML has finished.")

def html_to_image(html_path, img_path):
    import subprocess
    import os

    html_path = os.path.abspath(html_path)
    img_path = os.path.abspath(img_path)

    if not os.path.exists(html_path):
        raise FileNotFoundError(f"HTML 文件未找到: {html_path}")

    node_command = ["node", "screenshot.js", html_path, img_path]

    try:
        result = subprocess.run(
            node_command,
            check=True,
            text=True,
            capture_output=True
        )
        print("screenshot.js 输出:", result.stdout)
    except subprocess.CalledProcessError as e:
        print("screenshot.js 执行失败:", e.stderr)
        raise

    if not os.path.exists(img_path):
        raise FileNotFoundError(f"图片生成失败: {img_path}")

    print(f"图片生成成功: {img_path}")

import os
import time

def markdown_to_image(md_text, img_out_path):
    tmp_dir = os.path.join(os.getcwd(), 'tmp', 'cache')
    os.makedirs(tmp_dir, exist_ok=True)
    timestamp = int(time.time())
    html_file_path = os.path.join(tmp_dir, f"temp_{timestamp}.html")
    markdown_to_html(md_text, html_file_path)
    try:
        html_to_image(html_file_path, img_out_path)
        print(f"图片生成成功: {img_out_path}")
    except Exception as e:
        print(f"图片生成失败: {e}")
        raise
    finally:
        if os.path.exists(html_file_path):
            os.remove(html_file_path)

配置依赖环境

上述 Python 程序需要安装 markdown 包，运行以下命令安装：

pip install markdown

调用示例

新建一个 test.py，在里面调用 md2img.markdown_to_image(md_text, img_out_path) 即可实现 Markdown 和 LaTeX 转图片。

参数说明：
- md_text 表示含有 Markdown 和 LaTeX 的文本；
- img_out_path 表示图片的生成路径。

Glader's Blog - 中文版

LangChain4j 框架的学习

1. LangChain4j 简介

概念

特点

2. Java 语言整合 LangChain4j

引入依赖

文生文快速入门 Demo

文生图快速入门 Demo

3. LangChain4j 整合 Spring Boot

快速入门 Demo

集成类 Starter

声明式 AI Services Starter

Differentiable Auxiliary Learning for Sketch Re-Identification 的解读

1. 动机

2. 方法

Dynamic Auxiliary Generator (DAG)

Featrue Extraction

Modality Interactive Attention (MIA)

Auxilirary Cross-Attention Module (ACA)

Multi-Modality Collaborative Learning

类别损失

Circle Loss 损失

3. 实验

数据集配置

消融实验

对比实验

可视化展示

结论

Modalities collaboration and granularities interaction for fine–grained sketch-based image retrieval 的解读

1. 动机

2. 方法

CMFL (Cross-Modality Feature Learning)

CMIC (Cross-Modality Information Compensation)

CGPI (Cross-Granularity Prototype Interaction)

MGPM (Multi-Granularity Prototype Learning Module)

CGII (Cross-granularity information interaction)

MGPC (Multi-Granularity Prototype-aware Contrastive Loss)

3. 实验

数据集设置

与当前先进的方法对比

消融实验

超参数分析

实验展示

4. 总结

略微探讨 Spring 事务

1. 什么是事务

事务的定义

事务的性质

2. MySQL 中的事务

注意事项

基本事务操作

3. Spring 中的事务

示例 Demo

@Transactional 的基本用法

@Transactional 的高级用法

rollBackFor 属性

事务传播行为

Spring Bean 的作用域与生命周期

Singleton

Prototype

Bean 的生命周期

总结

第三方 Bean 注入 IoC 容器

手动注册 @Bean

@ComponentScan —— 扩展扫描路径

@Import 直接导入配置类

导入普通类

ImportSelector 动态注册 Bean

更复杂的示例：条件导入

使用 DeferredImportSelector

@EnableXxx 组合注解

Spring AOP

1. Spring AOP 示例注解解释

@Before

@Around

@After

@AfterReturning

@AfterThrowing

@Pointcut

`@Transactional` 的基本用法

`@Transactional` 的高级用法

`rollBackFor` 属性