Glader's Blog - English

Learning the LangChain4j Framework

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

1. Introduction to LangChain4j

Concept

LangChain4j is an open-source Java library/framework designed to simplify the process of integrating and using large language models in Java applications. Its design goal is to enable Java developers to easily build complex AI applications (such as chatbots, intelligent assistants, retrieval-augmented generation systems, etc.), just like using Python's LangChain.

Features

LLM Integration: Provides a unified API that allows you to call various mainstream large language models (such as OpenAI, Google, Anthropic, domestic models, etc.) without directly interfacing with their low-level interfaces.

Modularity and Extensibility: The framework adopts a modular design where different components can be imported separately, such as model providers, vector databases, memory management, tool invocation, etc.

RAG Support (Retrieval-Augmented Generation): Converts external text data into vectors, combines with vector databases for semantic retrieval, and injects results into model context to improve answer quality.

Tools and Agents: Supports function calling, external tool integration, and agent workflows to build more complex AI task flows.

Integration with Java Ecosystem: Can be used in combination with common Java frameworks (such as Spring Boot, Quarkus).

2. Integrating LangChain4j with Java

Adding Dependencies

First, we create a basic Java project. I'll use a Maven project as an example.

First, introduce the LangChain4j core framework dependency and adapter implementation dependency (using OpenAI's adapter implementation here), as shown below:

<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>

For specific version features and dependencies for other interface specifications (such as Alibaba, Ollama, etc.), you can refer to the official open-source repository or official documentation. Their usage methods are basically the same as OpenAI's.

Then we introduce JUnit dependency for unit testing:

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

Text Generation Quick Start Demo

Then we can write a unit test to quickly master the usage of LangChain4j:

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

If you have an OpenAI API key, you can directly run this test unit and view the results to output the model's returned result.

Note that the ChatModel API was introduced in LangChain4j version 1.0.0-beta4. In previous versions, you should use ChatLanguageModel as the standard interface for chat models.

If we use other third-party APIs that also comply with OpenAI's interface specification, we can use the baseUrl method in OpenAiChatModel to fill in the third-party API interface address. The specific interface address format needs to comply with the third-party interface documentation but should not include specific resource paths. For example, if we use the SiliconFlow interface:

@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("Hello");
	System.out.println(answer);
}

The result after running is as follows:

As you can see, it successfully prints the model's returned result, along with a very cute emoji 😊.

The red warning above can be temporarily ignored. This is because the current project has not yet configured a specific logging implementation. From the dependency tree of the LangChain4j core framework, it only introduces slf4j as a logging facade without binding any specific logging implementation. Later, when integrating with Spring Boot projects, Spring Boot's default logging implementation will automatically supplement this part:

If you don't plan to integrate with Spring Boot projects, you can manually introduce Logback as the logging implementation to eliminate this warning. In fact, Spring Boot has already integrated and auto-configured Logback as the logging implementation by default, so you usually won't encounter this problem in Spring Boot projects.

But since we're only doing testing now, it's fine not to use a logging system.

Text-to-Image Quick Start Demo

For text-to-image generation, we use ImageModel. Here I'm using Alibaba's Qwen-Image text-to-image model. We directly call the generate method under ImageModel, passing in our text description. For example, if I want to generate an image of a "cat-eared cute girl", we pass in this string. The return is a Response data, and we can use response.content().url() to get the direct link to the generated image.

@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("cat-eared cute girl");
    System.out.println(response.content().url());
}

The result after running is as follows:

We open the link, download the image, and get the following image:

As you can see, the quality is excellent and meets our requirements very well.

Based on this, readers can further explore capabilities in other modality directions (such as text-to-speech, image-to-text, image-to-video, etc.) in combination with the API documentation of the selected platform. Note that different vendors have significant differences in interface design for multimodal capabilities: some platforms provide OpenAI-compatible extended endpoints, while others adopt their own multimodal protocols or workflow orchestration interfaces. In actual implementation, it's recommended to prioritize solutions with stable interfaces, clear documentation, and mature ecosystems.

3. Integrating LangChain4j with Spring Boot

Quick Start Demo

To integrate LangChain4j with Spring Boot, your Spring Boot version must be 3.2 or above, and the JDK version requirement is 17 or above. Original details

LangChain4j mainly provides two types of Starters:

Integration Starters: Used to interface with common model providers, vector databases, Embedding services, and other third-party components, providing corresponding auto-configuration and configuration capabilities for out-of-the-box use in Spring Boot.
Declarative AI Services Starter: Used to enable and enhance declarative AI Service capabilities (such as @AiService), supporting the definition of AI capabilities through interfaces/annotations, with the framework completing implementation generation, dependency injection, and runtime orchestration.

Integration Starters

This may sound abstract, so let's first look at the first type of Starter. The unified specific format for this type of Starter is: langchain4j-{integration-name}-spring-boot-starter, where {integration-name} represents the specific integration object (such as a large model provider, Embedding service, or vector database, etc.). For example, if I use OpenAI's unified interface specification, I can introduce the following dependency:

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

Here, the {integration-name} is open-ai. For the specific name format of other providers, you can refer to the official repository.

After introducing the dependency, the next step is the exciting stage of writing configuration information. We can write in application.properties or in files with formats like application.yml.

If writing in application.properties, you basically need to add the following content:

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
...

Why use ellipsis here? These four are the basic configuration items. The first is the key information, the second is the model information, the third enables logging of request content sent to the model, and the fourth enables logging of response content returned by the model.

There are also some other configuration items that can be configured. Please refer to the official API documentation for details.

For example, since I'm now using SiliconFlow's interface, I also need a base-url configuration item, so the overall configuration is:

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

Then we write a test Controller as follows:

@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);
    }
}

In this case, the Controller only depends on the interface ChatModel, with the specific implementation automatically created as an instance OpenAiChatModel by the starter for auto-configuration and injection, which is very convenient.

Then we write a test unit for testing:

@Autowired
private ChatController chatController;
@Test
void test4(){
    System.out.println(chatController.model("Hello, who are you?"));
}

The result after running is as follows:

As you can see, not only do we have our sout output results, but there are also log printings of request and response content, which is the result of the two log settings we enabled in the configuration file.

In actual project development, we can customize utility classes according to our needs, for example:

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

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

This is very elegant. Remember to add the @Component annotation to hand it over to the IoC container for management.

All our previous tests wait for the interface to fully generate the text before getting results and printing them. However, when we use AI for conversations on web pages, its output is often streaming, for example:

As you can see, it outputs word by word, rather than returning all content to us after retrieving everything. This output method is usually called streaming output. Its core idea is: during the content generation process, every time the model generates a token (or a text fragment), it immediately returns it to the caller, rather than waiting for the complete response to be generated.

For AI conversations in web scenarios, streaming output is almost a "standard feature". It can significantly improve user experience:

Lower first token latency: Users can almost immediately see the model start "talking"
More natural interaction: Closer to the rhythm of human input
Better suited for long text generation: Avoids long blank screen waiting

Next, let's see how to elegantly implement streaming output in the LangChain4j + Spring Boot scenario.

In LangChain4j, streaming output is not completed through ChatModel, but through a dedicated Streaming interface, such as StreamingChatModel. When using interfaces that comply with the corresponding model provider's specifications, LangChain4j will establish a streaming connection with the model through SSE (Server-Sent Events) at the bottom layer and callback the token increments generated by the model one by one to the caller.

Fortunately, we don't need to manually handle these complex low-level details.

LangChain4j's Spring Boot Starter has already encapsulated the corresponding auto-configuration capabilities for us and will automatically create and register Beans related to StreamingChatModel based on the configuration file.

First, we need to add streaming model configuration in application.properties. Unlike the chat-model used for synchronous calls earlier, here we use the streaming-chat-model prefix, as follows:

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

Then we modify the utility class:

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

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

Just change the original ChatModel to StreamingChatModel, then pass a callback handler: StreamingChatResponseHandler in the chat method. The changes are very minor.

Now Spring Boot no longer requires manually writing SSE details for streaming returns. We just need to introduce the Spring WebFlux dependency, and we can conveniently implement automatic chunking, real-time pushing, and connection management of server data by returning Flux. Spring will handle the underlying SSE protocol encapsulation and refresh logic.

The Spring WebFlux dependency format is as follows:

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

Let's write a Service and Controller as quickly as possible for testing, as follows:

@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(" Output complete.");
                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);
    }
}

Next, we open ApiFox for testing. We input our test URL: http://localhost:8080/api/chat?message=Hello, who are you, and we can see the returned results popping out word by word:

From the running results, we can see that the web side can receive real-time returned content segment by segment, which is precisely the result of the collaborative work of various callback methods of StreamingChatResponseHandler. Let's analyze the role of these callbacks in streaming output one by one.

The several callback methods of StreamingChatResponseHandler correspond to different stages of the model generation process: when the model has not yet fully generated the result, onPartialResponse will be triggered multiple times, returning a small piece of content each time. Here we immediately push the data downstream through FluxSink.next(), thereby achieving real-time output of text on the front-end page; when the model finishes generating, onCompleteResponse is called back to indicate that this generation is complete. In actual use, the stream is usually ended here; if an exception occurs during the generation process, onError is triggered to pass the error signal to the front end. It is precisely by converting this callback-based flow into Flux through Flux.create that Spring WebFlux can automatically write data continuously into the HTTP response in a streaming manner, ultimately achieving streaming output without manually writing SSE.

In addition to the three main callback methods mentioned above, there is also an onPartialThinking method. What is this method for?

We find that many models now come with a thinking process, which first conducts reasoning. This callback is actually for handling the content returned by the reasoning process. We won't continue discussing this here. The principle is similar to onPartialResponse. Interested friends can continue to explore. In fact, we will have more concise callback writing methods later, which we'll continue to explore later.

Declarative AI Services Starter

LangChain4j provides a Spring Boot starter for auto-configuring AI Services, RAG, Tools, etc.

We have completed the auto-configuration of the underlying model client, but if we still stay at the level of directly injecting ChatModel and manually writing Prompt and callback logic, the overall usage is still imperative. The significance of AI Services Starter is to further abstract these boilerplate codes, allowing you to use large model capabilities through declarative interfaces just like writing ordinary Spring Services. You only need to define method signatures and annotations, and LangChain4j will automatically generate implementations at runtime, handling details such as Prompt construction, model calling, and result mapping. Combined with Spring Boot's auto-configuration, model parameters and keys can be centrally managed in application.yml, making it convenient to switch between different environments or models. When RAG or tool calling is introduced, the advantages of this approach become even more obvious. The relevant orchestration is almost transparent to business code, keeping the code always simple, clear, and maintainable.

Next, let's quickly demonstrate the specific usage in code.

First, we need to import the langchain4j-spring-boot-starter dependency as follows:

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

<!--        langchain4j-reactor is LangChain4j's official adapter layer for Reactor (Mono / Flux),-->
<!--        because we used Flux for streaming output, we need to introduce the adapter layer dependency below.-->
<!--        If streaming output is not needed in your project, you don't need to introduce the dependency below,-->
<!--        only need to introduce the one above.-->
<dependency>
  <groupId>dev.langchain4j</groupId>
  <artifactId>langchain4j-reactor</artifactId>
  <version>1.10.0</version>
</dependency>

Then we comment out or delete ChatServiceImpl. We don't need to manually implement such tedious code. We go directly back to the ChatService interface and add the AiService annotation to it, as follows:

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

No other code needs to be changed. Let's run and test it in ApiFox again:

As you can see, as we expected, it can correctly give streaming responses, and we don't need to write those tedious implementation class codes ourselves.

Let's go back and look at the source code of @AiService to see what it actually does for us. The source code is as follows:

@Service
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface AiService {
    AiServiceWiringMode wiringMode() default AiServiceWiringMode.AUTOMATIC; // Wiring mode: automatic or manually specify dependencies
    String chatModel() default "";                 // Synchronous ChatModel Bean name
    String streamingChatModel() default "";        // Streaming StreamingChatModel Bean name
    String chatMemory() default "";                // ChatMemory Bean name for conversation memory
    String chatMemoryProvider() default "";        // ChatMemoryProvider Bean name for creating memory by session
    String contentRetriever() default "";          // ContentRetriever Bean name for RAG retrieval
    String retrievalAugmentor() default "";        // RetrievalAugmentor Bean name encapsulating complete RAG enhancement process
    String moderationModel() default "";           // ModerationModel Bean name for content safety review
    String toolProvider() default "";               // ToolProvider Bean name for unified tool provision
    String[] tools() default {};                   // Specify list of tool Bean names to inject
}

As you can see, AiService also encapsulates the Service annotation. Therefore, using AiService is equivalent to using the Service annotation, so it will be scanned by Spring and managed by IoC. However, when it's annotated on an interface, what Spring injects is not the interface itself, but a proxy implementation generated by LangChain4j at runtime based on annotation configuration. For knowledge about dynamic proxies, you can refer to another blog post of mine; this proxy will be responsible for Prompt assembly, model selection (chat/streaming), and orchestration of capabilities such as memory/RAG/tools, making interface methods look like ordinary Service calls, but actually calling large models at the bottom layer. Let's look at its dynamic proxy part of the source code, located under 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 method handling
                        if (method.isDefault()) {
                            return InvocationHandler.invokeDefault(proxy, method, args);
                        }
                        if (method.getDeclaringClass() == Object.class) {
                            ...
                        }
                        // Build an AI call context
                        InvocationContext invocationContext = InvocationContext.builder()
                                .invocationId(UUID.randomUUID())
                                .interfaceName(context.aiServiceClass.getName())
                                .methodName(method.getName())
                                .build();
                        // Core entry: convert interface method call to AI call
                        return invoke(method, args, invocationContext);
                    }
                    public Object invoke(Method method, Object[] args, InvocationContext invocationContext) {
                        // Prompt / Memory / RAG / Guardrails preparation
                        ...
                        // Determine if it's a streaming return
                        Type returnType = method.getGenericReturnType();
                        boolean streaming =
                                returnType == TokenStream.class || canAdaptTokenStreamTo(returnType);
                        if (streaming) {
                            // Streaming: return TokenStream or adapted type (like Flux)
                            TokenStream tokenStream = new AiServiceTokenStream(...);
                            return returnType == TokenStream.class
                                    ? tokenStream
                                    : adapt(tokenStream, returnType);
                        }
                        // Non-streaming: synchronously call model and parse results
                        ChatResponse response = chatModel.execute(...);
                        return serviceOutputParser.parse(response, returnType);
                    }
                }
        );
        return (T) proxyInstance;
    }
    ...
}

At the same time, we notice that AiService also provides many annotation properties for us to use. We're only doing a quick start here. The specific roles of other properties will be explained in detail in separate articles later.

Interpretation of Differentiable Auxiliary Learning for Sketch Re-Identification

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

This paper is an AAAI-2024 article, titled "Differentiable Auxiliary Learning for Sketch Re-Identification."

The paper proposes a network architecture called DALNet. This method generates a "sketch-like" intermediate auxiliary modality by performing background removal and edge detection enhancement on real photos, thereby bridging and aligning the sketch and photo modalities. Since the module responsible for generating this auxiliary modality is trainable and differentiable, supporting end-to-end optimization, the method is named "Differentiable Auxiliary Learning" (DAL).

1. Motivation

As shown in the figure above, the paper's motivation is very clear and can be divided into two main points:

The inter-modal differences between sketches and pedestrian images are too large. Can an intermediate modality be constructed to help bridge the gap between these two modalities?
The intra-modal differences within sketches and pedestrian images are also significant. First, sketches of the same pedestrian may be drawn by different artists with diverse styles and varying levels of abstraction; additionally, photos of the same pedestrian under different cameras are severely affected by background clutter, illumination changes, and viewpoint/pose variations. This causes even photos of the same person to be far apart in the feature space, increasing matching difficulty.

To address the first problem, the paper constructs a "sketch-like" intermediate auxiliary modality as a bridge. This modality is generated through background removal and edge detection enhancement on real photos, effectively assisting in establishing inter-modal feature alignment. During the feature learning stage, the paper incorporates multi-modal collaborative constraints: using cross-modal circle loss to align the overall relationship among sketches, photos, and sketch-like images.

To address the second problem, the paper introduces intra-modal circle loss to specifically compress the distribution of the same identity within the same modality and increase the distance between different identities. For sketches, this reduces the impact caused by different artist styles; for real images, this reduces feature drift issues caused by illumination, background, and viewpoint/pose changes.

2. Method

The overall framework of the model is shown in the figure above. In general, during the training phase, the Dynamic Auxiliary Generator (DAG) module first generates a sketch-like auxiliary modality image (this module is trainable and optimized through the $L_{SR}$ loss to make the generated auxiliary images adaptively approximate the target sketch style). Then, images from three modalities—sketches, auxiliary images, and real images—are encoded to extract features. The auxiliary modality features are then fused into the other two modalities, and through cross-attention mechanisms, shared semantic information between sketches and real images is strengthened to achieve fine-grained interactive fusion. Finally, classification loss and cross-modal/intra-modal circle loss jointly constrain the feature relationships and distributions of the three modalities. Below, I will analyze the details of each component.

Dynamic Auxiliary Generator (DAG)

This is the dynamic auxiliary generator module, whose function is to input a real image and output a sketch-like auxiliary image. Its principle is specifically shown in the following figure:

First, the real pedestrian image is input into the pre-trained U²-Net (whose network parameters remain frozen) to obtain a foreground segmentation mask matrix; then, this mask is used to filter the original image pixel by pixel, thereby retaining the pedestrian body and removing the background, obtaining a pedestrian image with the background removed. The specific structure of U²-Net is shown on the right side of the figure above. The reason it's called U²-Net is that it is overall a U-Net-style encoder-decoder structure, but each encoding and decoding stage internally embeds a smaller U-Net (i.e., the RSU module, Residual U-block), equivalent to "U within U," forming a cascade of two-layer U-shaped structures, hence named with U squared.

U²-Net generates multiple masks (side maps) from different scale side output layers during the decoding process. These masks correspond to foreground predictions at different resolutions: shallow side outputs focus more on edges and details, while high-level side outputs focus more on overall structure and semantic regions. During training, deep supervision is typically applied to these side outputs to stabilize convergence and enhance multi-scale segmentation capabilities. Finally, the multi-scale side outputs are fused (such as concatenation followed by convolution or weighted fusion) to obtain a final high-quality foreground mask for subsequent background removal.

After obtaining the pedestrian image with the background removed, it is still an RGB color image. Therefore, it first needs to be converted into a single-channel grayscale image through a 1×1 convolutional block, then passed through a 3×3 convolutional kernel for edge detection to enhance contour lines, making the grayscale image more approximate to a sketch, thereby generating a sketch-like auxiliary modality image. Here, this 3×3 convolutional kernel is trainable, which is also the only trainable and optimizable part of the DAG module, constrained by the loss function $L_{SR}$. The definition of this loss function will be analyzed in detail in the feature extraction module below. The convolutional kernel is initialized with a center value of 9 and surrounding 8 values of -0.8, first providing a stable "edge enhancement" prior, then adaptively adjusting the convolutional kernel weights during training according to downstream retrieval objectives, making the generated Auxiliary more conform to the contour expression of the sketch domain.

Feature Extraction

Next is the feature extraction module. As shown in the figure below, a three-stream ResNet-50 is used as the backbone to encode features for Photo, Auxiliary, and Sketch modalities respectively: each modality first passes through its own front-end ResBlocks (using the first two stages of ResNet-50) to extract low-level local features, obtaining global representations for the three streams; then the three-stream features are sent to the same set of "weight-shared" subsequent ResBlocks (using the remaining stages of ResNet-50) to learn higher-level, more semantically-oriented shared representations, preparing for subsequent modality interaction alignment.

Specifically, define $P={x_i^P}_{i=1}^{N_p}$ as the sample set of real images, where $N_p$ represents the number of samples. The $A$ and $S$ sets are similar, representing the sketch-like set and sketch set respectively.

Now, Photo, Auxiliary, and Sketch are put into their respective front-end ResBlocks to obtain three encoded feature maps. GeM Pooling operation is performed on these feature maps to obtain three pooled feature vectors $I^P$, $I^A$, and $I^S$ respectively. The specific formula is shown as $I_k^u$ in the figure above, where $u$ represents the modality, $k$ represents the current $k$-th channel, $H$ and $W$ represent the height and width of the feature map respectively, and $p$ is a learnable parameter. When $p$ is close to 1, the pooling will be more like "average pooling" (doing more uniform aggregation over the entire feature map); as $p$ gradually increases, the aggregation process will increasingly approach "max pooling" (emphasizing the positions with the strongest responses). The reason for using GeM Pooling is that it adaptively compromises between average pooling and max pooling with a learnable $p$: it can both preserve global structural information and highlight local discriminative regions more critical for pedestrian retrieval (such as clothing textures, contour details, etc.), thereby obtaining more robust and discriminative global representations in cross-modal matching.

After obtaining the three feature vectors, the paper calculates the style refinement loss function $L_{SR}$ (whose form is similar to InfoNCE), with the specific formula shown in the figure above. The purpose is to pull the Auxiliary generated by DAG from "photo style" toward "sketch style," thereby optimizing the convolutional kernel parameters of the DAG module, without destroying the human body structure information it inherits from Photo. The specific approach is: using the style feature $I^A$ of the auxiliary modality as the anchor, treating the sketch style feature $I^S$ of the same identity as the only positive sample; in the denominator, only $I^S$ and a set of photo style features ${I_i^P}_{i=1}^{N}$ are included for comparison, without adding other sketch features, because the goal here is not to learn the "separability between sketches" (which belongs to identity discrimination and retrieval loss to handle), but to explicitly distinguish $I^A$ from the Photo domain and make it approach the Sketch domain: if the denominator introduces a large number of "other sketches," the optimization will become making $I^A$ simultaneously far from these sketches (including sketches with similar styles to the target sketch), which can easily weaken the traction force of "approaching the sketch domain" and even introduce unnecessary identity and style mixing. Therefore, the comparison set of this loss is deliberately designed as "one sketch positive sample + multiple photo negative samples," maximizing the similarity between $I^A$ and $I^S$ through softmax normalization with temperature coefficient $\xi$, minimizing the similarity between $I^A$ and each $I_i^P$, thereby achieving the style transfer constraint of "de-photo stylization + alignment toward sketch style." The experimental details indicate that the temperature coefficient $\xi$ is set to 0.07.

Afterward, the feature maps from the three streams are sent to the same set of "weight-shared" subsequent ResBlocks to learn higher-level, more semantically-oriented shared representations, specifically denoted as $f^P$, $f^A$, and $f^S$, preparing for subsequent modality interaction alignment. Note here that what is sent to the subsequent ResBlocks is the original feature maps generated by the three streams, not the pooled $I^u$.

Modality Interactive Attention (MIA)

Next is the modality interactive attention module, specifically shown in the figure below. This module consists of two sub-modules: the Bilinear Align module and the Auxiliary Cross-Attention module.

The Bilinear Align Module (BAM) is shown in the figure above. Its core function is to use the auxiliary modality feature map $f^A$ to calculate similarity weights $S_{uA}$ with the other two modality feature maps $f^P$ and $f^S$ (where $u\in{P,S}$). $S_{uA}$ can be understood as an "attention scoring map": it characterizes the matching degree between the current modality features and auxiliary modality features at each spatial position and each channel. Positions with high matching will be assigned larger weights, thereby highlighting more reliable and consistent pedestrian structure cues when weighting features subsequently. Specifically, during calculation, $f^A$ and the target modality's $f^u$ are first concatenated in the channel dimension, then sent to the bilinear alignment unit to model the second-order interaction relationship between the two, obtaining aligned responses. Then, through the sigmoid function $\sigma(\cdot)$, they are normalized to the $[0,1]$ range, forming similarity probability $S_{uA}$, which is used to perform attention weighting enhancement on $f^u$ and output aligned features.

The specific steps of bilinear alignment are shown in the figure above. First, tensor reshaping is required. The original $f^P$, $f^A$, and $f^S$ are actually tensors of shape $(N,C,H,W)$, where $N$ represents batch size, $C$ represents the number of channels, and $H$ and $W$ represent the height and width of the feature map respectively. First, the shape is adjusted to $(N,C,HW)$, then stacking and concatenation are performed to obtain a $(N,2C,HW)$ result concatenated on channels, as shown in the red box in the figure above. Taking the upper red box's $f^P$ and $f^A$ as examples, after reshaping, these two feature maps are represented by a series of long strips, where the length extending into the screen can be abstracted as $HW$, and the number in the vertical direction can be represented as the number of channels $C$. When the two feature maps are stacked together, there are a total of $2C$ strips (C orange ones in the upper half, C green ones in the lower half). Then they enter a linear layer to compress the channels to $C/4$. The purpose is to first perform "dimensionality reduction compression" on the channel expression after two-modality concatenation as a lightweight bottleneck transformation without losing key information: because the number of channels becomes $2C$ after concatenation, if bilinear interaction is done directly in high-dimensional space, both parameter and computational costs will be large, and it's easy to overfit. Therefore, the first linear layer first compresses the channels to $C/4$, which is equivalent to feature screening and information distillation, retaining the relevant components most helpful for two-modality alignment. Then it enters another linear layer to restore the channels back to $C$. The purpose is to remap the compressed "alignment relationship" back to the channel dimension consistent with the original backbone features, facilitating subsequent fusion/element-wise operations with original features, and ensuring that the output dimension matches subsequent modules (such as similarity estimation and attention weighting).

The calculated $S_{uA}$ will be reshaped back to $(N,C,H,W)$ shape to correspond one-to-one with the original feature map $f^u$ in spatial positions and channel dimensions. Subsequently, features are weighted and enhanced according to the alignment formula $f_{ali}^u = S_{uA}\odot f^u + f^u$: where $S_{uA}$ serves as attention weights, assigning higher responses to regions more consistent with the auxiliary modality and suppressing inconsistent or noisy regions, while preserving original information through the residual term. The finally obtained $f_{ali}^P$ and $f_{ali}^S$ are the Photo and Sketch feature maps guided and aligned by Auxiliary, providing "cleaner" and more alignable representations for subsequent ACA cross-attention interaction.

Meanwhile, to enable the auxiliary modality to also participate in bidirectional matching with "aligned, cleaner representations" during subsequent ACA cross-attention interaction (for example, using $f_{ali}^A$ as Key/Query to interact with $f_{ali}^P$ or $f_{ali}^S$), the paper also performs the same weighted residual enhancement on the auxiliary modality itself to obtain aligned auxiliary features $f_{ali}^A$. Specifically defined as using the similarity weight $S_{SA}$ between sketch and auxiliary modality to weight $f^A$: $f_{ali}^A = S_{SA}\odot f^A + f^A$.

The final result is like this, where depth and shallowness represent the degree of attention to features. Deeper means stronger attention, while shallower means weaker. As for why some are dashed boxes, the paper doesn't explain. I've consulted some drawing materials and learned that dashed lines may represent some common features under the three modalities.

Auxiliary Cross-Attention Module (ACA)

The purpose of ACA is not to "calculate another similarity score," but to actually enable information exchange and fusion among the three modalities based on the aligned features obtained from BAM: the paper emphasizes that it "uses the auxiliary modality to guide the model in learning the distribution of modality-shared representations," and can achieve significant information interaction and fusion between photo and sketch.

As shown in the figure above, taking "interaction between photo and auxiliary" as an example for specific calculation: the aligned features $f_{ali}^P$ and $f_{ali}^A$ output by BAM are respectively treated as Query and Key (denoted as $Q^P$ and $K^A$), then standard scaled dot-product attention is used to obtain matching weights from photo to auxiliary: $W_{P\rightarrow A} = \text{Softmax}\left(\frac{Q^P (K^A)^T}{\sqrt{d_K}}\right)$, where $d_K$ is the channel dimension of Key. At the same time, Query and Key are exchanged to obtain reverse matching weights: $W_{A\rightarrow P} = \text{Softmax}\left(\frac{Q^A (K^P)^T}{\sqrt{d_K}}\right)$.

With bidirectional weights, the paper uses a "round-trip consistency" method to refine photo features: using $V^P=f_{ali}^P$ as Value, multiplying $W_{P\rightarrow A}$ and $W_{A\rightarrow P}$ first, then weighting $V^P$, and finally performing LayerNorm to obtain photo features highlighted by the auxiliary modality: $\hat f^P = \text{Norm}\left(W_{P\rightarrow A} W_{A\rightarrow P} V^P\right),\quad V^P=f_{ali}^P.$ This can be understood as: first using $W_{P\rightarrow A}$ to find which positions or patterns in photo can find correspondence in auxiliary, then using $W_{A\rightarrow P}$ to "map this correspondence back" to confirm consistency, thereby more robustly strengthening the structural semantics shared by both and suppressing noise and inconsistent regions in each.

Similarly, performing the same bidirectional cross-attention on $f_{ali}^S$ and $f_{ali}^A$ yields the refined sketch features $\hat f^S$ guided by the auxiliary latent representation.

Multi-Modality Collaborative Learning

Multi-modality collaborative learning. This part mainly revolves around two types of losses: one is category loss, used to ensure that features of the three modalities have clear identity discriminability; the other is the circle loss series of metric learning losses, where cross-modal circle loss is used to constrain samples of different modalities but the same identity to approach each other in the feature space, and different identities to separate from each other, achieving overall inter-modal alignment; meanwhile, intra-modal circle loss is introduced to specifically compress the distribution of same-identity samples within the same modality and increase the distance between different identities, to alleviate intra-class dispersion problems caused by sketch style differences and photo viewpoint/illumination/background changes. The two work together to enable the model to simultaneously complete inter-modal and intra-modal alignment.

Category Loss

As shown in the figure above, the category (identity) loss uses $L_{ID}$. The purpose is to use "identity supervision" to pull the three modalities into the same separable identity space, allowing Photo/Auxiliary/Sketch of the same person to learn consistent identity patterns. The paper writes it as the sum of two parts: $L_{ID}=L_{id}(F)+L_{id}(\hat F)$, where $F={f^P,f^A,f^S}$ represents the set of feature maps output by the three modalities through shared ResBlocks, $\hat F={\hat f^P,\hat f^S}$ represents the set of Photo and Sketch feature maps enhanced through fine-grained interaction in MIA, and $L_{id}$ is the standard cross-entropy classification loss (using real identity labels for softmax classification supervision). The intuitive meaning of this design is: on one hand, directly constraining the three-modality basic representations extracted by the shared backbone to align at the identity level; on the other hand, also constraining the enhanced representations after auxiliary modality-guided interaction to still maintain correct identity discriminability, avoiding attention interaction "aligning" features to the wrong person or introducing identity-irrelevant deviations.

Circle Loss

As shown in the figure above, the paper improves upon circle loss proposed in 2020, making it suitable for sketches and images, and designs two loss functions. One is $L_{CM}$, used for inter-modal alignment; the other is $L_{IM}$, used for intra-modal alignment.

The paper uses circle loss for metric learning constraints rather than the common triplet loss. The core reason is: Sketch Re-ID simultaneously has "huge cross-modal differences and extremely few samples per identity." Simply using triplets often only provides local constraints on a small number of triplets, easily resulting in unstable optimization, strong dependence on hard samples, and the phenomenon of only considering cross-modal while ignoring intra-modal distribution. Circle loss, on the other hand, uses a unified form of "pairwise similarity optimization" to incorporate multiple pairs of positive and negative samples in a batch into optimization together, and emphasizes "harder" positive-negative pairs through adaptive weights $\alpha_i^+,\alpha_j^-$, making it more suitable for learning a more robust metric space with limited samples.

Let me first explain my understanding of the original circle loss. The original formula is shown in the red box in the figure above. It treats "similarity" as the optimization objective: for positive sample pairs formed by the same identity, similarity is denoted as $Z_i^+$ (hoping it to be as large as possible); for negative sample pairs formed by different identities, similarity is denoted as $Z_j^-$ (hoping it to be as small as possible). Therefore, its core is to simultaneously do two things: pull all $Z_i^+$ toward 1 (pull together same classes), while pulling all $Z_j^-$ toward 0 or even smaller (push apart different classes). It puts positive pairs and negative pairs into exponential functions separately for weighted summation: the exponential part of the positive pair term is roughly $-\gamma \alpha_i^+(Z_i^+ - \delta(+))$. When the similarity $Z_i^+$ of a certain positive pair is not large enough and is lower than the expected threshold $\delta(+)$, the bracket is negative, the exponential term becomes larger, contributing more to the loss, thus backpropagation will strongly push this positive pair to become more similar. Conversely, if $Z_i^+$ is already very large, exceeding $\delta(+)$, the contribution of this term becomes smaller, indicating that "easy positive samples" will not be over-optimized. The exponential part of the negative pair term is $\gamma \alpha_j^-(Z_j^- - \delta(-))$. When the similarity $Z_j^-$ of a certain negative pair is high, exceeding the threshold $\delta(-)$, this term will rapidly increase, and the loss will pay more attention to these "hard negative samples," thereby pushing their similarity down. If the negative pair is already very small (already separated), its contribution will be automatically suppressed. Here, $\delta(+)=1-m$ and $\delta(-)=m$ are controlled by margin $m$, which is equivalent to setting a "passing line" for positive and negative pairs respectively, requiring positive pair similarity to exceed $1-m$ as much as possible, and negative pair similarity to be below $m$ as much as possible. $\gamma$ is the scale coefficient, used to control the "strength/steepness" of optimization. The most critical adaptive weights are $\alpha_i^+=[1+m-Z_i^+]+$ and $\alpha_j^-=[Z_j^-+m]+$: they will make positive pairs with unsatisfactory similarity ($Z_i^+$ small) and negative pairs most easily confused ($Z_j^-$ large) obtain larger weights, thereby naturally shifting the training focus to "hard sample pairs." This is why circle loss can simultaneously achieve "pulling together same classes, pushing apart different classes" and be more stable.

Based on this, the paper further extends the "pairwise similarity optimization" idea of circle loss to the three-modality scenario and designs corresponding solutions for the two core contradictions of sketch Re-ID. First is inter-modal alignment $L_{CM}$: it no longer only constructs positive-negative pairs within the same modality, but directly calculates similarity between different modalities to construct positive-negative pairs, that is, changing $Z_i^+$ and $Z_j^-$ to cross-modal cosine similarities $Z_i^{uv+}(f^u,f^v)$ and $Z_j^{uv-}(f^u,f^v)$ ($u\neq v,;u,v\in{S,P,A}$), and applying circle loss constraints to the three groups of modality pairs $AS$, $AP$, $PS$ and then summing them. The intuitive purpose of doing this is: sketch, photo, and auxiliary of the same identity should be close to each other in the feature space, while different identities should be separated. Moreover, because auxiliary is in the "sketch-like" intermediate state, it simultaneously participates in the alignment of $AS$ and $AP$, playing a bridging role during optimization, indirectly reducing the alignment difficulty of $PS$. The specific formula is shown in the green box in the figure above.

However, if only $L_{CM}$ is used, the model often focuses its optimization on "cross-modal differences," resulting in the distribution of the same identity within each modality still possibly being very scattered (for example, photos of the same person from different cameras are still far apart, or sketches by different artists still have large style differences), thereby learning a suboptimal latent space. Therefore, the paper adds intra-modal alignment $L_{IM}$: it still uses the form of circle loss, but constructs positive-negative pairs by constraining within the same modality. To create more powerful supervision with few samples, it pairs features before interaction $f^u$ with features after interaction $\hat f^u$ within the same modality to construct positive sample pairs (the same identity should be consistent), while selecting the most easily confused different-identity pairs as negative sample pairs. In this way, $L_{CM}$ is responsible for pulling different modalities into the same metric space to complete inter-modal alignment, while $L_{IM}$ is responsible for compressing intra-class dispersion and increasing inter-class gaps within each modality. The two work together to simultaneously alleviate both "cross-modal gap" and "large intra-modal differences." The specific formula is shown in the blue box in the figure above.

In the experimental details, the parameter settings are $m_{cm}=0.25$, $m_{im}=0.5$, $\gamma=64$.

The total loss function is the sum of the above four loss functions, namely $L=L_{ID}+L_{CM}+L_{IM}+λL_{SR}$, where $λ = 0.6$.

3. Experiments

Dataset Configuration

As shown in the figure above, the paper uses the above 5 datasets.

Ablation Experiments

Table 1 above shows ablation experiments conducted on the PKU-Sketch and ShoeV2 datasets, where B represents Baseline. The paper explains that the Baseline here is "ResNet-50 trained with only identity loss." Aux. indicates whether the auxiliary modality is introduced. $L_{Cir}$ represents the original circle loss, followed by the loss functions and modules designed by the paper. It can be seen that when using the complete model and loss functions proposed by the paper, all indicators are highest.

Table 2 above is to verify the impact of whether the DAG module participates in joint training updates on the entire model. $G_f$ represents fixed parameters, and $G_j$ represents parameters participating in training optimization, which refers to the convolutional kernel parameters. $L_{SR}$ refers to the style refinement loss. It can be seen that when using the $L_{SR}$ loss function to optimize the parameters of the DAG module during training, the model achieves the best performance with the highest indicators.

Comparison Experiments

Tables 3-5 above compare with current SoTA models on different datasets. It can be seen that regardless of which dataset, the model proposed in this paper achieves the highest indicators.

Visualization Display

Figure 3 performs "attention visualization comparison." The paper uses XGrad-CAM to draw attention heatmaps for two sketch queries from different viewpoints and their respective top-4 retrieved photo results, marking incorrect and correct retrievals with red and green boxes respectively. The conclusion is intuitive: the Baseline's attention easily ignores truly relevant regions between sketches and photos, especially being interfered by some similar local features when scenes and poses change. DALNet, on the other hand, can simultaneously focus on more "cross-modally shared" human body cues (such as key facial regions, clothing textures, bags, badges, etc.), so there are more correct retrievals (green boxes).

Figure 4 performs "visualization of feature distribution alignment process." The paper randomly selects 10 identities from PKU-Sketch and uses t-SNE to draw the feature distributions of the three modalities at different training epochs (brightness distinguishes different identities). The phenomenon is: at epoch=0, the distributions of photo (orange) and sketch (gray) are very different; as training progresses, auxiliary (green) acts like a "bridge" connecting the two; by epoch=50, photo and sketch gradually converge, with tighter intra-class and wider inter-class separations. Finally, at epoch=100, auxiliary features converge to their respective identity centers, indicating that the model has learned stronger identity discriminability and aligned the three-modality distributions.

Conclusion

This paper addresses the problems of large cross-modal gaps and severe intra-modal variations in sketch-based person re-identification by proposing DALNet: first, DAG generates a "sketch-like" auxiliary modality from real photos as a bridge; then a three-stream shared backbone extracts features, and through MIA, fine-grained cross-modal interactive fusion is achieved under the guidance of the auxiliary modality. Finally, classification loss and improved circle loss (including both cross-modal and intra-modal) are jointly optimized to achieve simultaneous inter-modal and intra-modal alignment.

The innovation lies in introducing trainable dynamic auxiliary modality generation and style refinement constraints to reduce modality differences, and designing the entire collaborative learning mechanism of "auxiliary-guided interactive attention and cross-modal and intra-modal circle loss," making feature distribution alignment more stable and retrieval performance stronger.

Interpretation of "Modalities collaboration and granularities interaction for fine-grained sketch-based image retrieval"

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

The paper is titled: Modalities collaboration and granularities interaction for fine-grained sketch-based image retrieval.

This paper was published in Pattern Recognition 2026.

1. Motivation

As shown in the figure above, the paper has two main motivations:

As shown in figure (a), existing methods only focus on single-modality feature extraction, ignoring the complementarity between sketches (structural outlines) and photos (texture and color). The characteristics of large cross-modal differences within the same instance and small intra-modal differences across different instances make direct alignment difficult. The complementary information between sketches and real images is not fully utilized.
As shown in figure (c), fixed-size patch partitioning produces boundary noise and fragments complete features. Meanwhile, the lack of cross-granularity feature interaction prevents the use of multi-scale contextual information to enhance discriminability.

The entire paper aims to solve these two problems.

2. Method

The figure above shows the overall framework of the proposed method. The framework is abbreviated as MCGI and can be roughly divided into 3 major modules: CMFL, CMIC, and CGPI. The CGPI module is further divided into three sub-modules: MGPM, CGII, and MGPC.

CMFL (Cross-Modality Feature Learning)

The cross-modality feature learning module is not the paper's innovation point; it can be considered a baseline module. This part uses a ViT-B/16 encoder. Sketches or images are divided into tokens, and after adding position encoding and [CLS] token, they are separately input into the L layers (12 layers) of the encoder. The outputs are $f_{cls}^{s,L}$ and $f_{cls}^{p,L}$ (the former represents sketch, the latter represents real image). These two [CLS] tokens are then fed into classifiers $W_s$ and $W_p$ respectively, and cross-entropy losses $L_{ce}^s$ and $L_{ce}^{p}$ are calculated for the classification results. At the same time, basic cross-modal alignment is performed. The paper uses triplet loss with mutual alignment, calculating triplet losses $L_{tri}^s$ and $L_{tri}^{p}$. The specific formulas are shown in the figure below:

CMIC (Cross-Modality Information Compensation)

The cross-modality information compensation module is the first innovation point proposed in the paper to solve problem 1 in the motivation. The method involves exchanging tokens from the l-th layer output (the paper sets l = 11). The exchange method preserves the [CLS] token without exchanging it, only exchanging the N patch tokens. The token sets before exchange are denoted as $F^{s,l}$ and $F^{p,l}$ (the former for sketch, the latter for real image), and after exchange as $\bar{F}^{s,l}$ and $\bar{F}^{p,l}$. Then the exchanged token sets pass through the remaining $L - l$ layers to obtain outputs. The [CLS] tokens from both sides are extracted, denoted as $\bar{f}{cls}^{s,L}$ and $\bar{f}{cls}^{p,L}$, and these two tokens are used to calculate cross-entropy losses $L_{ce}^{s,2}$ and $L_{ce}^{p,2}$ following the same approach as CMFL.

However, there is an issue: while we know the pairing relationship between sketches and images during training, we don't know the pairing relationship during inference. Therefore, the paper designs a relational knowledge distillation. The two [CLS] tokens output from the CMFL module: $f_{cls}^{s,L}$ and $f_{cls}^{p,L}$ are separately fed into two MLPs to simulate the output after token exchange, and loss functions $L_{rkd}^{s}$ and $L_{rkd}^p$ are designed for distillation. The specific formulas are as follows, where $\psi_D$ represents the distance function, $\mu$ represents the normalization factor for distance, and $l_{\delta}$ represents the Huber loss function.

CGPI (Cross-Granularity Prototype Interaction)

The cross-granularity prototype interaction module is the second innovation point of the paper, designed to solve problem 2 in the motivation. This module is further divided into the following three sub-modules.

MGPM (Multi-Granularity Prototype Learning Module)

The multi-granularity prototype learning module has two abbreviations in the paper: MGPM and MGPL. The paper's framework diagram uses MGPM, while the text description uses MGPL. For consistency and ease of explanation, I will use MGPM here.

This module takes the patch token output (excluding [CLS] token) from layer L - 1. The outputs for sketch and real image are $[f_1^{s,L-1},f_2^{s,L-1},...,f_n^{s,L-1}]$ and $[f_1^{p,L-1},f_2^{p,L-1},...,f_n^{p,L-1}]$ respectively. These are then evenly divided into $M$ groups (the paper sets $M = 7$), with each group containing $\frac{n}{M}$ tokens. Then, these groups are progressively aggregated to form feature sequences of different granularities: $[f_1^{s,L-1},f_{1:2}^{s,L-1},...,f_{1:M}^{s,L-1}]$ and $[f_1^{p,L-1},f_{1:2}^{p,L-1},...,f_{1:M}^{p,L-1}]$, where $1 : i$ represents the concatenation of tokens from the first $i$ groups.

To enhance the discriminability of these multi-granularity features, the paper introduces learnable multi-granularity shared prototypes $P = [P_1, P_2, ..., P_M]$, concatenating each granularity's prototype with corresponding 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})]$ and $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})]$, where $C(·)$ represents the concatenation operation. These prototypes function similarly to [CLS] tokens, with each prototype $P_i$ responsible for aggregating the global feature representation of the i-th granularity.

Then $Z_s$ and $Z_p$ are separately fed into the L-th layer Transformer Encoder to obtain $F^s$ and $F^p$. The detailed flow diagram and formulas are shown below.

CGII (Cross-granularity Information Interaction)

The cross-granularity information interaction module continues to process the output from the previous module. This module introduces two external memory units $M_k$ and $M_v$ as Key and Value, using multi-granularity prototype features $F_s$ and $F_p$ as Query, and calculates cross-granularity attention weights to capture contextual associations between different granularities. Through multi-head attention mechanism, information from different granularities is aggregated, outputting enhanced multi-granularity features $\tilde{F}_s = [\tilde{P}_1^s, \tilde{P}_2^s, ..., \tilde{P}_M^s]$ and $\tilde{F}_p = [\tilde{P}_1^p, \tilde{P}_2^p, ..., \tilde{P}M^p]$. Finally, these are concatenated with the global [CLS] token to obtain complete enhanced feature sets $f_s^{en} = [f{cls}^{s,L}, \tilde{P}_1^s, \tilde{P}_2^s, ..., \tilde{P}M^s]$ and $f_p^{en} = [f{cls}^{p,L}, \tilde{P}_1^p, \tilde{P}_2^p, ..., \tilde{P}_M^p]$. The specific process is shown below:

MGPC (Multi-Granularity Prototype-aware Contrastive Loss)

The multi-granularity prototype-aware contrastive loss module uses the outputs $f_{en}^s$ and $f_{en}^p$ from the previous module to calculate contrastive loss $L_{mgpc}$ for further alignment of cross-modal multi-granularity feature representations. This loss increases the similarity of positive sample pairs (matched sketch-photo pairs) in the multi-granularity feature space while decreasing the similarity of negative sample pairs, promoting feature alignment between sketches and photos at the multi-granularity level. The specific process and formulas are as follows:

The total loss is the weighted sum of all the above losses, where $\lambda_1 = 0.6$ and $\lambda_2 = 1.0$. The optimization of these two parameters will be explored in later experiments.

3. Experiments

Dataset Settings

The experimental setup uses four datasets:

These are the chair dataset, shoe dataset, clothing dataset, and pedestrian dataset.

Comparison with State-of-the-Art Methods

The three tables above show comparisons with current state-of-the-art methods on different datasets. The paper's model demonstrates overall better performance, especially on the chair and shoe datasets, showing improvements across all metrics.

Ablation Studies

As shown above, the first table presents ablation study analysis on the shoe dataset, exploring the role of the four innovative modules proposed in the paper. The results show that metrics are highest only when all modules are used, indicating that each module is indispensable.

The second table provides ablation analysis for each loss function, also conducted on the shoe dataset. Removing any loss function leads to varying degrees of performance degradation. These results validate the effective contribution of each proposed loss function to the overall model performance.

Hyperparameter Analysis

As shown above, figure (a) demonstrates the impact of token exchange at different layers on model performance. Experimental results show that as layer $l$ increases, accuracy and mAP gradually rise, reaching their peak at $l = 11$, which is why the paper sets $l = 11$.

Figure (b) shows the impact of multi-granularity number $M$ (i.e., the number of groups mentioned earlier) on model performance. Experimental results indicate that when $M = 7$, overall metrics are best with the highest mAP.

Figure (c) compares the performance difference between the proposed MGPM module and the traditional fixed patch partitioning strategy (PCB). Experimental results show that MGPL significantly outperforms PCB across all evaluation metrics, validating the effectiveness of the hierarchical granularity partitioning strategy. Therefore, the paper adopts MGPM as the multi-granularity feature learning method.

The last two line graphs experiment with the impact of $\lambda_1$ and $\lambda_2$ values on the experiments, showing that the best results are achieved when $\lambda_1=0.6$ and $\lambda_2=1.0$.

Experimental Visualization

The figure above shows visualization of retrieval results using the proposed method on four datasets, where green boxes indicate correctly retrieved images and red boxes indicate incorrectly retrieved images. The method successfully ranks correct target images in higher positions. This improvement is evident across different types of datasets including chairs, shoes, clothing, and pedestrians, demonstrating the good generalization capability of the framework.

4. Conclusion

The MCGI framework addresses fine-grained sketch-based image retrieval by leveraging cross-modal complementary information and cross-granularity contextual associations, thereby bridging modality gaps and enhancing feature discriminability.

The Cross-Modality Information Compensation (CMIC) module integrates complementary information from sketches and photos through token exchange and knowledge distillation to learn modality-robust feature representations.

The Cross-Granularity Prototype Interaction (CGPI) module hierarchically extracts multi-granularity features and models their contextual interactions to capture discriminative fine-grained information.

Extensive experiments on four benchmark datasets demonstrate state-of-the-art performance, achieving 78.6% Rank-1 accuracy on QMUL-Chair-V2, 44.5% on QMUL-Shoe-V2, 96.0% on Clothes-V1, and 91.5% on Sketch Re-ID.

Ablation studies validate the effectiveness of individual components, where CMIC improves modality robustness and CGPI enhances fine-grained discriminability through hierarchical feature learning and cross-granularity interaction.

A Brief Exploration of Spring Transactions

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

1. What is a Transaction

Definition of Transaction

A transaction typically refers to a group of activities or events that are treated as a single unit of execution.

For example, in a bank transfer, when Account A transfers 100 yuan to Account B, the following two operations are required:

Account A's balance decreases by 100 yuan
Account B's balance increases by 100 yuan

These two operations must either succeed together or fail together. If Account A's balance decreases but Account B's balance doesn't increase, or if Account A's balance remains unchanged while Account B's balance increases, this would result in data inconsistency issues, meaning the banking system has encountered an error and the accounting records are no longer reliable.

Transactions exist to solve problems like the one described above. This is the significance of transactions: to ensure operations either complete entirely or fail entirely, avoiding data errors caused by partial completion, thereby maintaining data consistency and integrity.

Properties of Transactions

Transactions have four ACID properties: Atomicity, Consistency, Isolation, and Durability.

Atomicity: Transactions are indivisible.

Consistency: Data maintains a valid state before and after the transaction.

Isolation: Multiple transactions do not interfere with each other.

Durability: Data is permanently saved after commit.

2. Transactions in MySQL

Important Notes

Not all storage engines in MySQL support transactions:

Supports transactions: InnoDB (default)
Does not support transactions: MyISAM (does not support transactions, data operations cannot be rolled back)

Before using transactions, please ensure the table uses the InnoDB engine.

Basic Transaction Operations

In MySQL, we can use START TRANSACTION or BEGIN to start a transaction, then execute SQL operations. Then use COMMIT to commit the transaction or use ROLLBACK to roll back the transaction.

Let's use the bank transfer example above. First, create a simplified user balance table and initialize some data:

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);

Note: In normal projects, primary keys are usually integer types. Here, for the sake of the example above and ease of explanation, it's set to char type.

Next, we enter START TRANSACTION in the console to start the transaction.

Now we create a transfer operation and execute it:

-- Deduct from Account A's balance
UPDATE accounts
SET balance = balance - 100
WHERE id = 'A';

-- Add to Account B's balance
UPDATE accounts
SET balance = balance + 100
WHERE id = 'B';

At this point, we use SELECT * FROM accounts to view the current table state:

We can see the operation was successful - the balances of A and B have changed. However, when we now return to IDEA's database tool panel to view the table data, we find the balances haven't changed:

This demonstrates transaction isolation. These modifications are only visible within the transaction. In the same session, modifications to data before the transaction is committed are visible, but for other sessions, these modifications remain invisible until the transaction is committed and take effect externally. When we open the database tool panel in IDEA to view table data, it's equivalent to opening a new session, which is independent from the previous transaction, so the data hasn't changed.

If we now use COMMIT to commit the transaction, the data is officially written to the database table for persistence - this is the durability of transactions.

At this point, we'll find that the table data in IDEA's database tool has been modified:

Similarly, using ROLLBACK can undo all uncommitted operations in the transaction, restoring the data to the state before the transaction began. This way, even if multiple modifications are made within the transaction, they won't affect the actual database data, implementing atomicity and consistency.

3. Transactions in Spring

Demo Example

We write the following code:

@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);
    }

}

In AccountsService, we define a simple transfer method. In this method, we deliberately write 1/0 to throw a runtime exception. After running it, we'll check whether the data in the database has changed after the exception is thrown.

We create a test unit:

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

After running, we find an exception is thrown:

When we check the database table, we find there's a problem:

Account A's balance decreased by 100 yuan, but Account B's balance didn't increase. The total balance of 1500 inexplicably decreased by 100 yuan, causing problems with data consistency and integrity.

In the AccountsService code, accountsMapper.updateByDelta(id1,BigDecimal.ZERO.subtract(delta)); ran successfully first, but after the exception was thrown, the following accountsMapper.updateByDelta(id2,delta); didn't execute, causing the above problem. What we want is for both update operations to either succeed together or fail together. Therefore, we must encapsulate these two update operations into a single transaction. If one fails, everything should ROLLBACK.

Basic Usage of `@Transactional`

In the Spring framework, transaction management is implemented through Spring's transaction abstraction, which allows us to conveniently manage transactions in business code without directly operating the database's START TRANSACTION, COMMIT, or ROLLBACK.

In the Spring framework, we often use the @Transactional annotation to declare that a method or class needs to execute within a transaction. Spring automatically starts a transaction before method execution, commits the transaction after successful execution, and if a RuntimeException or Error occurs during execution, the transaction automatically rolls back, ensuring the atomicity and consistency of operations.

@Transactional can be added to methods or classes. If added to a method, it only affects that method - the transaction is only opened when executing that method. If added to a class, it applies to all public methods in the class, equivalent to adding transactions to each public method. However, in actual development, it's usually only added to methods that need it, rather than directly on the class.

Now let's add the @Transactional annotation to the transfer method in AccountsService:

@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);
    }

}

For comparison, I'll first restore the database data to 900 and 600.

Run the unit test again, and after the exception is thrown, check the database result:

After refreshing, we can see the data hasn't changed at all, indicating the transaction successfully rolled back. When the transfer method executes to 1/0 and throws an ArithmeticException, Spring detects the runtime exception and automatically triggers a transaction rollback, undoing the previous deduction from Account A, ensuring data consistency.

If we now delete the 1/0 code and run again, there are no exceptions, so it will COMMIT successfully. Refresh the database table as shown below:

Advanced Usage of `@Transactional`

`rollBackFor` Property

OK, we just mentioned that it automatically rolls back when encountering runtime exceptions. But what if the exception is not a runtime exception? Will it still automatically roll back? Let's test it. We modify the transfer code as follows:

@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("Manually thrown exception~");
        }
        accountsMapper.updateByDelta(id2,delta);
    }
}

Using if(true) makes the compiler think the following statement might be executed, so it won't report a compilation error - essentially "tricking" the compiler.

In the unit test, we catch the exception:

@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);
        }
    }
}

After running the unit test, refresh and check the database table - we find there's a problem again:

It's the same as the initial situation. Even with @Transactional, the same problem occurs - A's balance decreased, B's balance didn't increase. Why is this?

As we just mentioned, @Transactional by default only automatically rolls back for runtime exceptions. Since ArithmeticException is a subclass of RuntimeException, it can automatically roll back, but Exception is not a runtime exception, so it cannot automatically roll back.

What can we do? Do we have no way to solve this problem? Let's immediately look at the source code of @Transactional to see if there are any properties we can set in this annotation.

@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 {};
}

We discovered Class<? extends Throwable>[] rollbackFor() default {};. Looking at the name rollbackFor - rollback for... - isn't this exactly what we want? It takes a Class array as input. Let's immediately return to our transfer method and add this property:

@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("Manually thrown exception~");
        }
        accountsMapper.updateByDelta(id2,delta);
    }
}

Then we restore the database data to 800 and 700, and run the unit test again with the following result:

Now it's perfect. The exception was thrown and the data wasn't modified, indicating a ROLLBACK occurred.

Transaction Propagation Behavior

Good, but we have another question. In our projects, we often have business logic for storing operation logs. Let's create an accounts_log table:

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

Please note, this is a simplified log table. In normal project development, it's not this simple - there are many other fields, such as log type, etc.

Then create an entity class:

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

Create a Mapper:

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

Create a Service:

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

}

Refactor the transfer code:

@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 + " initiated transfer to "
                + id2 + " of " + delta + " yuan, ";
        try {
            accountsMapper.updateByDelta(id1,BigDecimal.ZERO.subtract(delta));
            if(true){
                throw new Exception("Manually thrown exception~");
            }
            accountsMapper.updateByDelta(id2,delta);
            message = "Succeeded!";
        } catch (Exception e){
            message += "but failed!";
            throw e;//continue throwing exception, otherwise @Transactional won't detect it
        }finally {
            accountsLogService.insert(new AccountsLog(null,message));
        }
    }

}

We require that logs be recorded whether the transfer succeeds or fails. If we only write it this way, after running the unit test we find:

The exception was thrown, but there's no data in the accounts_log table. This is because although accountsLogService.insert is called in finally, the operation is still constrained by the same transaction method. As long as there's an exception, all modifications will be rolled back, including operations in finally. So how do we solve this problem?

In the Transactional source code, we see a property Propagation propagation() default Propagation.REQUIRED;. This property is used to control transaction propagation behavior, i.e., when a transaction method is called by another transaction method, how to handle the transaction issue.

Spring defines 7 transaction propagation behaviors:

Propagation Behavior	Description
REQUIRED (default)	If a transaction exists, join it; if no transaction exists, create a new one
REQUIRES_NEW	Always create a new transaction; if a transaction exists, suspend the current transaction
SUPPORTS	If a transaction exists, join it; if no transaction exists, execute non-transactionally
NOT_SUPPORTED	Execute non-transactionally; if a transaction exists, suspend the current transaction
MANDATORY	If a transaction exists, join it; if no transaction exists, throw an exception
NEVER	Execute non-transactionally; if a transaction exists, throw an exception
NESTED	If a transaction exists, execute within a nested transaction; if no transaction exists, create a new one

For our logging requirement, we should use Propagation.REQUIRES_NEW, which creates a completely independent new transaction that is not affected by the outer transaction's rollback.

We modify AccountsLogService as follows:

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

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

}

Now let's run the unit test again and check the database table result:

Perfect! Our log was added successfully. For this current example, when executing the inner transaction, the outer transaction is suspended and waits for the inner transaction's lifecycle to end before resuming the outer transaction.

However, in actual project development, we mostly use the default propagation method (about 85% ~ 90% of scenarios), followed by REQUIRES_NEW (about 5% ~ 10%). Other propagation methods are used less frequently. Interested readers can explore them on their own.

Spring Bean Scope and Lifecycle

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

The default scope of Spring Beans is Singleton, but it also supports modification to Prototype. So how do we implement this specifically?

Singleton

Let's first understand what singleton means.

Let me give a somewhat inappropriate example. We'll write a configuration class ArrayListConfig to put ArrayList under IOC container management, as follows:

@Configuration
public class ArrayListConfig {

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

}

Note that in practice, when developing projects, we wouldn't normally have IOC manage the lifecycle of ArrayList. This is just for demonstration and learning purposes.

Alright, now that we've created this configuration class, let's write a unit test:

@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);
}

So, what do you think the output will be?

Both output [1, 2]. This is Singleton. When the IOC container starts, it creates a Bean instance, and after that, all the objects we get through autowiring point to the same Bean instance, which is why they output the same content.

So how can we make these two ArrayLists point to different Bean instances? This requires us to use Prototype.

Prototype

Implementing prototype is simple. We just need to use the @Scope annotation, for example:

@Configuration
public class ArrayListConfig {

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

}

As shown above, we've now achieved the desired effect. This is prototype scope.

In fact, singleton is @Scope("singleton"), but we usually omit it.

@Scope can also be combined with @Component and other annotations to directly implement singleton or prototype when defining a class. I won't demonstrate this here.

Note: Prototype Beans are sometimes also called prototype Beans.

Bean Lifecycle

I wonder if you've ever thought about the lifecycle of Beans.

For example, when are the Beans managed by the IOC container created? Like the ArrayList above, is it created when we first use it, or is it created as soon as the container starts?

To facilitate testing, let me manually create a class and have IOC manage it, as follows:

@Component
public class Kunkun {
    public Kunkun() {
        System.out.println("Kunkun was born!");
    }
}

Then let's write a unit test:

@Test
void test2(){
    
}

As shown above, we find that even without using Kunkun (we didn't @Autowired a Kunkun), the Kunkun constructor was still called. This means that by default, the container initializes singleton Beans when it starts.

Sometimes, creating all Bean objects in advance can be a waste of resources. Can we do this: only create the Bean when we first use it, and then just get it from the IOC container for subsequent uses? Yes, we can. We just need to add the @Lazy annotation, for example:

@Component
@Lazy
public class Kunkun {
    public Kunkun() {
        System.out.println("Kunkun was born!");
    }
}

Now if we run the unit test Test2 again, there won't be any output.

Now let's modify the unit test as follows:

@Autowired
private Kunkun kunkun;

@Test
void test2(){
    
}

When we run it now, we find:

This shows that the Kunkun Bean object was created only when it was used.

Please note that everything we've discussed above is for singleton Beans. What about prototype Beans?

Let's add @Scope("prototype") to the class, as follows:

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 was born!");
    }
}

Now let's not declare and create Kunkun, and see if the constructor appears when starting.

After testing, we find that there is indeed no output related to Kunkun's constructor. This means that for prototype Beans, they are not initialized and created when the IOC container starts.

So let's @Autowired two Kunkuns, as follows:

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

}

After running, the output is:

As you can see, the constructor was called successfully. We can easily conclude that for prototype Beans, lazy loading is the default. If you still want to add @Lazy, it won't cause an error, but adding it has no real effect.

Now that we've discussed the creation of singleton and prototype Beans, let's talk about destruction.

First, let's look at singleton Bean destruction:

There's an annotation @PreDestroy. Methods annotated with it will be automatically executed when the Bean is destroyed, for example:

@Component
public class Kunkun {
    public Kunkun() {
        System.out.println("Kunkun was born!");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("Kunkun is being destroyed~");
    }
}

Let's write a unit test and @Autowired a Kunkun to see the effect:

As we can see, for singleton Beans, when the container is destroyed, the Bean instance is also destroyed.

Now let's turn it into a prototype Bean and experiment:

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("Kunkun was born!");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("Kunkun is being destroyed~");
    }
}

In the unit test, @Autowired two Kunkuns and test:

We find that only the constructor was called, but after the container was destroyed, the Bean objects were not destroyed. This is because for prototype Beans, the container doesn't manage their destruction. You must manually force destruction, as follows:

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

Summary

Default Scope
- Spring Beans are singleton (Singleton) by default, sharing one instance across the entire container.
- You can use @Scope("prototype") for "prototype (Prototype)" to create a new instance each time one is obtained.
Creation Timing
- Singleton Bean: Created when the container starts (when not @Lazy)
- Prototype Bean: Created each time it's obtained, lazy loading by default
- @Lazy: Used to delay singleton Bean initialization, has no practical meaning for prototype Beans
Destruction Mechanism
- Singleton Bean: Automatically destroyed when the container closes, supports @PreDestroy or DisposableBean.destroy()
- Prototype Bean: Not managed by the container for destruction, requires manual invocation of destruction methods
Use Cases
- Singleton: Globally shared objects, service classes, configuration classes
- Prototype: Temporary objects, short-term use objects, frequently created computation or task objects
Key Points
- Singleton Beans have a long lifecycle, fully managed by the container
- Prototype Beans have a short lifecycle, developers are responsible for resource release
- @Lazy mainly optimizes singleton Bean initialization, reducing startup overhead

Injecting Third-Party Beans into IoC Container

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

During actual development, we often need to integrate various third-party libraries to improve development efficiency or extend system functionality. However, when using the Spring or Spring Boot framework, how to properly register components from these third-party libraries into the IoC container often becomes a problem that needs to be solved.

Manual Registration with @Bean

Taking the third-party utility package HuTool as an example, first we introduce the Maven dependency for HuTool:

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

In HuTool, if we want to use the cn.hutool.http.HttpUtil utility class, we hope to use it like this:

@Autowired
private HttpUtil httpUtil;

But obviously, writing it directly like this will result in an error:

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

This is because all classes in Hutool use static methods and are not registered in the Spring container.

We can manually create a Bean in a configuration class using the @Bean annotation:

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

Then we perform a unit test:

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

When creating a Bean in a configuration class, if you need to pass parameters, and if the IoC container has this parameter type, it can be auto-injected. For example:

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

This is equivalent to omitting:

@Autowired
HttpSecurity http;

@ComponentScan — Extending Scan Paths

If certain classes in a third-party library already use annotations like @Component, @Service, @Repository, but these classes are not under our default scan path, we can extend the scan range through @ComponentScan.

@SpringBootApplication
@ComponentScan(basePackages = {
    "com.example.myapp",           // Your project package path
    "com.baomidou.mybatisplus.extension.plugins"  // Third-party library package path
})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

basePackages is an array. Once @ComponentScan is used, the default scan path in @SpringBootApplication becomes ineffective, and we must configure our project's package path in basePackages, then add the third-party library's package path.

@Import to Directly Import Configuration Classes

Using @Import can directly import configuration classes or regular classes into the Spring container:

// Third-party configuration class
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);
    }
}

// Import in main configuration class
@Configuration
@Import(RedissonConfig.class)
public class ApplicationConfig {
}

Or use it directly on the startup class:

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

Importing Regular Classes

@Import can also directly import regular classes without any annotations:

// Third-party regular class
public class DataConverter {
    public String convert(Object data) {
        return JSON.toJSONString(data);
    }
}

// Import configuration
@Configuration
@Import(DataConverter.class)
public class ConverterConfig {
}

After importing, it can be directly injected and used:

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

ImportSelector for Dynamic Bean Registration

ImportSelector allows us to dynamically select which configuration classes to import based on conditions, which is very useful when we need to register Beans dynamically based on environment or configuration.

// Custom ImportSelector
public class ElasticsearchImportSelector implements ImportSelector {
    
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // Can dynamically decide which configuration classes to import based on annotation attributes, environment variables, etc.
        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"
            };
        }
        
        // Default configuration
        return new String[]{
            "com.example.config.ElasticsearchDefaultConfig"
        };
    }
}

// Configuration class
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);
    }
}

// Use in configuration class
@Configuration
@Import(ElasticsearchImportSelector.class)
public class SearchConfig {
}

More Complex Example: Conditional Import

public class ConditionalImportSelector implements ImportSelector {
    
    @Override
    public String[] selectImports(AnnotationMetadata metadata) {
        List<String> imports = new ArrayList<>();
        
        // Check if a certain class exists in the classpath
        if (ClassUtils.isPresent("com.example.ThirdPartyClass", null)) {
            imports.add("com.example.config.ThirdPartyConfig");
        }
        
        // Check system properties
        if ("true".equals(System.getProperty("enable.cache"))) {
            imports.add("com.example.config.CacheConfig");
        }
        
        // Check environment variables
        String profile = System.getenv("SPRING_PROFILES_ACTIVE");
        if ("prod".equals(profile)) {
            imports.add("com.example.config.ProdConfig");
        }
        
        return imports.toArray(new String[0]);
    }
}

Using DeferredImportSelector

If you need to perform imports after all @Configuration classes have been processed, you can implement the DeferredImportSelector interface:

public class DeferredElasticsearchImportSelector implements DeferredImportSelector {
    
    @Override
    public String[] selectImports(AnnotationMetadata metadata) {
        // Deferred import logic
        return new String[]{"com.example.config.ElasticsearchConfig"};
    }
}

@EnableXxx Composite Annotations

@EnableXxx is a high-level encapsulated configuration approach that typically combines @Import with other annotations, providing users with a simple switch to enable a certain functional module.

@EnableXxx can be placed on the startup class or on a configuration class.

Spring AOP

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

1. Spring AOP Annotation Explanation

@Before

Executed before the target method runs. Commonly used for logging, parameter validation, permission checks, etc.
When the defined pointcut expression is matched, Spring executes this method before calling the target method.

@Around

An around advice wraps the entire execution process of the target method.
By calling ProceedingJoinPoint.proceed() explicitly, it can add custom logic before and after the method execution.
This is the most flexible advice type — it can control whether the method executes, modify parameters, or process return values.

@After

Executed after the target method finishes, regardless of whether an exception occurred.
Similar to a finally block, it’s often used for resource cleanup or general logging.

@AfterReturning

Executed only when the target method returns normally.
If the method throws an exception, this advice will not run.
Often used to process the return value or log successful execution.

@AfterThrowing

Executed when the target method throws an exception.
Useful for logging exception details, sending alerts, or collecting error statistics.

@Pointcut

@Pointcut is used to extract pointcut expressions, which define where advices apply.
Instead of writing execution(...) repeatedly, you can define it once as a method and reuse it across multiple advices for better readability and maintainability.

Example:

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

Then reuse it:

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

2. Spring AOP Example (Using @Pointcut Extraction)

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 {

    // Extracted pointcut expression matching all methods under service.impl package
    @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 ....");
    }
}

Execution order when the method runs normally: @Around → @Before → method execution → @AfterReturning → @After → @Around

Execution order when the method throws an exception: @Around → @Before → method execution → @AfterThrowing → @After → @Around

Using these annotations together allows injecting logic at different stages — ideal for unified logging, monitoring, or security. @Pointcut makes the structure cleaner by allowing multiple advices to share the same matching rules.

If different methods need their own pointcut expressions, they can be written separately, for example:

@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. Multiple Advice Execution Order

In Spring AOP, the execution order of multiple advices follows these rules:

Within the same aspect class:

Default natural order: @Around → @Before → target method → @AfterReturning/@AfterThrowing → @After → @Around
If there are multiple advices of the same type (e.g., several @Before), they execute in alphabetical order of method names.
For @Before, smaller alphabetical order executes earlier; for @After, smaller alphabetical order executes later.

Between different aspect classes:

By default, class names determine the order (alphabetical).
You can control priority using @Order or implementing Ordered.
A smaller @Order value means higher priority — it executes @Before earlier and @After later.

Example:

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

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

Execution overview:

Outer aspect @Around
    ↓
  Inner aspect @Around
      ↓
    @Before (outer to inner)
        ↓
     Target method
        ↓
    @AfterReturning / @AfterThrowing (inner to outer)
        ↓
    @After (inner to outer)
    ↓
  Inner @Around ends
↓
Outer @Around ends

This mechanism ensures predictable and precisely controlled AOP execution order when multiple aspects or advices exist.

4. Pointcut Expressions

execution

execution matches based on method return type, package name, class name, method name, and parameters.

Syntax: execution(modifier? return-type package.class.?method(parameters) throws exception?) Parts marked with ? are optional.

Modifier: optional (e.g., public, protected)
Package/class: optional but recommended
throws: optional (refers to declared exceptions, not runtime ones)

* matches any single element — return type, package, class, method, or parameter.

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

.. matches multiple consecutive elements — nested packages or any number of parameters.

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

annotation

Matches methods annotated with a specific annotation. Example annotation:

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

Applied to a method:

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

Used in an aspect:

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

In IDEs like IntelliJ, the m icon can confirm the match visually.

5. JoinPoint

In Spring, JoinPoint abstracts a connection point, allowing access to method execution details such as class name, method name, and arguments.

For @Around, use ProceedingJoinPoint; for the other four types, use JoinPoint, which is the parent of ProceedingJoinPoint.

Example:

@Before("@annotation(top.mygld.demo.anno.LogOperation)")
public void before(JoinPoint jp){
    log.info("before");
    // 1. Get target object
    Object target = jp.getTarget();
    log.info("target: {}", target);
        
    // 2. Get target class
    String name = target.getClass().getName();
    log.info("name: {}", name);
        
    // 3. Get target method
    String methodName = jp.getSignature().getName();
    log.info("methodName: {}", methodName);
        
    // 4. Get method arguments
    Object[] args = jp.getArgs();
    log.info("args: {}", args);
}

ProceedingJoinPoint can execute the target method, while JoinPoint cannot. The former is a subclass of the latter.

volatile Keyword

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

volatile keyword

Now we have the following two pieces of code:

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("Thread starts executing, current a = " + a);
        a = 1;
        System.out.println("Thread finishes executing, current 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("Detected a = 1");
                break;
            }
        }
    }
}

So, if we run the main class, what do you think the result will be?

Based on our prior knowledge, we would expect that the program first creates thread t, then starts it. Thread t executes concurrently with the main thread. The main thread enters an infinite loop, waiting and monitoring the shared member a in MyThread. After thread t sleeps for 1 second and then sets a = 1, the main thread detects that a has changed and breaks out of the loop, ending the program. In other words, the expected sequential output would be:

Thread starts executing, current a = 0
Thread finishes executing, current a = 1
Detected a = 1

Then the program ends. This is what we would reason from the code, but is this really what happens? Let's try it:

We find that the program only prints the content from thread t, but after that it does not terminate—it keeps running indefinitely, even if we wait for a long time. Why is that?

This problem is called visibility in multithreading, which refers to whether a thread can immediately see changes made to a shared variable by another thread.

There are many causes for visibility issues. In this case, it is mainly because modern CPUs often cache variable values in registers or local caches rather than reading from main memory each time.

In simple terms, for a static shared variable, to avoid multiple threads modifying main memory directly and causing problems, Java first copies the shared variable into the thread's working memory when reading it. If the thread does not modify this copy, it does not fetch the latest value from main memory. Only when the thread modifies its copy does it synchronize the change back to the shared variable in main memory.

So the problem above can be explained as follows: thread t sleeps for 1 second first, which allows the main thread to execute if(MyThread.a == 1) first. The main thread gets a copy of a, whose value is 0. When thread t wakes up and sets a = 1, even though it is synchronized to the shared variable, the main thread has not modified its copy, so it never fetches the latest value and keeps using the original copy with a = 0. This leads to an infinite loop in the main thread.

One might think: we just need the main thread to refresh the value of a. This is possible, and there are several ways to do it:

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("Detected a = 1");
                break;
            }
        }
    }
}

Here, adding Thread.sleep(milliseconds) inside the while loop causes the main thread to block. Once it resumes, it fetches the latest value of the shared variable. The output is:

The program now behaves as expected and terminates normally. Other methods include:

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("Detected 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("Detected a = 1");
                break;
            }
        }
    }
}

These methods use the fact that exiting a synchronized block or forcing a thread refresh will fetch the latest value of the shared variable. Note that the second method is deprecated.

Is there a direct way to solve the shared variable inconsistency? Yes, the volatile keyword. When a shared variable is declared volatile, writes are immediately flushed to main memory, and reads are forced to fetch the latest value from main memory into the thread's working memory (copy), rather than using an old local copy.

For example:

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("Thread starts executing, current a = " + a);
        a = 1;
        System.out.println("Thread finishes executing, current 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("Detected a = 1");
                break;
            }
        }
    }
}

As you can see, it works as intended.

volatile also works for non-static instance variables.

In addition, volatile can prevent instruction reordering. Although reordering has less impact than the randomness of multithreading, this effect is still worth noting.

Vocabulary and Idiom Accumulation

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

The current article does not support English. Please switch to Chinese to view it.

Thread Pool

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

Core Principles of Thread Pool

Create a pool, the pool is initially empty
When submitting tasks, the pool creates new thread objects. After task completion, threads are returned to the pool. When submitting tasks again, there's no need to create new threads, existing threads can be reused directly
However, if there are no idle threads in the pool when submitting tasks, and no new threads can be created, tasks will queue and wait

Creating Thread Pools

Thread pool creation mainly uses two methods from the Executors utility class: newCachedThreadPool and newFixedThreadPool. The former creates a thread pool with no upper limit, while the latter creates a thread pool with an upper limit. Both return an ExecutorService object:

ExecutorService e1 = Executors.newCachedThreadPool(); //Create an unlimited thread pool
ExecutorService e2 = Executors.newFixedThreadPool(3); //Create a thread pool that can contain at most 5 threads

Submitting Tasks to Thread Pool

Next, we'll test whether the thread pool can really achieve the expected effect. Common methods for submitting tasks are submit or execute. Usually, execute(Runnable) submits tasks for execution only without returning results, while submit(Runnable) returns a Future that can be used to get execution status or exception information.

We perform the following test:

public class Main {
    public static void main(String[] args){
        //Create threads
        ExecutorService e1 = Executors.newCachedThreadPool(); //Create an unlimited thread pool
        //ExecutorService e2 = Executors.newFixedThreadPool(5); //Create a thread pool that can contain at most 5 threads
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " is running.");
            }
        };
        e1.submit(r);
    }
}

As shown above, the thread is already executing. Notice that the program doesn't end, so we need to destroy the thread pool when it's no longer needed, although generally thread pools don't need to be closed.

Let's test with more threads:

public class Main {
    public static void main(String[] args){
        //Create threads
        ExecutorService e1 = Executors.newCachedThreadPool(); //Create an unlimited thread pool
        //ExecutorService e2 = Executors.newFixedThreadPool(5); //Create a thread pool that can contain at most 5 threads
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " is running.");
            }
        };
        e1.submit(r);
        e1.submit(r);
        e1.submit(r);
        e1.submit(r);
        e1.submit(r);
    }
}

As shown, we added 5 tasks. For further testing, we'll add a short sleep before adding tasks to verify whether thread objects that have finished execution in the thread pool can be reused:

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 {
        //Create threads
        ExecutorService e1 = Executors.newCachedThreadPool(); //Create an unlimited thread pool
        //ExecutorService e2 = Executors.newFixedThreadPool(5); //Create a thread pool that can contain at most 5 threads
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " is running.");
            }
        };
        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);
    }
}

As shown above, thread 1 is reused multiple times after completion.

Now let's test 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 {
        //Create threads
        //ExecutorService e1 = Executors.newCachedThreadPool(); //Create an unlimited thread pool
        ExecutorService e2 = Executors.newFixedThreadPool(3); //Create a thread pool that can contain at most 5 threads
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " is running.");
            }
        };
        e2.submit(r);
        e2.submit(r);
        e2.submit(r);
        e2.submit(r);
        e2.submit(r);
    }
}

Perfect! As shown above, at most 3 threads can be used.

Thread Pool Destruction

For unused thread pools, simply use the shutdown method to destroy them. No demonstration here.

Custom Thread Pool

Besides using factory methods provided by Executors, we can also create a more flexible and controllable thread pool through ThreadPoolExecutor. Its constructor is as follows:

public ThreadPoolExecutor(
        int corePoolSize,        // Core thread count
        int maximumPoolSize,     // Maximum thread count
        long keepAliveTime,      // Maximum survival time for non-core threads
        TimeUnit unit,           // Time unit for survival time
        BlockingQueue<Runnable> workQueue, // Task queue
        ThreadFactory threadFactory,       // Thread factory for creating new threads
        RejectedExecutionHandler handler   // Rejection policy
)

Parameter Meanings

corePoolSize Core thread count, the number of threads the thread pool will always maintain, even if these threads are idle.
maximumPoolSize Maximum thread count, the maximum number of threads the thread pool can expand to when there are too many tasks.
keepAliveTime & unit Survival time for non-core threads (beyond corePoolSize) when idle, they will be recycled after timeout.
workQueue Blocking queue for storing tasks waiting to be executed. Common choices:
- ArrayBlockingQueue (bounded queue, array implementation)
- LinkedBlockingQueue (unbounded queue, linked list implementation)
- SynchronousQueue (direct task submission, no storage)
threadFactory Defines how threads are created, such as setting thread names, whether they are daemon threads, etc. Default factory is sufficient.
handler Rejection policy when both thread pool and queue are full:
- AbortPolicy (default, throws exception)
- CallerRunsPolicy (caller thread executes the task)
- DiscardPolicy (directly discard task)
- DiscardOldestPolicy (discard oldest task in queue)

Example: Custom Thread Pool

package top.mygld.demo;

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) {
        // Custom thread pool
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                2,                      // Core thread count
                5,                      // Maximum thread count
                10, TimeUnit.SECONDS,   // Non-core thread idle survival time
                new ArrayBlockingQueue<>(3),  // Bounded task queue, stores at most 3 tasks
                Executors.defaultThreadFactory(), // Default thread factory
                new ThreadPoolExecutor.AbortPolicy() // Rejection policy: throw exception directly
        );

        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " is executing task");
            try {
                Thread.sleep(2000); // Simulate time-consuming task
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        // Submit 10 tasks, observe how thread pool schedules them
        for (int i = 1; i <= 10; i++) {
            try {
                pool.execute(task);
            } catch (RejectedExecutionException e) {
                System.out.println("Task " + i + " was rejected!");
            }
        }

        pool.shutdown(); // Close thread pool
    }
}

Execution Flow Explanation

The first two tasks will directly start core threads for processing.
The next three tasks will be placed in the task queue.
When the queue is full, the thread pool will continue creating new threads (up to maximumPoolSize=5).
If both thread pool and queue are full, the 9th and 10th tasks will trigger the rejection policy, throwing exceptions directly and indicating rejection.

Maximum Parallelism

Meaning of Maximum Parallelism

CPU Level: For compute-intensive tasks, maximum parallelism is usually limited by the number of CPU cores (including hyperthreading). For example, if your CPU has 8 cores (16 threads), theoretically executing 16 computing tasks simultaneously is optimal.
Thread Pool Level: For Java's ExecutorService or ThreadPoolExecutor, maximum parallelism is the value of the thread pool's maximumPoolSize. The thread pool controls the number of simultaneously active threads based on this value.
Operating System Limitations: JVM thread count is also limited by the operating system. Usually, too many threads can cause memory overflow or excessive scheduling overhead.

Maximum parallelism can be obtained through the following code:

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

Appropriate Thread Pool Size

CPU-Intensive Computing

Maximum parallelism + 1

I/O-Intensive Computing

$Maximum\ parallelism \times Expected\ CPU\ utilization \times \frac{Total\ time(CPU\ compute\ time + wait\ time)}{CPU\ compute\ time}$

Interview Key Points

volatile
JMM
Pessimistic locks, optimistic locks, CAS
Atomicity
Concurrency utilities

These topics are frequently asked in interviews and will be organized later.

Java Dynamic Proxy

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

1. Concept

Java dynamic proxy, in my personal understanding, is essentially creating a temporary implementation class for an interface through reflection mechanism and returning an instantiated object.

Notes:

Can only proxy interfaces: JDK dynamic proxy can only create proxies for interfaces, not for concrete classes
Reflection invocation: Every method call is forwarded to InvocationHandler through reflection mechanism
Temporary class: Proxy class is generated at runtime, exists in memory, and is not persisted to disk

To put it simply, suppose Kun Kun is a big star who wants to hold a concert. Kun Kun is only responsible for singing and dancing, so setting up the stage and other tasks are definitely not done by Kun Kun himself, so we need an agent to do these things.

So we can do this:

package top.mygld.demo.test;

public class KunKun {
    public String sing(String name){
        System.out.println("Kun Kun sang: " + name);
        return "Kun Kun finished singing";
    }
    public void dance(String name){
        System.out.println("Kun Kun danced: " + name + " dance!");
    }
}
package top.mygld.demo.test;

public class ProxyPeople {
    KunKun kunKun = new KunKun();
    public String sing(String name){
        System.out.println("Agent sets up the venue." );
        System.out.println("Agent finished setting up the venue." );
        return kunKun.sing(name);
    }
    public void dance(String name){
        System.out.println("Kun Kun danced: " + name + " dance!");
        kunKun.dance(name);
    }
}

Then we just need to run in the main class:

ProxyPeople proxyPeople = new ProxyPeople();
proxyPeople.sing("Just Because You're Too Beautiful");
proxyPeople.dance("Ballet");

That's it.

But writing this way is obviously not elegant enough, so you thought of using polymorphism:

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("Kun Kun sang: " + name);
        return "Kun Kun finished singing";
    }
    @Override
    public void dance(String name){
        System.out.println("Kun Kun danced: " + name + " dance!");
    }
}
package top.mygld.demo.test;

public class ProxyPeople implements People{
    KunKun kunKun = new KunKun();
    @Override
    public String sing(String name){
        System.out.println("Agent sets up the venue." );
        System.out.println("Agent finished setting up the venue." );
        return kunKun.sing(name);
    }
    @Override
    public void dance(String name){
        System.out.println("Agent sets up the venue." );
        System.out.println("Agent finished setting up the venue." );
        kunKun.dance(name);
    }
}

This is much more elegant, but it's still not enough. This way we need to write a separate implementation class ProxyPeople, which seems somewhat redundant, because our statements are relatively simple. Is there a way to avoid writing a separate implementation class? Dynamic proxy is designed for this purpose.

2. Proxy Class

In the java.lang.reflect package, there is a Proxy class, which has a newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) method that can temporarily generate implementation classes and return an object.

Among them, the first parameter of newProxyInstance is a class loader, the second is a Class array of interfaces, and the third parameter is used to specify what the proxy object should do, for example:

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("Agent sets up the venue." );
                        System.out.println("Agent finished setting up the venue." );
                        if (method.getName().equals("sing")) {
                            return method.invoke(kunKun, objects);
                        }
                        else{
                            method.invoke(kunKun,objects);
                            return null;
                        }
                    }
                });
    }
}

Then the KunKun class doesn't need to be changed, just run directly in the main class:

People proxyPeople = ProxyUtil.createProxyPeople(new KunKun());
System.out.println(proxyPeople.sing("Just Because You're Too Beautiful"));
proxyPeople.dance("Ballet");

Here's a supplement: why is the second parameter of newProxyInstance an array? Because a proxy object can implement multiple interfaces simultaneously, for example:

Suppose you have multiple interfaces:

interface UserService {
    void saveUser(String name);
}

interface LogService {
    void log(String message);
}

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

You can create a proxy object that implements all three interfaces simultaneously:

InvocationHandler handler = new InvocationHandler() {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Calling method: " + method.getName());
        
        // Handle differently based on method name or interface type
        if (method.getName().equals("saveUser")) {
            System.out.println("Save user: " + args[0]);
        } else if (method.getName().equals("log")) {
            System.out.println("Log message: " + args[0]);
        } else if (method.getName().equals("cache")) {
            System.out.println("Cache data: " + args[0] + " -> " + args[1]);
        }
        
        return null;
    }
};

// Implement multiple interfaces simultaneously
Object proxy = Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class, LogService.class, CacheService.class},  // Multiple interfaces
    handler
);

// Can be cast to any interface for use
UserService userService = (UserService) proxy;
LogService logService = (LogService) proxy;
CacheService cacheService = (CacheService) proxy;

userService.saveUser("Zhang San");
logService.log("Operation completed");
cacheService.cache("user:1", "Zhang San");

When you pass in multiple interfaces, the JVM will generate a proxy class that implements all interfaces:

// The dynamically generated proxy class will implement all interfaces
public final class $Proxy0 extends Proxy 
    implements UserService, LogService, CacheService {
    
    // Implement UserService methods
    public void saveUser(String name) throws Throwable {
        super.h.invoke(this, saveUserMethod, new Object[]{name});
    }
    
    // Implement LogService methods
    public void log(String message) throws Throwable {
        super.h.invoke(this, logMethod, new Object[]{message});
    }
    
    // Implement CacheService methods
    public void cache(String key, Object value) throws Throwable {
        super.h.invoke(this, cacheMethod, new Object[]{key, value});
    }
}

3. Actual Use Cases

This design is common in frameworks, such as:

Spring AOP: Proxy objects need to implement original interface + additional enhancement interfaces
Transaction management: Business interface + transaction management interface
Cache proxy: Business interface + cache management interface

So the array design is for supporting the flexibility of multiple interface implementation. Even if you only pass in one interface, you still need to use array form new Class[]{YourInterface.class}.

That's it. The above are the knowledge points related to Java dynamic proxy.

Java Reflection Review

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

1. The Concept of Java Reflection

Java's reflection mechanism refers to the ability during program runtime to construct objects of any class, understand the class to which any object belongs, understand the member variables and methods of any class, and call the properties and methods of any object. This capability of dynamically obtaining program information and dynamically calling objects is called Java's reflection mechanism. Reflection is considered key to dynamic languages.

2. Reflection API

(1) Commonly Used Classes in Reflection

java.lang.Class: Classes in Java can also be considered special objects, and Class represents class objects.

java.lang.reflect.Constructor: Class constructors.

java.lang.reflect.Field: Class member variables.

java.lang.reflect.Method: Class member methods.

(2) Three Methods to Get Class Objects

Now I'll create a User class in the top.mygld.demo.pojo package as follows for demonstration:

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

Then I'll demonstrate getting class objects in the main class.

i) Get directly through ClassName.class, for example:

Class c = User.class;   //Assuming User is our encapsulated class

ii) Get through Class.forName("full class name"), for example:

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

iii) Get through specific object.getClass(), for example:

User user = new User("Xiao Ming",30);
Class c = user.getClass();

The object c obtained through the above three methods is the class object corresponding to the User class. Next, we can call some methods in c to obtain internal information of the User class and then manipulate the internal information, which is Java reflection.

(3) Basic Information of Class Objects

In step (2), we obtained the class object c. What would we get if we directly print and output c? Let's try it.

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);
    }
}

As shown above, it outputs class + full class name. This shows that the Class class overrides the toString method.

Additionally, the Class class provides two main member methods: getName and getSimpleName, used to get the full class name and simple class name of the class object respectively, with effects as follows.

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) Getting Constructor Information of Target Class Through Reflection

Through the reflection mechanism, we can obtain constructor information of the target class, such as the number of constructors, constructor parameter situations (no-arg constructor, parameterized constructor), number of parameters in parameterized constructors, parameter types, access modifiers, etc.

To facilitate testing, I'll rewrite the User class as follows:

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 +
                '}';
    }
}

Using the getDeclaredConstructors() method in Class can get an array of constructor objects for all constructors in the target class. Using getParameterCount() in Constructor can get the number of parameters in the corresponding constructor, as follows:

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("Total " + cons.length + " constructors") ;
        for(Constructor con : cons){
            System.out.println(con + " Parameter count: " + con.getParameterCount());
        }
    }
}

Of course, if you only want to get constructors modified by public, use the getConstructors() method in Class, which won't be demonstrated here.

So there's a question: if I want to get a single specified constructor object, how do I get it? Actually, you just need to call the overloaded method getDeclaredConstructor(Class<?>... parameterTypes) of getDeclaredConstructor, where parameterTypes only needs to pass in ClassName.class or primitive type.class, as follows:

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));
    }
}

Of course, if you want to get a constructor modified by public, you can also use getConstructor(Class<?>... parameterTypes) in Class to get it, where its parameter can be empty, indicating getting a no-arg constructor modified by public.

Note: getDeclaredConstructors and getDeclaredConstructor are not limited by access modifiers, while getConstructors and getConstructor can only get constructors modified by public.

(5) Creating Target Class Instance Objects Through Reflection

We've already obtained the constructor object of the target class. At this point, someone might wonder what we can do with this constructor object. Actually, we can do a lot.

First, by calling the newInstance(Object... initargs) method in Constructor, we can instantiate an object of the target class, for example:

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("Kun Kun", 18);
        System.out.println(kun);
    }
}

Someone might ask, isn't this unnecessary? Couldn't I just do new User("Kun Kun",18) directly? Why make it so complicated?

Now I'll talk about something interesting. We observe that in the User class, there's a constructor modified by private. Executing the following code would definitely cause an error:

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

This is because private User(String name) is private and cannot be directly accessed externally. However, through reflection, we can temporarily bypass access permissions to call this constructor. Call setAccessible(boolean) in Constructor, as follows:

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("Kun Kun"));
    }
}

Note: Using con.setAccessible(true); only temporarily modifies access permissions and doesn't affect the target class. The constructor remains private.

(6) Getting Member Variables of Target Class Through Reflection

Since we can get constructor information of the target class through reflection, we can certainly also get member variable (Field) information of the target class.

Actually, similar to getting constructors, getting member variables is basically similar:

Calling the getDeclaredFields() method in Field can get all member variable information under the target class; calling getDeclaredField(String name) in Field can get the specified variable with variable name name among member variables; calling the getFields() method in Field can get all member variable information modified by public under the target class; calling getField(String name) in Field can get the specified variable with variable name name among member variables modified by public, as follows:

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);
        //Since no public member variables are set in User, the getField() method won't be demonstrated here, you can try it yourself
    }
}

Note: The parameter lists of getDeclaredField and getField methods cannot be empty.

(7) Modifying and Getting Values of Member Variables of Target Class Objects Through Reflection

In step (6), we obtained member variable information of the target class. Can we modify or get the values of member variables of target class objects based on these member variable objects? The answer is yes. We just need to use the set(Object obj, Object value) and get(Object obj) methods in Field, as follows (since member variables in User are all private and cannot be directly modified, we need to first call setAccessible(true) in Field to temporarily bypass access permissions):

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("Kun Kun",18);
        System.out.println(user);

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

(9) Getting Member Methods of Target Class Through Reflection

If you've read the above 8 sections carefully, you should be able to guess that getting member method (Method) information also mainly has four methods:

They are getDeclaredMethods, getDeclaredMethod, getMethods, and getMethod in Method. Their functions and precautions should be self-evident. To facilitate demonstration, I'll first add several methods to User, as follows:

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("Hello, User");
    }
}

Then I'll test in the main class:

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"));

    }
}

Note: In getDeclaredMethod and getMethod, the first parameter is the name of the member method, and from the second parameter onward, it represents the parameter types of this member method's parameter list. If there's no parameter list, just write the first parameter for the above methods.

(10) Calling Member Methods of Target Class Objects Through Reflection

Through reflection, we can also call the invoke(target class object, parameter list) method in Method to call member methods in target class objects, as follows:

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, "Kun Kun");
        System.out.println(user);
    }
}

3. The Role of Reflection

i) Basic role: Can get all components of a class and then operate on them. (Already demonstrated in the above steps)

ii) Can break encapsulation. (Because it can modify access permissions of internal members of a class, it breaks class encapsulation)

iii) Can bypass generic constraints, for example, the execution result of the following code:

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. Summary

In summary, the core knowledge points of Java reflection mainly include four aspects: class objects (getting Class objects and their information), constructors (getting and operating class construction methods), member variables (getting and operating class fields), and member methods (getting and calling class methods).

Many frameworks are implemented through reflection methods, such as Spring Boot.

Through reflection, we can also design some frameworks ourselves. If I want to get member variable information of any class, I can write a relatively simple framework function, as follows:

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("Kun Kun",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));
        }
    }
}

Of course, the above is just an example. This function code might not be applicable to some other classes.

Why is "reflection" called "reflection"? I think that normally calling a member property or member method of an object follows the format object.member, while in reflection the format is basically member.method(object), which is the reverse of the normal format, so it's called reflection. Of course, this is just my personal understanding. If you're interested in why it's really called "reflection", you can look up some materials~

AI Grand Judge

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

I created a simple AI judge game purely based on frontend technology, a fun little game: Game Link

Hastily Completed Graduation Project

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

Because I needed to submit the first draft of my undergraduate thesis, I hastily completed this intelligent questionnaire system based on Vue3 + SpringBoot. Everyone is welcome to test it.

The AI interface uses the balance from Silicon Flow's invitation gift, which may run out at any time. If the AI generation stops working, it's likely due to insufficient balance.

Since it was written in a hurry, there are many bugs, ~~which is normal...~~

Test website: Graduation Project Test Site

Building a Static Blog with Netlify and Astro

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

1. Registering for Netlify

First, open Netlify's official website Click here to visit

Choose a method to register and log in. Here I'll choose GitHub login, which is the first option.

Then we authorize the GitHub login.

Afterward, you'll see pages asking for information including name, plan, role, etc. Fill them out roughly and check the tags.

If you selected the Personal option in How are you planning to use Netlify?, you'll be asked to create a project name at the end, which will be used as an identifier in the URL. You can customize this according to your preferences.

After completion, click Continue to deploy. A prompt will appear asking you to set up your first project. Click Skip this step for now.

After completing the above steps, you've successfully registered for Netlify.

2. Installing Astro

First, visit Astro's official documentation website Click here to visit

Then click on "Install Astro"

On the new page, three prerequisites are shown:

According to the documentation prerequisites, we need a Node.js environment, a text editor, and a terminal.

For Node.js environment installation and configuration, you can refer to the following tutorial:

Node.js Installation Tutorial, click to visit

You can use the system's built-in tools for the latter two. For a more comfortable coding environment, we can download and use VSCode as our text editor. Installation instructions can be found in the following tutorial:

VSCode Installation Tutorial, click to visit

After completing the above prerequisites, we can officially begin installing Astro.

First, create a new blank folder.

Then type cmd in the address bar and press Enter.

In the terminal that appears, enter the following command and type y when prompted:

npm create astro@latest

After waiting a while, you'll be prompted to choose a directory for the new project. You can enter ./glader-blog, which will create a new folder called glader-blog in the current directory to store the project.

Next, press Enter 3 times to wait for project initialization.

When you see the following message, the project initialization is complete. You'll now see a glader-blog directory in your folder containing the project:

Then enter the created project and use npm install to install dependencies, as follows:

Astro has a built-in server. After the installation is complete, run the command npm run dev to start the server.

Enter http://localhost:4321 in your browser to access the preview.

After entering this URL in the browser, the result is as follows, indicating that the Astro project has been successfully installed.

3. Getting Familiar with the Astro Development Environment

For convenient code writing, we'll use the VSCode text editor. First, open VSCode and use it to open the newly created project, glader-blog, as shown below. A prompt to install the Astro extension will appear in the bottom right corner - click install:

If the prompt doesn't appear, you can click the extensions icon and manually search and install:

After installation, return to the project directory. You'll find a new npm scripts option in the lower left corner. Clicking on items here will help us run npm scripts. For example, there's a dev option - clicking it is equivalent to running npm run dev in the project directory.

As you can see, the effect is the same as entering the command directly in the command window.

4. Writing a Simple Blog

In the project directory under src/pages/, there's an index.astro file, which is the website's homepage.

We can try deleting all the code in this file and rewrite a piece of code as follows:

<html lang="en">
  <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>

Now you can see in the browser that the webpage content has changed to what we wrote in the code.

Astro is essentially a static site generator that is compatible with native HTML code. For demonstration purposes, let's write a rough blog homepage. The code is as follows:

<!DOCTYPE html>
<html lang="en">
  <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>
    <!-- Navigation Bar -->
    <header>
      <nav>
        <ul>
          <li><a href="/">Home</a></li>
          <li><a href="/about">About Me</a></li>
          <li><a href="/posts">Blog Posts</a></li>
          <li><a href="/contact">Contact Us</a></li>
        </ul>
      </nav>
    </header>

    <!-- Main Content Area -->
    <main>
      <section class="intro">
        <h1>Welcome to My Blog!</h1>
        <p>Here I record some thoughts and shares about programming, technology, and life.</p>
      </section>

      <!-- Latest Articles List -->
      <section class="posts">
        <h2>Latest Articles</h2>
        <ul>
          <li><a href="">Test Article 1</a></li>
        </ul>
      </section>
    </main>

    <!-- Footer -->
    <footer>
      <p>&copy; 2025 My Blog. All Rights Reserved.</p>
    </footer>
  </body>
</html>

Now, if we want to write a blog in Markdown format, create a new folder called posts under src/pages/ to store our articles. Then create post-1.md under src/pages/posts/.

# My First Blog Post

Published: 2022-07-01

Welcome to my new blog about learning Astro! Here, I'll share my learning journey in building a new website.

## What I Did

1. **Installed Astro**: First, I created a new Astro project and set up my online accounts.

2. **Made Pages**: Then I learned how to make pages by creating new `.astro` files and saving them in the `src/pages/` folder.

3. **Published Blog Posts**: This is my first blog post! I now have pages written with Astro and articles written in Markdown!

## Next Steps

I will complete the Astro tutorial and then continue writing more content. Follow me for more information.

After writing the blog, add a hyperlink to "Test Article 1" in index.astro that links to the markdown article we just created:

Note: Don't add .md, just write the file name. That is, don't write /posts/post-1.md

Now, clicking on Test Article 1 in the webpage will display our blog content:

For more syntax, components, and related content, readers can learn on their own at the Astro Development Documentation Official Website.

5. Uploading the Project to GitHub

To upload the project to GitHub, you first need to download and install Git. The installation method can be found in the following tutorial:

Git Installation Tutorial

After installing Git, we need to configure Git for VSCode and upload the project we just wrote to a GitHub repository. The specific tutorial can be found here:

VSCode Git Configuration and Code Upload to GitHub Tutorial

Then click publish branch, and then click upload to private repository.

After uploading, we'll have such a private repository on GitHub:

Additionally, when we need to modify our code, we can also commit changes here:

At this point, we can edit our blog locally and then use Git to save our code to GitHub in real-time.

6. Hosting the Code on Netlify

Open the Netlify website again and log in to the account we just registered. Click Import from Git:

Then select GitHub:

In the new window that appears, authorize the operation and select the repository to upload:

Then click Install to install. A password prompt will appear - enter your GitHub password and click confirm.

Now as shown below, the upload is successful. Click on the repository to configure it:

We just need to give it a name in Site name. This name will later be included in the domain we visit. Leave the rest blank and click Deploy directly.

Then we just wait for deployment, which may take a few minutes.

After deployment is complete, the result is as follows:

Now we can visit the website https://glader.netlify.app to display our blog.

At this point, our blog deployment is complete.

Additionally, on GitHub, many people have already developed many easy-to-use blog themes based on the Astro framework. The operations we described above are merely to learn the basic usage of Astro. In actual blog creation, we can go to GitHub to choose a blog theme template we like and deploy it directly.

Domain Migration

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

Migrated the blog to: blog.mygld.top.

SpringBoot Knowledge Points Summary (Part 2)

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

YAML Configuration

In addition to the content summarized in Part 1, YAML has other syntax. For example, you can continue parameter references in YAML, as shown in the following example:

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);
}

After running, the output result is Bob:20.

This shows that in YAML, you can continue parameter references. person.name is assigned the value of name, which is Bob.

Additionally, arrays in YAML can also be written in inline array format, for example:

list: [hello,world]

YAML also has an important knowledge point: scalars. For example, if we now define the following parameters in YAML:

msg1: 'hello\n world' #Does not recognize escape characters, outputs as-is
msg2: "hello\n world" #Recognizes escape characters

The only difference between the above parameters is that msg1 uses single quotes, while msg2 uses double quotes. We write the following code for testing:

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

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

The output result is as follows:

hello\n world
hello 
 world

This shows that if we use single quotes to quote strings, escape characters are not recognized and output as-is; if we use double quotes, escape characters are recognized.

So think about it, if we define:

msg3: hello\n world

What effect will it have? After my experiment, the effect is actually the same as adding single quotes - escape characters are not recognized.

Additionally, even if we don't use the @Value and @ConfigurationProperties annotations, there are other ways to get parameters from the configuration in the code at any time. We can use the getProperty(parameter_name) method in the Environment class, for example:

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

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

The parameter name can be used directly as a string, without adding $ or {}.
Environment should import org.springframework.core.env.Environment; - don't import the wrong one.

Profile Usage

When developing SpringBoot applications, the same set of programs is usually installed in different environments, such as: development, testing, production, etc. The database address, server port, and other configurations are all different. If the configuration file has to be modified every time it's packaged, it would be very troublesome. The profile function is used for dynamic configuration switching.

Multiple Profile Files Method

As shown in the figure below, I now create the following three YAML files:

I write in the application-dev.yml file:

server:
  port: 8082

Then I write in the application-test.yml file:

server:
  port: 8081

If I don't write anything in application.yml, the result after running is as follows:

You can see that no Profile is currently set, and it's running on port 8080.

If I then write the following statement in application.yml:

spring:
  profiles:
    active: dev

The result after running is as follows:

You can see that the Profile is now set, and dev is currently active. The project is running on port 8082, which means the configuration in application-dev.yml has taken effect. Similarly, if I change application.yml to:

spring:
  profiles:
    active: test

Then the project will run on port 8081, switching to activate the test Profile, meaning the configuration in application-test.yml takes effect.

Through this method, we can quickly switch configurations suitable for different environments.

YAML Multi-Document Method

In the multiple Profile files method, we found that we need to create multiple yml or properties files, which is somewhat troublesome. So can we write configurations for different environments in the same configuration file, separated by special symbols? The answer is yes, as follows:

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

Different configuration files only need to be separated by ---.

SpringBoot Knowledge Points Summary (Part 1)

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

YAML Configuration and Retrieval in SpringBoot

In the application.yml file, custom configurations can be written as follows:

student:
  name: Xiao Kun
  age: 18
  hobbies:
    - Singing
    - Dancing
    - Rap
    - Basketball

Note: Indentation between levels must be aligned, and there must be a space after the colon before writing the value. If it's an array, each line after a line break is a value, preceded by -, and there must also be a space after -.

Method 1 to retrieve configuration: Use @Value("${property}"), applied in the pojo entity class as follows:

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

Method 2 to retrieve configuration: Use @ConfigurationProperties(prefix = "prefix"), applied in the pojo entity class as follows:

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

Note: If using Method 2, the property names in the pojo entity class must be exactly the same as the names in the yml configuration file.
Note: @Value only supports simple string parsing and cannot parse complex data structures like List.

SpringBoot Integration with MyBatis

The MyBatis starter dependency is as follows, add it to pom.xml:

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

Also introduce the MySQL driver dependency as follows:

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

Write the data source configuration in the application.yml configuration file as follows:

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/{database_name}
    username: {username}
    password: {password}

Suppose we now have a database named mybatis with a table user as follows:

id	name	age	gender	phone
1	Xiao Kun	19	1	18800000001
2	Xiao Xu	18	1	18800000002
3	Xiao Cai	17	1	18800000003
4	Xiao Cai	16	2	18800000004
5	Xiao Ji	15	1	18800000005
6	Xiao Mei	14	1	18800000006

Next, we need to create a pojo entity class User with the following code:

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

Then create an interface UserMapper under the mapper package as follows:

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

Note: Don't forget to add @Mapper.

Then, create an interface UserService under the service package as follows:

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

Next, under the impl package in the service package, create an implementation class UserServiceImpl that implements the UserService interface and add the @Service annotation to hand it over to the IOC container:

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

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

Finally, create UserController under the controller package with the following code:

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

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

}

Note: The above operations belong to the MVC architecture.

Then, run the project and enter http://localhost:8080/selectUserById?id=1 in the browser to see the effect. The browser will output:

{"id":1,"name":"Xiao Kun","age":19,"gender":1,"phone":"18800000001"}

Testing LaTeX Rendering

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

This article is only used to test if LaTeX formulas can render properly. The test content is generated by AI:

1. Inline Formulas

For example, we can write the famous Einstein mass-energy formula: $E=mc^2$, which describes the relationship between energy and mass.

2. Display Formulas

For quadratic equations: $$ ax^2 + bx + c = 0 $$ The quadratic formula is: $$ x = \frac{-b \pm \sqrt{b^2-4ac}}{2a} $$

3. Summation and Limits

Classic result of infinite series: $$ \sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6} $$ Also, let's test the limit formula: $$ \lim_{x\to 0} \frac{\sin x}{x} = 1 $$

4. Matrices and Special Formulas

Here's an example of a 2x2 matrix: $$ \mathbf{A} = \begin{bmatrix} a & b \ c & d \end{bmatrix} $$ And the world-famous Euler's formula: $$ e^{i\pi} + 1 = 0 $$

Script Development for Converting Markdown and LaTeX to Images

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

A few days ago, I wrote a QQ bot for fun and connected it to a third-party AI interface. Although there are plugins in LiteLoaderQQNT that can render Markdown and LaTeX formats, most people do not have these plugins. So, I wondered if I could write a script to convert text containing Markdown and LaTeX into images, and here is what I did.

Implementation Idea

After researching, I found that the following steps can be used:

Convert the generated text into an HTML page;
Use MathJax to render the LaTeX format in it;
Take a screenshot of the page and save it.

JavaScript Script: Webpage Screenshot

First, write a JS script to take a screenshot of a given HTML page. The code is as follows:

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

// Get input and output paths from command line arguments
const args = process.argv.slice(2);
const inputPath = args[0];
const outputPath = args[1];

// Check if arguments are provided
if (!inputPath || !outputPath) {
  console.error('Usage: node script.js <input path> <output path>');
  process.exit(1);
}

// Resolve input path to absolute path
const resolvedInputPath = path.resolve(__dirname, inputPath);

// Check if input file exists
if (!fs.existsSync(resolvedInputPath)) {
  console.error('Input file not found:', resolvedInputPath);
  process.exit(1);
}

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

  // Open the page
  await page.goto('file://' + resolvedInputPath, { waitUntil: 'networkidle0' });

  // Try to wait for MathJax to finish rendering, wait up to 2 seconds
  try {
    await page.waitForFunction(
      'window.MathJax && window.MathJax.Hub && window.MathJax.Hub.getAllJax().length > 0',
      { timeout: 2000 }
    );
  } catch (e) {
    console.log('MathJax not fully loaded, but continue to generate image...');
  }

  // Take a screenshot and save to the specified output path
  const resolvedOutputPath = path.resolve(__dirname, outputPath);
  await page.screenshot({ path: resolvedOutputPath, fullPage: true });

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

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

Save the above code as screenshot.js.

Environment Setup

The above code depends on Node.js. First, configure the Node.js environment, and then install the Puppeteer package in the same folder with the following command:

npm install puppeteer

Python Script: Markdown to HTML

Create a new Python program md2img.py in the same folder to convert Markdown and LaTeX to images.

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 file not found: {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 output:", result.stdout)
    except subprocess.CalledProcessError as e:
        print("screenshot.js failed:", e.stderr)
        raise

    if not os.path.exists(img_path):
        raise FileNotFoundError(f"Image generation failed: {img_path}")

    print(f"Image generated successfully: {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"Image generated successfully: {img_out_path}")
    except Exception as e:
        print(f"Image generation failed: {e}")
        raise
    finally:
        if os.path.exists(html_file_path):
            os.remove(html_file_path)

Environment Setup

The above Python program requires the markdown package. Install it with the following command:

pip install markdown

Usage Example

Create a new test.py and call md2img.markdown_to_image(md_text, img_out_path) in it to convert Markdown and LaTeX to an image.

Parameter description:
- md_text means the text containing Markdown and LaTeX;
- img_out_path means the output path of the generated image.

Glader's Blog - English

Learning the LangChain4j Framework

1. Introduction to LangChain4j

Concept

Features

2. Integrating LangChain4j with Java

Adding Dependencies

Text Generation Quick Start Demo

Text-to-Image Quick Start Demo

3. Integrating LangChain4j with Spring Boot

Quick Start Demo

Integration Starters

Declarative AI Services Starter

Interpretation of Differentiable Auxiliary Learning for Sketch Re-Identification

1. Motivation

2. Method

Dynamic Auxiliary Generator (DAG)

Feature Extraction

Modality Interactive Attention (MIA)

Auxiliary Cross-Attention Module (ACA)

Multi-Modality Collaborative Learning

Category Loss

Circle Loss

3. Experiments

Dataset Configuration

Ablation Experiments

Comparison Experiments

Visualization Display

Conclusion

Interpretation of "Modalities collaboration and granularities interaction for fine-grained sketch-based image retrieval"

1. Motivation

2. Method

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. Experiments

Dataset Settings

Comparison with State-of-the-Art Methods

Ablation Studies

Hyperparameter Analysis

Experimental Visualization

4. Conclusion

A Brief Exploration of Spring Transactions

1. What is a Transaction

Definition of Transaction

Properties of Transactions

2. Transactions in MySQL

Important Notes

Basic Transaction Operations

3. Transactions in Spring

Demo Example

Basic Usage of @Transactional

Advanced Usage of @Transactional

rollBackFor Property

Transaction Propagation Behavior

Spring Bean Scope and Lifecycle

Singleton

Prototype

Bean Lifecycle

Summary

Injecting Third-Party Beans into IoC Container

Manual Registration with @Bean

@ComponentScan — Extending Scan Paths

@Import to Directly Import Configuration Classes

Importing Regular Classes

ImportSelector for Dynamic Bean Registration

More Complex Example: Conditional Import

Using DeferredImportSelector

@EnableXxx Composite Annotations

Spring AOP

1. Spring AOP Annotation Explanation

@Before

@Around

@After

@AfterReturning

@AfterThrowing

@Pointcut

Basic Usage of `@Transactional`

Advanced Usage of `@Transactional`

`rollBackFor` Property