JavaSourceCodeLearning: a reading map for Java framework internals, written in Chinese

A map of what to read, not a framework to depend on

There is no build file, no package manifest and nothing to install here. The tree is ten entries: `.gitignore`, `README.md`, `JdkLearn/`, `Spring/`, `Spring-AOP/`, `Spring-Boot/`, `Spring-Netty/`, `Spring-Security/`, `architecture/`, `note/` and `rocketmqdemo/`. The project's own description calls it a source code reading map for Java backend engineers, going from JDK and JUC through Spring, Netty, Kafka and RocketMQ, breaking down framework design and underlying implementation along the core paths.

That framing is the whole pitch. The argument the project makes for its existence is that reading source is not about memorizing every line of an implementation, it is about seeing the design choices behind a framework clearly. The stated payoff is situational: during a production problem, people who have read the core path can locate a boundary faster, judge the root cause and verify a hypothesis, and when designing a system themselves they can borrow from how mature frameworks split modules, design extension points, handle concurrency and optimise.

The README also states plainly that the project will keep organising source analysis, study notes and key diagrams around the core paths of mainstream Java backend frameworks. That is a statement of intent rather than a schedule, and there is no issue tracker activity to measure it against. The last push to the repository was on 2026-07-22, and the only release published is `images-v1` on 2026-07-07, which exists to hold the diagrams.

Versions pinned per framework, and two very different eras

The badge row at the top of the README is the most useful thing in it, because each set of notes is written against one specific version. The pinned versions are JDK 1.8.0_77, Spring 5.2.1.RELEASE, Spring Boot 2.2.1.RELEASE, Spring Security 5.1.0.RELEASE, Spring Security OAuth2 2.3.5.RELEASE, Netty 4.1.43.Final, RocketMQ 4.9.0 and Kafka 4.3.

Read down that list and the map splits into two groups by age. The JDK, Spring, Spring Boot, Spring Security, OAuth2 and Netty notes all target versions from the tail end of the previous decade, while the Kafka notes target 4.3 and the RocketMQ notes 4.9.0, which are current lines. That inconsistency is not a criticism so much as a fact about how the project grew: the framework-side notes were written first and have not been refreshed, the messaging-side notes are recent. It also has a practical consequence, since if you follow the Spring notes in an IDE you want a checkout of that specific Spring release rather than whatever version your own project uses.

JDK 1.8.0_77
Spring 5.2.1.RELEASE
Netty 4.1.43.Final
RocketMQ 4.9.0
Kafka 4.3

There is a companion table in the README that maps each body of notes to the capability it covers. The JDK and JUC row lists collections, concurrency, thread pools, the memory model and CompletableFuture. The Spring and Spring Boot row lists the IoC container, the event mechanism, the startup flow, auto-configuration and extension points. Spring AOP, Spring Security and OAuth2 map to proxying, the filter chain, and the main authentication and authorization flow. Netty maps to the Reactor model, the event loop, the channel pipeline and the network communication path. Kafka and RocketMQ map to broker, producer, consumer, rebalance, message storage and replication.

The five-stage path the README draws

The learning route is a five-step diagram rather than prose, which makes it the clearest statement of the project's method: the diagram runs from JDK and JUC basics, down through the Spring container and its extension points, then Spring Boot startup and auto-configuration, then the Netty network communication model, and finally the Kafka and RocketMQ messaging system internals.

The ordering is the argument. Concurrency primitives come first because every later stage depends on them, the Spring container comes next because auto-configuration is only meaningful once you know what is being configured, and Netty sits before the messaging systems because a client and a broker are both built on an event loop and a pipeline. The final stage ties the two halves together, since Kafka and RocketMQ are where the earlier concurrency and networking work becomes visible in a distributed protocol.

The top-level table in the README expands the same idea into the five subject areas listed above, with the emphasis words for each: what you can see, and which capabilities matter. Nothing in the repository grades your progress through it or tracks it, so the path is advice rather than a curriculum with checkpoints.

Notes, experiments and diagrams in three different places

The tree separates three kinds of content that a reader will otherwise conflate. `note/` holds the written analysis as Markdown files, organised by subject with subdirectories for Kafka and JDK. The top-level directories named after frameworks, such as `Spring/`, `Spring-Boot/`, `Spring-Netty/`, `Spring-Security/`, `Spring-AOP/` and `JdkLearn/`, are the other half: they are where small readable projects live, and the naming pattern suggests each one is a trimmed-down version of the framework built for reading. `rocketmqdemo/` is the same idea applied to RocketMQ.

note/
architecture/
JdkLearn/
rocketmqdemo/

`architecture/` is the third kind, and it is the least explained. The README does not say whether it holds diagrams, notes or both, which makes it the first directory to open if you want to understand how the project organises its own thinking rather than a specific framework.

The diagrams are not in the tree at all. Every figure in the README, including the Kafka architecture diagram, the EAGER and COOPERATIVE rebalance flow diagrams, the ISR and HW and LEO relationship diagram, the HashMap internals diagram and the AQS architecture diagram, is served from the `images-v1` GitHub release via a download URL. That is a deliberate choice, since binaries in a Git repository make diffs noisy, but it has a side effect: the images are pinned to a release tag and will not change unless a new tag is published, and there is currently exactly one.

Most of the JDK and Spring links point at a second repository

A detail worth flagging before anyone clones anything: the links are not consistent about which repository they point into. The Kafka links resolve to `coderbruis/JavaSourceCodeLearning`, which is the repository being reviewed. The JDK and Spring links resolve instead to `coderbruis/JavaSourceLearning`, a different name with the words Code and Learning swapped. Both are presented in the same README with no note explaining the split, so following a JDK link takes you off this repository and possibly onto a different branch history.

The file paths in those links are not consistent either. Most Kafka entries point into `note/kafka/`, while one Rebalance entry points at `note/Kafka` with the subject directory missing. In a repository whose entire value is that you can find the note you want, small path drift is the kind of thing that costs a reader more time than it should.

Set against that, the catalogue itself is well chosen for someone who already writes Java. The Kafka section runs from a concepts primer through broker internals, the producer side, consumer analysis, Rebalance under the classic consumer group protocol with both eager and cooperative variants diagrammed, and an explanation of ISR. The JDK section covers String, CompletableFuture, ThreadLocal, the volatile keyword, Thread, HashMap, bitwise tricks found in open source projects, ThreadPoolExecutor and AQS.

No license file, and content in one language

Two practical constraints are worth stating before anyone plans to reuse any of this. The first is that there is no `LICENSE` file in the tree and no license is declared for the project, so the reuse terms for the notes, the example projects and the diagrams are unstated. For a repository meant as a personal learning record that is unremarkable, and for a company considering mirroring it into internal documentation it is a question to ask the author rather than assume.

The second is language. The README, the section headings, the table and every note title are written in Chinese, with the diagrams labelled in Chinese as well. Nothing here is translated, and there is no English version of the site. For a reader who reads Chinese this is a large amount of well-organised material on exactly the internals that are hard to find explained coherently elsewhere. For a reader who does not, the map still has value as a syllabus, since the version numbers and the topic list tell you which parts of which releases are worth the time, but the analysis itself is not reachable without translation.

There is also no `CONTRIBUTING.md`, no code of conduct and no issue tracker convention described anywhere in the README. The repository reads as a curated notebook maintained by one person, which is consistent with the release history: one tag, for images, published 2026-07-07.

Editorial conclusion

JavaSourceCodeLearning is best understood as a curated index rather than a body of work you consume front to back. Its value is in the routing: it decides that the JDK collections and concurrency packages, the Spring container, the Spring Boot startup sequence, Netty's event loop, and the Kafka and RocketMQ broker and consumer paths are the parts worth reading, and it pins each set of notes to a specific version so you are not reading about a moving target. The two halves of that map are of different ages, with Spring and JDK notes on long-released lines and the Kafka notes on a current one, which matters if you are trying to follow along in an IDE. Everything is written in Chinese, there is no LICENSE file and no stated license, and the diagrams live in a GitHub release rather than in the tree. The last push was on 2026-07-22. If you want in, read the Kafka section first, since it is the most complete, then use the pinned version numbers in `note/` as your starting point in a checkout of the matching framework release.

Frequently asked questions

Official sources

1. coderbruis/JavaSourceCodeLearning on GitHub
2. Issues
3. README
4. Releases