Unlocking Architecture Secrets: How to Learn from Classic Source Code

Reading Classic Source Code: Levels and Insights

The author compares technical architecture to traditional Chinese medicine, where basic components are like herbs and design patterns or frameworks are the prescriptions, and shares personal experiences on extracting architectural ideas from classic source code.

1. Architecture Analogy to Traditional Medicine

Just as medicine starts with herbs, moves to formulas, and finally to clinical practice, software architecture starts with basic components (languages, middleware), then design/architecture patterns (the formulas), and finally real‑world implementation.

1.2 Levels of Reading Source Code

Reading source code can be approached in three hierarchical levels:

Understanding Level : Know the overall flow and be able to use the component; stay at the surface.

Deepening Level : Dive into internal details, understand why a component exists and how it solves problems.

Internalization Level : Extract design thinking, formulate generic solutions, and evolve them into concrete implementations.

2. Extracting Common Core Ideas

2.1 Starting with Familiar SPI

SPI (Service Provider Interface) is a common mechanism for decoupling definitions from implementations. The classic example is the Java database driver loaded via META-INF/services/java.sql.Driver.

DriverManager loads and initializes the driver at runtime.

The SPI pattern follows the principle “standard, identify, register, run”. Files in META-INF/services act as conventions that ServiceLoader reads to instantiate the appropriate class.

Thus, SPI works by loading files from a predefined directory, reading class names, and instantiating them at runtime.

2.2 First Advanced Reading

Beyond the basic principle, two questions arise:

Why must the file be placed in META-INF/services? Could another directory be used?

Why does the file contain only implementation class names? Could other formats be used?

The answers reveal that these are agreed‑upon conventions—standards. The execution flow is: load file from the convention path, instantiate the class, register it in a container, and later retrieve and run it.

The key steps can be summarized as standard, identify, register, run . Different implementations (e.g., using Redis or Zookeeper for registration) are possible, showing that SPI is just one solution among many.

System extensibility can follow the rule “standard, identify, register, run” to evolve various concrete implementations. When reading source code, focus on universal patterns that can be transformed into reusable solutions.

2.3 Second Advanced Reading

The core idea is to grasp a framework’s fixed workflow and the points where user logic can be injected. For example, Spring’s PostProcessor follows the same “standard, identify, register, run” pattern.

3. Accumulating Architectural Thinking

3.1 Architecture Is Not Fancy

Architecture exists to solve concrete problems, not to create empty diagrams. Early-stage products focus on market fit; architecture becomes critical when scaling, performance, or reliability issues arise, requiring systematic design.

3.2 Start Small

A solid foundation is essential. By studying small, well‑defined components—such as plugins—one can see the universal process: define an interface, implement it, recognize implementations, load them, and execute. This mirrors open platforms like WeChat mini‑programs, where a QR code acts as a standard that multiple implementations can satisfy.

4. Conclusion

The article demonstrates how to learn architectural design from excellent framework source code: understand the underlying principles, identify universal patterns, and build reusable design solutions that can be applied to real‑world problems.