Programming on LOCRIAN_V Blog

Understanding the CAS Spin Pattern in Java Through Random

Sat, 06 Jun 2026 21:40:20 +0800

Do you understand this snippet?

do {
    oldseed = seed.get();
    newseed = (oldseed * ...) & mask;
} while (!seed.compareAndSet(oldseed, newseed));   // ← CAS

Level 0: First understand why a “variable” is dangerous in multithreading

Suppose there’s a variable seed = 100, and two threads want to change it at the same time:

Thread A: reads seed=100 → computes new value 200 → writes back seed=200
Thread B: reads seed=100 → computes new value 300 → writes back seed=300

Here’s the problem — both read 100, each computes on its own, and whoever writes later wins. A’s result is overwritten by B, A’s work is wasted, and the program has no idea anything went wrong.

A Close Look at Common Caching Strategies

Tue, 05 May 2026 22:46:44 +0800

The Three Cache Brothers

Cache Penetration

What it is: a flood of requests querying data that doesn’t exist in the database. The cache has nothing, so it keeps hammering the database. Prevention:

Cache null values
1. Even when the database finds nothing, put an empty marker in the cache (with a short TTL, e.g. 2 minutes; only after that TTL expires can the database be queried again)
2. The next time the same id comes in, it’s blocked directly
3. Pros: effectively intercepts large numbers of penetration requests
4. Cons:
  1. A malicious attack with many different non-existent keys fills the cache with useless data and wastes memory
  2. It delays data consistency; new data has to wait for the cache to expire
Bloom filter (recommended)
1. At startup, put all legitimate ids into the Bloom filter
2. If the Bloom filter says no, it really doesn’t exist
3. Pros:
  1. No high-memory-usage risk
  2. No data-consistency risk
4. Cons:
  1. There’s a tiny false-positive rate
  2. Insertions and deletions need maintenance; when data updates, the Bloom filter must be updated in sync
Rate limiting and validation at the interface layer
1. Intercept at the API gateway or Controller layer
2. Parameter validation, rate limiting, and degradation
Mutex-based rebuild
1. A mutex mainly solves cache breakdown (a hot key expiring), but in the cache-empty-object scenario, if there are many concurrent requests for a non-existent key, a lock can be used
2. Each access lets one thread query the DB while the others wait

Big companies’ practice

The Fundamentals You Need to Build a Chat Room

Fri, 03 Apr 2026 11:45:26 +0800

The TCP Three-Way Handshake

Client — Server

Purpose of the three-way handshake: the client’s send and receive are both fine, and the server’s send and receive are both fine.

First handshake: the client sends SYN (synchronize request)

Client: I know nothing, so I’ll send out a SYN message and see if anyone receives it.
If no one replies, I send it a few more times (timeout retransmission).
At this moment, what the client knows is:
- I sent it, but I don’t know whether anyone received it ❌
- Can I receive messages? Unknown ❌
- Does the other side exist? Unknown ❌

Second handshake: the server replies SYN+ACK (synchronize + acknowledge)

The server received the client’s SYN.

Why the Backend Sometimes Needs to Maintain a Refresh_Tokens Table

Mon, 02 Mar 2026 20:07:07 +0800

The Normal JWT Request Flow

sequenceDiagram
    participant User as User
    participant Frontend as Frontend (browser/app)
    participant Auth as Auth server
    participant Backend as Backend API server

    Note over User,Backend: 1. Login phase
    User->>Frontend: enter username/password
    Frontend->>Auth: POST /login (credentials)
    Auth->>Auth: verify credentials
    Auth-->>Frontend: return access_token + refresh_token
    Frontend->>Frontend: store tokens (memory/localStorage)
    Frontend-->>User: login successful

    Note over User,Backend: 2. Normal request phase
    User->>Frontend: request a protected resource
    Frontend->>Backend: GET /api/resource
Authorization: Bearer access_token
    Backend->>Backend: verify access_token signature and expiry
    Backend-->>Frontend: return the requested resource
    Frontend-->>User: display data

    Note over User,Backend: 3. Access token expires
    User->>Frontend: keep requesting
    Frontend->>Backend: GET /api/resource
Authorization: Bearer access_token (expired)
    Backend-->>Frontend: 401 Unauthorized (token expired)
    Frontend->>Frontend: detects 401, triggers refresh logic

    Note over Frontend,Auth: 4. Token refresh phase
    Frontend->>Auth: POST /refresh
refresh_token
    Auth->>Auth: verify refresh_token
    Auth-->>Frontend: return a new access_token (optionally a new refresh_token)
    Frontend->>Frontend: update the stored access_token
    Frontend->>Backend: retry the original request (new access_token)
    Backend-->>Frontend: return the requested resource
    Frontend-->>User: display data

Why You Can’t Rely on JWT Alone

Once a refresh token is issued and the backend doesn’t store it, it becomes an uncontrollable long-term pass
You can’t forcibly log a user out
You can’t log out a single device
You can’t tell whether a token has been stolen (an attacker who gets the refresh token can keep refreshing the access token forever)
You can’t implement session management

The Flow After Using a refresh_tokens Table

sequenceDiagram
    participant User as User
    participant Frontend as Frontend
    participant Auth as Auth server
    participant DB as Database (refresh_tokens table)
    participant Backend as Backend API server

    Note over User,DB: 1. Login phase (issue token + persist)
    User->>Frontend: enter username/password
    Frontend->>Auth: POST /login
    Auth->>Auth: verify credentials
    Auth->>DB: generate a unique refresh_token_id
INSERT INTO refresh_tokens
(user_id, token_hash, expires_at,
 device_info, ip_address, revoked)
    DB-->>Auth: insert successful
    Auth->>Auth: generate access_token + refresh_token
(refresh_token contains the id reference)
    Auth-->>Frontend: return access_token + refresh_token
    Frontend->>Frontend: store tokens
    Frontend-->>User: login successful

    Note over User,Backend: 2. Normal request (same as before)
    User->>Frontend: request a resource
    Frontend->>Backend: GET /api/resource
Authorization: Bearer access_token
    Backend->>Backend: verify access_token
    Backend-->>Frontend: return the resource

    Note over Frontend,DB: 3. Access token expires → refresh
    Frontend->>Backend: GET /api/resource (access_token expired)
    Backend-->>Frontend: 401 Unauthorized
    Frontend->>Auth: POST /refresh
refresh_token

    Note over Auth,DB: 4. Refresh verification (multi-step checks)
    Auth->>Auth: parse refresh_token, extract token_id
    Auth->>DB: SELECT * FROM refresh_tokens
WHERE id = token_id
    DB-->>Auth: return the record
    
    Auth->>Auth: verification checklist:
    Note over Auth: ✅ does token_hash match
✅ is it expired (expires_at > now())
✅ is it revoked (revoked = false)
✅ is the user still valid
✅ does device info match (optional)
    
    alt all checks pass
        Auth->>DB: UPDATE refresh_tokens
SET last_used_at = now(),
    last_used_ip = current_ip
WHERE id = token_id
        Auth->>Auth: generate a new access_token
(optional: extend refresh_token validity)
        Auth-->>Frontend: return the new access_token
        Frontend->>Frontend: update access_token
        Frontend->>Backend: retry the original request (new token)
        Backend-->>Frontend: return the resource
    else checks fail
        Auth-->>Frontend: 401/403 (refresh failed)
        Frontend->>Frontend: clear all tokens
        Frontend->>User: redirect to the login page
    end

    Note over User,DB: 5. Explicit logout
    User->>Frontend: click logout
    Frontend->>Auth: POST /logout
refresh_token
    Auth->>DB: UPDATE refresh_tokens
SET revoked = true
WHERE id = token_id
    Auth-->>Frontend: logout successful
    Frontend->>Frontend: clear local tokens
    Frontend-->>User: logged out

    Note over User,DB: 6. Security scenario: password change
    User->>Frontend: change password
    Frontend->>Auth: POST /change-password
    Auth->>DB: UPDATE refresh_tokens
SET revoked = true
WHERE user_id = current_user_id
    Note over DB: revoke all of the user's refresh_tokens
(force all devices to log in again)
    Auth-->>Frontend: password change successful
    Frontend->>Frontend: clear local tokens
    Frontend-->>User: please log in again

Microservice Auth System: Architecture Walkthrough and Interview Prep

Mon, 26 Jan 2026 18:05:16 +0800

Tech stack: Spring Boot 3 · Spring Cloud Alibaba · OpenFeign · JWT · Gateway · Nacos

How to use this document

When you talk about a project in an interview, the worst thing you can do is start from code details. The right order is:

First explain what problem it solves → then the overall architecture → then walk through it by request flow → finally handle the deep-dive questions.

On What a Hassle Login Is

Fri, 26 Dec 2025 15:56:40 +0800

From SMS codes to Passkeys — a look at the hassles behind login that nobody wants to think through, and a set of practices you can actually ship.

The Incompatibility Between PostgreSQL and Java's LocalDateTime

Sat, 25 Oct 2025 12:55:49 +0800

Java’s LocalDateTime and PostgreSQL’s time types “aren’t talking about the same kind of time.”

First, get clear on PostgreSQL’s two time types

TIMESTAMP           → without time zone, just a bare time "2026-06-25 10:00:00"
TIMESTAMPTZ         → with time zone, stored internally as UTC, converted to the session time zone on query

On the Java side

LocalDateTime       → no concept of a time zone, just a bare time
ZonedDateTime       → with time zone
OffsetDateTime      → with an offset (e.g. +08:00)
Instant             → a UTC timestamp

Why the error happens

The PostgreSQL JDBC driver (especially newer versions 42.x+) is very strict about type matching:

Swagger 2 vs. Swagger 3 Annotation Comparison Table

Thu, 25 Sep 2025 09:06:35 +0800

In the Spring Boot ecosystem, the annotations changed a great deal between Swagger 2.0 (typically using the Springfox dependency) and Swagger 3.0 (typically using the Springdoc-openapi dependency, based on the OpenAPI 3 spec).

Below is a complete correspondence table of the common annotations in Swagger 2.0 vs. Swagger 3.0 (OpenAPI 3):

1. Core annotation correspondence table

Description	Swagger 2.0 annotation (io.swagger.annotations)	Swagger 3.0 annotation (io.swagger.v3.oas.annotations)	Notes
Mark a controller class	`@Api(tags = "User API")`	`@Tag(name = "User API")`	3.0 removed the `description` attribute; use `name` uniformly
Mark an API method	`@ApiOperation(value = "Get user")`	`@Operation(summary = "Get user")`	In 3.0 `value` became `summary`
Request/entity class	`@ApiModel(value = "User object")`	`@Schema(description = "User object")`	3.0 greatly simplified this; use `@Schema` uniformly
Entity class property	`@ApiModelProperty(value = "Name")`	`@Schema(description = "Name")`	As above, merged into `@Schema`
Ignore a property	`@ApiModelProperty(hidden = true)`	`@Schema(hidden = true)`
Ignore a whole class/method	`@ApiIgnore`	`@Hidden`	For endpoints or parameters you don’t want exposed in docs

2. Request-parameter annotation correspondence table

For method parameters (URL path parameters, query parameters, etc.), 3.0 introduced a more structured configuration:

SCA 2023.X — Troubleshooting and Fixing the Nacos Bootstrap Config Failure

Thu, 24 Jul 2025 22:40:26 +0800

Issue source: spring-cloud-alibaba#3931
Affected versions: spring-cloud-alibaba 2023.0.1.3+

1. Problem Description

In Spring Cloud Alibaba 2023.X, placing Nacos config (including extension-configs, shared-configs, etc.) in bootstrap.yml / bootstrap.properties causes the config center’s content to fail to load properly, even though the logs show the bootstrap file itself was read.

Moving the same config to application.yml makes everything work again.

2. Root Cause

flowchart TD
    A[bootstrap.yml is read] --> B{SCA version check}
    B -- 2023.0.1.2 and earlier --> C[✅ Nacos config center loads normally]
    B -- 2023.0.1.3 and later --> D[❌ extension-configs / shared-configs fail]
    D --> E[Root cause: SCA 2023.0.1.3 changed the config-load priority mechanism]
    E --> F[Nacos PropertySource registered in the bootstrap phase is overwritten or discarded by later steps]

In short:
SCA 2023.0.1.3 made a backward-incompatible internal change, causing the Nacos extension config in bootstrap.yml to be “dropped” in the loading chain, while config in application.yml takes the new path and is unaffected.

Some Common Nacos Configurations

Tue, 24 Jun 2025 19:01:02 +0800

bootstrap config

bootstrap.yaml

server:
  port: 10888
  tomcat:
    uri-encoding: UTF-8
spring:
  profiles:
    active: dev
  application:
    name: archive-service
  cloud:
    nacos:
      config:
        file-extension: yaml
        shared-configs:
          - data-id: shared-spring.yaml
            refresh: false
          - data-id: shared-redis.yaml
            refresh: false
          - data-id: shared-mybatis.yaml
            refresh: false
          - data-id: shared-logs.yaml
            refresh: false
          - data-id: shared-feign.yaml
            refresh: false
          - data-id: shared-logs.yaml # shared logging config
            refresh: false
#          - data-id: shared-feign.yaml # shared feign config
#            refresh: false

lia:
  jdbc:
    database: tb_archive

bootstrap-dev.yaml

spring:
  cloud:
    nacos:
      server-addr: 192.168.2.115:8848 # nacos registry
      discovery:
        namespace: f923fb34-cb0a-4c06-8fca-ad61ea61a3f0
        group: DEFAULT_GROUP
        ip: 192.168.2.115
logging:
  level:
    asia.liminality: debug

nacos config

shared-spring.yaml

spring:
  jackson:
    default-property-inclusion: non_null
  main:
    allow-bean-definition-overriding: true
  mvc:
    pathmatch:
      # Fixes the exception: swagger Failed to start bean 'documentationPluginsBootstrapper'; nested exception is java.lang.NullPointerException
      # Because Springfox's path matching is based on AntPathMatcher, while Spring Boot 2.6.X uses PathPatternMatcher
      matching-strategy: ant_path_matcher

shared-redis.yaml

spring:
  redis:
    host: ${lia.redis.host:192.168.2.115}
    password: ${lia.redis.password:github}
    lettuce:
      pool:
        max-active: ${lia.redis.pool.max-active:8}
        max-idle: ${lia.redis.pool.max-idle:8}
        min-idle: ${lia.redis.pool.min-idle:1}
        max-wait: ${lia.redis.pool.max-wait:300}

shared-mybatis.yaml

MySQL

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://${sh.jdbc.host:127.0.0.1}/${sh.jdbc.database}?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false
    username: ${lia.jdbc.username:root}
    password: ${lia.jdbc.password:794211}
    
mybatis-plus:
  configuration:
    default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler
  global-config:
    db-config:
      logic-delete-field: deletedAt
      logic-not-delete-value: "null"
      logic-delete-value: "now()"
      id-type: assign_id
      insert-strategy: not_null
      update-strategy: not_null

PostgreSQL

spring:
  datasource:
    driver-class-name: org.postgresql.Driver
    url: jdbc:postgresql://${lia.jdbc.host:192.168.2.115}:${lia.jdbc.port:5432}/${lia.jdbc.database}?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
    username: ${lia.jdbc.username:postgres}
    password: ${lia.jdbc.password:github}
mybatis-plus:
  configuration:
    default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler
  global-config:
    db-config:
      logic-delete-field: deletedAt
      logic-not-delete-value: "null"
      logic-delete-value: "now()"
      id-type: assign_id
      insert-strategy: ignored
      update-strategy: ignored
      select-strategy: not_null

shared-logs.yaml

logging:
  pattern:
    dateformat: HH:mm:ss.SSS
    console: "%clr(%d{${LOG_DATEFORMAT_PATTERN}}){faint}-[${hostname}][%X{requestId:-sys}] %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n"
    file: "%d{${LOG_DATEFORMAT_PATTERN}}-[${hostname}][%X{requestId:-sys}]-${LOG_LEVEL_PATTERN:-%5p} ${PID:- } --- [%15.15t] %-40.40logger{39} : %m%n"
  file:
    path: "logs/${spring.application.name}"

shared-feign.yaml

feign:
  client:
    config:
      default: # the default global config
        loggerLevel: BASIC # log level; BASIC is the basic request and response info
  httpclient:
    enabled: true # enable Feign's HttpClient support
    max-connections: 200 # max connections
    max-connections-per-route: 50 # max connections per route
  sentinel:
    enabled: true

A Guide to Suffering Through WeChat Mini Program Development

Wed, 23 Apr 2025 14:02:30 +0800

The auth interaction flow between a WeChat Mini Program and the backend

The core flow of WeChat Mini Program login: the mini program gets a temporary credential code → the backend exchanges the code for an openid → the backend issues its own JWT to the mini program. Below is the overall flow diagram.

sequenceDiagram
    participant MP as WeChat Mini Program
    participant WX as WeChat server
    participant GW as gateway
    participant Auth as auth module
    participant User as user-service
    participant DB as lia_user database

    MP->>WX: wx.login() to get code
    WX-->>MP: returns temporary code
    MP->>GW: POST /auth/wx-login {code}
    GW->>Auth: forward the request
    Auth->>WX: code2session(code)
    WX-->>Auth: returns openid + session_key
    Auth->>User: OpenFeign to query/create the user
    User->>DB: query by openid
    DB-->>User: user record (or empty)
    User-->>Auth: return userId
    Auth->>Auth: generate JWT
    Auth-->>MP: return token + user info
    MP->>MP: store into Storage

Breaking down the key points

1. The mini program gets the code (frontend)

Message Middleware: Interview Questions

Sun, 23 Mar 2025 13:21:54 +0800

RabbitMQ

How does RabbitMQ guarantee messages are not lost?

Where can loss happen
- publisher -> exchange
  - Producer confirmation mechanism
    - ack publish-confirm
    - nack publish-confirm
    - ack publish-return
    - How to handle a failed message
      - Callback method
      - Log it
      - Save to the database and resend on a schedule
- exchange -> queue
  - Message persistence
    - Exchange persistence
    - Queue persistence
    - Message persistence
- queue
- queue -> consumer
  - Consumer acknowledgment mechanism

How is the duplicate-consumption problem in RabbitMQ solved?

Causes of duplicate consumption

Spring Cloud: Interview Questions

Sun, 23 Feb 2025 13:20:18 +0800

The OpenFeign service-call process

flowchart TD

A["Business code calls
userClient.getById(1L)"] --> B["JDK dynamic proxy Proxy.invoke"]

B --> C["Feign InvocationHandler
MethodHandler"]

C --> D["Contract parses annotations
@GetMapping / @PathVariable"]

D --> E["RequestTemplate builds the HTTP request"]

E --> F["Parameter binding
Path / Query / Body / Header"]

F --> G["Service name resolution: user-service"]

G --> H["Service discovery: Nacos / Eureka"]

H --> I["LoadBalancer load balancing"]

I --> J["Select instance IP:PORT"]

J --> K["HTTP Client executor
OkHttp / Apache / JDK"]

K --> L["Send HTTP request GET /user/1"]

L --> M["Remote service: user-service"]

M --> N["Controller handles the request"]

N --> O["Return JSON"]

O --> P["Feign Decoder deserializes"]

P --> Q["JSON → UserDTO"]

Q --> R["Return to business code"]

Why Did China Big Tech Companies Pull All Their Public Docker Mirror Sources?

Mon, 23 Dec 2024 08:16:01 +0800

Over 2024 and 2025, the public Docker mirror sites run by Alibaba Cloud, Tencent Cloud, NetEase, iFlytek, and various universities were shut down or throttled in wave after wave. By 2026, “pulling an image feels like surviving a tribulation” is no longer a joke.

Many people’s first reaction is to curse the big companies for being stingy. But honestly, it’s not that simple.

The mountain of compliance can’t be gone around

Docker Hub is a globally open community — anyone can push an image to it, and no one does content review at the entrance. That means it contains everything: images with vulnerabilities, images carrying malware, even content that crosses domestic regulatory red lines, all mixed in.

Learning the Cloudflare Business

Sat, 23 Nov 2024 00:37:30 +0800

Spring: Interview Questions

Sat, 19 Oct 2024 23:19:24 +0800

These interview questions were collected from every corner of the internet

Talk about the underlying implementation of Spring IOC

Reflection
The value of the factory
Design patterns
A few key methods
- createBeanFactory
- getBean
- doGetBean
- createBean
- doCreateBean
- createBeanInstance(getDeclaredConstructor, newInstance)
- populateBean

flowchart TD
    A[Start] --> B["createBeanFactory()
create DefaultListableBeanFactory"]
    B --> C[Load BeanDefinitions
parse XML/annotations]
    C --> D["getBean(beanName)
external call entry"]

    D --> E["doGetBean(beanName)"]
    E --> F{Get singleton from cache?}
    F -->|Yes| G[Return the cached Bean]
    F -->|No| H["createBean(beanName, mbd)"]

    H --> I["doCreateBean(beanName, mbd)"]
    I --> J["createBeanInstance()
getDeclaredConstructor + newInstance"]
    J --> K["populateBean()
property filling / dependency injection"]
    K --> L["initializeBean()
initialization callbacks"]
    L --> M[Register destroy methods]
    M --> N[Return the complete Bean instance]

Talk about your understanding of Spring IOC — its principle and implementation

The IOC idea
DI as the means of implementation
What is a container, what is a Bean
BeanDefinition
- Where it’s read from
  - XML
  - Annotations
- Where it’s stored
  - All BeanDefinitions are stored in a Map inside DefaultListableBeanFactory

The container lifecycle

flowchart TD
    START([🚀 Program starts]) --> REFRESH["AbstractApplicationContext.refresh()"]

    REFRESH --> PHASE1

    subgraph PHASE1["🔵 Phase 1: Preparation"]
        direction TB
        A1["prepareRefresh()\nrecord start time\nset container state to 'active'\ninitialize environment variables"] --> A2
        A2["obtainFreshBeanFactory()\ncreate DefaultListableBeanFactory\nthe container's core repository"] --> A3
        A3["prepareBeanFactory()\nregister basic BeanPostProcessors\nregister Aware-related processors\nregister the default environment Bean"]
    end

    PHASE1 --> PHASE2

    subgraph PHASE2["🟢 Phase 2: Load BeanDefinitions (read the blueprints)"]
        direction TB
        B1["scan the packages specified by @ComponentScan\nor read the XML config file"] --> B2
        B2["parse annotations / XML\nrecognize @Component @Service\n@Repository @Controller @Bean"] --> B3
        B3["generate a BeanDefinition for each Bean\nrecord: class name, scope, lazy or not\ninit method, destroy method, dependencies"] --> B4
        B4[("store into beanDefinitionMap\nkey = beanName\nvalue = BeanDefinition")]
    end

    PHASE2 --> PHASE3

    subgraph PHASE3["🟡 Phase 3: Modify BeanDefinitions (edit the blueprints)"]
        direction TB
        C1["invokeBeanFactoryPostProcessors()\nrun all BeanFactoryPostProcessors"] --> C2
        C2["ConfigurationClassPostProcessor\nhandle @Configuration @Import\n@PropertySource @ComponentScan\n👉 Spring Boot auto-configuration triggers here"] --> C3
        C3["PropertySourcesPlaceholderConfigurer\nreplace all ${xxx} placeholders in\nBeanDefinitions with real values"] --> C4
        C4[/"all BeanDefinitions finalized\nthe blueprints no longer change"/]
    end

    PHASE3 --> PHASE4

    subgraph PHASE4["🌸 Phase 4: Register BeanPostProcessors (workers take their posts)"]
        direction TB
        D1["registerBeanPostProcessors()\nregister by priority\nPriorityOrdered → Ordered → ordinary"] --> D2
        D2["AutowiredAnnotationBeanPostProcessor\nhandles @Autowired @Value"] --> D3
        D3["CommonAnnotationBeanPostProcessor\nhandles @PostConstruct @PreDestroy @Resource"] --> D4
        D4["AnnotationAwareAspectJAutoProxyCreator\ndetects aspects, generates AOP proxies"] --> D5
        D5[/"all workers in place\nwaiting to intervene during Bean creation\nnot working yet"/]
    end

    PHASE4 --> PHASE5

    subgraph PHASE5["🟣 Phase 5: Initialize container infrastructure"]
        direction TB
        E1["initMessageSource()\ninitialize i18n resources"] --> E2
        E2["initApplicationEventMulticaster()\ninitialize the event multicaster"] --> E3
        E3["onRefresh()\n⭐ Spring Boot starts here\nTomcat / Jetty / Undertow\nthe web container begins listening on a port"] --> E4
        E4["registerListeners()\nregister all ApplicationListeners\nlisten for container events"]
    end

    PHASE5 --> PHASE6

    subgraph PHASE6["🟠 Phase 6: Instantiate all singleton Beans"]
        direction TB
        F1["finishBeanFactoryInitialization()\npreInstantiateSingletons()\niterate all non-lazy singleton BeanDefinitions"] --> F2
        F2["execute getBean() one by one\ntrigger each Bean's lifecycle\ninstantiate → fill properties → Aware callbacks\n→ pre-processing → init method → post-processing"] --> F3
        F3[("all singleton Beans stored in\nthe singletonObjects level-1 cache\n✅ all ready")]
    end

    PHASE6 --> PHASE7

    subgraph PHASE7["✅ Phase 7: Container ready"]
        direction TB
        G1["finishRefresh()\nclean up resources used at startup\ninitialize the lifecycle processor"] --> G2
        G2["publish ContextRefreshedEvent\nnotify all listeners: container startup complete"] --> G3
        G3[/"container enters running state\ncan handle business requests"/]
    end

    G3 --> RUNNING([🎉 Container running normally])

    RUNNING -.->|"receive shutdown signal\nCtrl+C / kill / close()"| PHASE8

    subgraph PHASE8["🔴 Phase 8: Container destruction"]
        direction TB
        H1["publish ContextClosedEvent\nnotify all listeners: container about to close"] --> H2
        H2["stop the web container\nTomcat stops accepting new requests"] --> H3
        H3["run all Beans' destroy logic\n@PreDestroy → destroy() → destroy-method\ndestroy in reverse registration order"] --> H4
        H4["clear all caches\nsingletonObjects cleared\nbeanDefinitionMap cleared"] --> H5
        H5["set container state to 'closed'\nactive = false / closed = true"]
    end

    H5 --> END([💀 Container destruction complete])

    style START fill:#43A047,color:#fff
    style RUNNING fill:#43A047,color:#fff
    style END fill:#e53935,color:#fff
    style REFRESH fill:#1E88E5,color:#fff

The Bean lifecycle

flowchart TD
    START([🌱 Start creating the Bean]) --> A

    A["① Instantiation\nInstantiation\nreflectively call the constructor\nnew an empty shell object\nall fields are null at this point"] --> B

    B["② Put into the level-3 cache\nsingletonFactories\nexpose the half-built object early\nto prepare for circular dependencies"] --> C

    C["③ Property filling\npopulateBean()\nhandle @Autowired @Value\ninject the dependent Beans"] --> D

    subgraph AWARE["④ Aware callbacks"]
        direction TB
        D["BeanNameAware\ntell the Bean its own name"] --> E
        E["BeanFactoryAware\npass the BeanFactory to the Bean"] --> F
        F["ApplicationContextAware\npass the ApplicationContext to the Bean"]
    end

    subgraph INIT["⑤ Initialization initializeBean()"]
        direction TB
        G["pre-processing\npostProcessBeforeInitialization()\nall BeanPostProcessors run one by one\n📌 @PostConstruct is called here"] --> INITMETHOD

        subgraph INITMETHOD["init methods (executed in order)"]
            direction TB
            H1["1st: @PostConstruct\n(already run in pre-processing)"] --> H2
            H2["2nd: afterPropertiesSet()\nimplement the InitializingBean interface"] --> H3
            H3["3rd: init-method\n@Bean(initMethod='xxx') or XML config"]
        end

        INITMETHOD --> I

        I["post-processing\npostProcessAfterInitialization()\nall BeanPostProcessors run one by one\n⭐ AOP proxies are generated here"]
    end

    AWARE --> INIT

    I --> J

    subgraph CACHE["⑥ Store into the cache"]
        direction TB
        J["remove from the level-3 cache singletonFactories\nremove from the level-2 cache earlySingletonObjects"] --> K
        K["store into the level-1 cache singletonObjects\n✅ complete Bean ready"]
    end

    K --> READY([🎉 Bean is now usable])

    READY -.->|"container closes"| DESTROY

    subgraph DESTROY["⑦ Destruction phase (on container close)"]
        direction TB
        D1["1st: @PreDestroy\nmethod is called"] --> D2
        D2["2nd: destroy()\nimplement the DisposableBean interface"] --> D3
        D3["3rd: destroy-method\n@Bean(destroyMethod='xxx') or XML config"]
    end

    D3 --> END([💀 Bean destruction complete])

Spring’s three-level cache dependency flow

sequenceDiagram
    participant Spring as Spring container
    participant L3 as Level-3 cache
singletonFactories
    participant L2 as Level-2 cache
earlySingletonObjects
    participant L1 as Level-1 cache
singletonObjects

    Note over Spring: Start creating A

    Spring->>Spring: ① new A empty-shell object
    Spring->>L3: ② store A's ObjectFactory lambda

    Note over Spring: Injecting properties into A, discovers it needs B

    Spring->>Spring: ③ new B empty-shell object
    Spring->>L3: ④ store B's ObjectFactory lambda

    Note over Spring: Injecting properties into B, discovers it needs A

    Spring->>L1: ⑤ getBean(A), check level-1 cache
    L1-->>Spring: ❌ not there

    Spring->>L2: check level-2 cache
    L2-->>Spring: ❌ not there

    Spring->>L3: check level-3 cache
    L3-->>Spring: ✅ found A's lambda!

    Spring->>Spring: ⑥ execute the lambda
(generate proxy A if a proxy is needed)
    Spring->>L2: ⑦ put the early reference into the level-2 cache
    Spring->>L3: remove A from the level-3 cache

    Note over Spring: B gets A's early reference, B finishes initialization

    Spring->>L1: ⑧ put B into the level-1 cache ✅
    Spring->>L3: remove B from the level-3 cache

    Note over Spring: Back in A's flow, B is ready, A finishes initialization

    Spring->>L1: ⑨ put A into the level-1 cache ✅
    Spring->>L2: remove A from the level-2 cache

    Note over L1: Finally: the level-1 cache holds complete A and B ✅

Case	Level-3 cache	lambda executed	Level-2 cache
No circular dep, no AOP	stored the lambda	❌ not executed	not used
No circular dep, with AOP	stored the lambda	❌ not executed	not used
Circular dep, no AOP	stored the lambda	✅ executed	stores the raw object
Circular dep, with AOP	stored the lambda	✅ executed	stores the proxy object

When Spring Bean caches are placed and removed

When Spring Bean’s three-level caches are placed and removed

Cache	What it stores	When placed	When removed
Level-3 `singletonFactories`	The Bean’s factory lambda	Right after instantiation	When the factory is called (promoted to level-2) or when the Bean completes
Level-2 `earlySingletonObjects`	The early-exposed half-built Bean	The moment the level-3 factory is called	When the Bean is fully initialized and placed in level-1
Level-1 `singletonObjects`	The complete, usable Bean	After initialization fully completes	When the container closes and destroys

The difference between BeanFactory and FactoryBean

What is a FactoryBean

public interface FactoryBean<T> {
    // Return the Bean instance (can involve complex creation logic)
    T getObject() throws Exception;
    
    // Return the Bean's type
    Class<?> getObjectType();
    
    // Whether it's a singleton
    default boolean isSingleton() {
        return true;
    }
}

Similarities
- Both are used to create Bean objects
Differences
- Creating an object with BeanFactory must follow the strict lifecycle process, which is too complex. If you want to simply customize the creation of some object while still handing it to Spring to manage, you must implement the FactoryBean interface
  - isSingleton — whether it’s a singleton
  - getObjectType — get the returned object’s type
  - getObject — customize the object-creation process

Dimension	BeanFactory	FactoryBean
Role	Container/factory interface	A special Bean
Function	Manages the lifecycle of all Beans	Customizes the creation of a specific Bean
Positioning	Infrastructure (the IOC container)	Business extension (creating complex objects)
How it’s used	Implemented and used by the Spring framework	Implemented by the developer, registered into the container
Common implementations	`DefaultListableBeanFactory`	`SqlSessionFactoryBean`, `ProxyFactoryBean`
Who creates whom	`BeanFactory` creates and manages `FactoryBean`	`FactoryBean` creates business objects

flowchart LR
    subgraph BeanFactory[BeanFactory - IOC container]
        direction LR
        Bean1[ordinary Bean]
        Bean2[ordinary Bean]
        FB[FactoryBean
special Bean]
    end

    FB -->|call getObject| Result[business object]
    
    User[developer] -->|getBean| BF[BeanFactory]
    BF -->|return| Bean1
    BF -->|return| Bean2
    BF -->|return getObject result| Result
    BF -->|add & prefix| FB

Design patterns used in Spring

Singleton
Prototype (scope set to prototype)
Factory
- BeanFactory
Template Method
- JdbcTemplate
- TransactionTemplate
- RestTemplate
- RedisTemplate
Strategy
- XmlBeanDefinitionReader
- PropertiesBeanDefinitionReader
Observer
- listener
- event
- multicast
Adapter
- HandlerAdapter
Decorator
- BeanWrapper
Chain of Responsibility
- When using AOP, an interceptor chain is generated first
- The filter chain of Spring MVC
Proxy
- Dynamic proxy
Delegate
- delegate

The underlying implementation principle of Spring AOP

🥇 Level 1: characterize it in one sentence (opening)

“The underlying essence of Spring AOP is dynamic proxy. When the container initializes a Bean, Spring intercepts via the BeanPostProcessor mechanism, decides whether the Bean needs enhancement, and if so, uses a dynamic proxy to generate a proxy object that replaces the original Bean when registered into the container. All subsequent calls to this Bean actually go through the proxy object.”

MySQL: Interview Questions

Thu, 19 Sep 2024 23:19:24 +0800

These interview questions were collected from every corner of the internet

How do you locate a slow query?

Approach 1
- Open-source tools
  - Arthas
- Ops tools
  - Prometheus
  - Skywalking
Approach 2
- MySQL’s built-in slow log (has a performance cost)
  - How to enable the slow log
    - /etc/my.conf
      - slow_query_log
      - long_query_time

A SQL statement runs slowly — how do you analyze it?

Reasons for slowness
- Aggregate queries
- Multi-table queries
- Queries on tables with too much data
- Deep pagination queries
How to analyze the slowness
- The explain / desc command
  - How to read the result?
    - The extra optimization hints
      - using where; using index — the lookup used an index, and the needed data is all in the index columns, so no back-to-table lookup is needed
      - using index condition — the lookup used an index
    - type
      - index, all — need optimization

Do you know about indexes? What is an index?

An index is a data structure (ordered) that helps MySQL fetch data efficiently. Beyond the data itself, the database system maintains data structures that satisfy specific search algorithms (such as B+ trees); these structures reference (point to) the data in some way, so advanced search algorithms can be implemented on them. Such a data structure is an index.

How Powerful Is JeecgBoot? Here Is My Take

Mon, 19 Aug 2024 21:33:09 +0800

A Close Study of Redis's LFU Memory Eviction Policy

Fri, 19 Jul 2024 13:10:54 +0800

Redis’s LFU (Least Frequently Used) eviction policy is an “upgraded” approximate algorithm built on top of LRU. It reuses the same 24-bit lru field in the object header and, through clever encoding and logarithmic counting, achieves an approximate tracking of access frequency at a tiny memory cost.

Below we examine it point by point: from the storage structure, to counter increment/decrement, to the eviction decision, to parameter configuration.

1. The bit layout of the 24-bit field

Every Redis object has an lru attribute (24 bits). In LFU mode it no longer holds a second-level timestamp but is split into two parts:

Studying for the System Architect Software Exam

Tue, 18 Jun 2024 12:51:35 +0800

These notes are organized around the core knowledge points of the exam syllabus, with code examples and memory mnemonics — good for a final sprint review. (The exam is China’s “Soft Exam” — Computer Technology and Software Professional Qualification — System Architect level.)

1. Laws, Regulations, and Standardization

1.1 Copyright

Category	Content
Not protected	Government documents, laws and regulations, current-affairs news
Protected	Speeches, authored books, software code
When it vests	Automatically arises from the day software development is completed
Protection term	50 years (attribution, modification, and integrity rights are protected permanently)

Copyright ownership rules:

Learning ElasticSearch

Sat, 18 May 2024 12:51:05 +0800

1. Fundamentals

1.1 Origin: Lucene

Lucene: Apache’s open-source Java full-text search engine library.
Advantages: easy to extend, high performance (pure Java, embeddable).
Drawbacks: complex to use — you must handle low-level details like index creation and query parsing, with no distributed support.
Elasticsearch is built on Lucene, providing a distributed, easy-to-use RESTful API.

1.2 The tech stack (ELK)

Elasticsearch: the storage, search, and analytics engine.
Logstash: a server-side data processing pipeline that collects and transforms data before sending it to ES.
Kibana: a visualization platform for building charts and dashboards and managing ES.
Beats: lightweight data shippers that send to Logstash or ES.

1.3 Installing with Docker

Elasticsearch (single node):

Learning AWS

Thu, 18 Apr 2024 12:48:03 +0800

Compiled for the Solutions Architect certification, from a Java backend perspective. Core idea: what pain point each service solves, when to choose it, and how to distinguish it from similar services.

1. Storage

1.1 Comparison of the three storage types

Type	Representative service	Access unit	Typical scenario
Block storage	EBS, EC2 Instance Store	Block	Databases, OS disks
File storage	EFS, FSx	Files / directory tree	Multi-instance sharing, NFS/SMB mounts
Object storage	S3	Object (Object + Key)	Static assets, backups, data lakes

Block storage  → like a local hard drive; the OS sees a raw device it formats and mounts itself
File storage   → like a NAS; multiple machines can mount the same directory at once
Object storage → like HTTP PUT/GET key-value; no directory concept, simulated with prefixes

1.2 Amazon S3

Quick reference of core features:

Learning Spring Cloud

Mon, 18 Mar 2024 12:46:51 +0800

1. Service Decomposition and Remote Calls

1.1 Why decompose into services?

As business grows, a monolith faces slow deployment, poor scalability, a frozen tech stack, and more. Microservices split it into small, independently deployable and scalable services, each responsible for a single business domain.

Decomposition principles:

Single responsibility: each service does one thing
High cohesion, low coupling: tight within a service, loose between services
Data independence: each service owns an independent database

Client → Gateway (auth) → business microservice A → microservice B (OpenFeign)
                ↓
           Nacos (service discovery)

1.3 RestTemplate — the raw inter-service call

RestTemplate is the HTTP client Spring provides for inter-service calls, but its code is verbose and it doesn’t support load balancing — a transitional solution before OpenFeign.

Learning the SSM Framework

Sun, 18 Feb 2024 12:40:44 +0800

1. The Spring IoC Container

1.1 Container architecture

BeanFactory (top-level interface)
    └── ApplicationContext (the commonly used interface, extends BF)
            ├── ClassPathXmlApplicationContext (XML config)
            ├── FileSystemXmlApplicationContext (filesystem-path XML)
            └── AnnotationConfigApplicationContext (annotation config)

Core differences between BeanFactory and ApplicationContext:

Feature	BeanFactory	ApplicationContext
Bean init timing	Lazy (on the first getBean)	Eager (at container startup)
Features	Basic IoC	IoC + event publishing + i18n + AOP, etc.
Use case	Extremely resource-constrained embedded	99% of business scenarios

Why doesn’t ApplicationContext have close()?
The ApplicationContext interface itself doesn’t define close(), to keep the interface general (not all containers can/need to be closed, e.g. web containers). But its implementation AbstractApplicationContext implements Closeable, so you can cast and call it, or receive it via the ConfigurableApplicationContext interface.

Learning MyBatis-Plus

Tue, 16 Jan 2024 15:38:37 +0800

1. Introduction

MyBatis-Plus (MP for short) is an enhancement tool for MyBatis. It only enhances MyBatis without changing it, built to simplify development and improve efficiency.

Core features:

Non-intrusive: adding MP has no effect on an existing MyBatis project — smooth as silk.
Low overhead: basic CRUD is auto-injected at startup, with essentially no performance loss.
Powerful CRUD operations: built-in generic Mapper and generic Service; with just a little configuration you get most single-table CRUD.
Supports Lambda-style calls: write query conditions safely and efficiently via lambda expressions, preventing mistyped field names.
Built-in code generator: generate Mapper, Service, Controller, etc. with minimal configuration.
Built-in pagination plugin: physical pagination based on MyBatis; developers don’t need to worry about the details — just configure and use.

Official site: https://baomidou.com/