Spring源码深度解析（第2版）（异步图书） (郝佳)（Z-Library）

# Spring源码深度解析（第2版）— Reading Guide ## 【One-Line Pitch】 A deep-dive, example-driven walkthrough of Spring's internal source code—covering the core container, AOP, enterprise integrations, and Spring Boot—for Java developers who already use Spring and want to understand *how* it works, not just *what* it does. ## 【Book Arc】 - **Opening (~0%–10%)**: Book structure and philosophy. The author explains his "peel-the-onion" approach—starting from concrete examples and tracing them through the source—and lays out the three-part organization: core implementation (Chapters 1–7), enterprise applications (Chapters 8–13), and Spring Boot (Chapter 14). Chapter 1 covers Spring's overall architecture and the sometimes painful environment setup: downloading source from GitHub, importing into IDEA, and fixing cglib/objenesis and AspectJ compilation issues. - **Early (~10%–25%)**: Container fundamentals. Chapter 2 walks through the simplest possible Spring usage—reading an XML config, instantiating a bean, calling a method—and reveals the enormous machinery behind it. Key classes (DefaultListableBeanFactory, XmlBeanDefinitionReader) and the resource-loading pipeline are introduced. Chapter 3–4 cover parsing of default tags (bean, alias, import, embedded beans) and custom tags, including namespace resolution and handler extraction. - **Middle (~25%–50%)**: Bean loading and container extension. Chapter 5 is the heart of the IoC container: FactoryBean usage, singleton caching, circular dependency resolution, and the full bean creation sequence (instantiation, property injection, initialization, DisposableBean registration). Chapter 6 extends the picture to ApplicationContext: environment preparation, BeanFactoryPostProcessor activation, message resources, event multicasting, and listener registration. - **Middle–Late (~50%–75%)**: AOP and enterprise integrations. Chapter 7 covers both dynamic AOP (proxy creation, advisor matching) and static AOP (AspectJ weaving). Chapters 8–13 move to practical enterprise modules: JDBC abstraction, MyBatis integration, transaction management (creation, rollback, commit), SpringMVC request handling, remote services (RMI, HttpInvoker), and Spring messaging with JMS/ActiveMQ. - **Ending (~75%–100%)**: Spring Boot. Chapter 14 explores Spring Boot's auto-configuration magic: SpringApplication startup, spring.factories loading, Conditional mechanism, property auto-configuration, and Tomcat startup—showing how Boot leverages Spring's extension points to the fullest. ## 【Key Takeaways】 - **Spring's "simple" code is deceptively complex** (Early): A single line like `new XmlBeanFactory(resource)` triggers a long chain of resource encapsulation, stream handling, validation-mode detection, Document parsing, and BeanDefinition registration—the book's core method is tracing this chain step by step. - **DefaultListableBeanFactory is the center of the bean universe** (Early): It's the default implementation for bean registration and loading, with XmlBeanFactory adding only a custom XML reader. Understanding its class hierarchy (BeanFactory, SingletonBeanRegistry, BeanDefinitionRegistry, etc.) gives you a map for the entire container. - **Resource abstraction unifies config file access** (Middle): Spring's `Resource` interface wraps files, classpath entries, URLs, and streams with a common API. This is both a practical utility you can reuse and a key to understanding how Spring decouples config sources from parsing logic. - **ignoreDependencyInterface prevents unwanted auto-wiring** (Middle): When a bean implements certain Aware interfaces (BeanNameAware, BeanFactoryAware), Spring skips auto-wiring those dependencies—a subtle but important detail for understanding container behavior. - **XML parsing follows a three-step pattern** (Middle): Get validation mode (DTD vs XSD) → load Document → register BeanDefinitions. The third step is the most complex and is where default and custom tag parsing diverge. - **Circular dependencies are solved via early exposure** (Middle): Spring handles circular references by recording an ObjectFactory for the bean being created, allowing early access before full initialization—a mechanism worth understanding even if you rarely encounter it in practice. - **AOP in Spring is two different beasts** (Early–Middle): Dynamic AOP uses proxy creation with advisor matching (AnnotationAwareAspectJAutoProxyCreator), while static AOP relies on AspectJ's compile-time weaving with `aspect` keywords and the ajc compiler—the book covers both, including setup pitfalls. - **Spring Boot is Spring's extension power on steroids** (Ending): Boot's auto-configuration works through spring.factories loading, Conditional annotations, and property binding—all built on the same extension mechanisms (BeanFactoryPostProcessor, BeanPostProcessor) covered in earlier chapters. ## 【Reading Tips】 - **Skim Chapter 1's setup sections** (~5%–10%): The cglib/objenesis and AspectJ compilation fixes are useful if you plan to build Spring from source, but you can skip ahead if you just want the conceptual content. - **Deep-read Chapters 2 and 5**: These are the foundation—container initialization and bean loading. The class diagrams and sequence diagrams are essential; don't rush past them. If you understand these two chapters, the rest of the book becomes much easier. - **Use the examples as your entry point**: Each chapter starts with a working example, then traces it through the source. Follow along by opening the actual Spring source in your IDE—the book's line-by-line analysis makes most sense when you can see the code yourself. - **Treat Chapter 14 as a capstone, not a standalone**: Spring Boot's auto-configuration only makes sense if you've absorbed the extension mechanisms (BeanFactoryPostProcessor, BeanPostProcessor, custom tag parsing) from earlier chapters. Read it last, and expect to revisit earlier sections. - **Watch for the "why" behind the "what"**: The author frequently explains *why* Spring made certain design choices (e.g., repackaging cglib, ignoring certain dependency interfaces). These insights are more valuable than the code walkthroughs themselves. ## 【Coverage Limits】 This guide is based on the book's table of contents, preface, and early chapters (roughly the first 50% of content). Detailed analysis of later chapters (AOP internals, JDBC/MyBatis integration, transactions, SpringMVC, remote services, messaging, and Spring Boot) is not covered in the source excerpts—use the chapter summaries above as a roadmap for those sections. ##