深入浅出Spring Boot 2.x (杨开振)（Z-Library） (1)

【One-Line Pitch】 A hands-on guide to enterprise Java development with Spring Boot 2.x, moving from annotation-driven Spring fundamentals to persistence, transactions, NoSQL, web layers, and a first look at microservices. Best for Java developers new to Spring Boot or migrating from traditional Spring projects. 【Book Arc】 - **Opening (~0%–10%)**: Frames Spring Boot's "convention over configuration" philosophy and contrasts it with traditional Spring MVC, then walks through environment setup (Eclipse/IDEA, STS plugin, starter dependencies) and a minimal first project. - **Early (~10%–32%)**: Builds the Spring core under full annotation — IoC containers (BeanFactory vs. ApplicationContext), dependency injection, Bean lifecycles and scopes, @Profile environment switching, and AOP with custom interceptors and multiple aspects. - **Middle (~32%–48%)**: Covers database programming via JDBC, JPA/Hibernate, and MyBatis, including datasource and connection-pool configuration, then dives into Spring declarative transactions, isolation levels, and propagation behavior. - **Late (~48%–70%)**: Extends into NoSQL with Redis (RedisTemplate) and MongoDB, plus Spring MVC and REST-style web development. - **Ending (~70%–100%)**: Touches Spring Security, the reactive WebFlux framework, high-concurrency scenarios such as flash-sale/seckill business, packaging, testing, monitoring, and an introduction to Spring Cloud distributed development. 【Key Takeaways】 - **Convention over configuration is the organizing idea** (Opening): Spring Boot supplies sensible defaults and starter dependencies so you can run without XML or boilerplate, customizing only via properties when needed. - **Annotation-based IoC is the foundation for everything later** (Early): BeanFactory and ApplicationContext differ in capability, and Bean lifecycle, scope, and @Profile behavior determine how components are wired and switched across environments. - **AOP is explained from first principles** (Early): The book builds up interceptors and invocation proxies before showing @Aspect, @Pointcut, and advice ordering across multiple aspects. - **Persistence is taught across three stacks** (Middle): JDBC, JPA, and MyBatis are each configured and used, with MyBatis treated as the primary enterprise persistence layer. - **Transactions deserve careful attention** (Middle): Declarative transactions via @Transactional, isolation levels, timeouts, and propagation behavior are demonstrated — including the self-invocation pitfall where a class calling its own method bypasses proxy-based transaction semantics. - **NoSQL integration is practical** (Late): RedisTemplate handles connection acquisition and release automatically, and MongoDB is introduced alongside Redis for non-relational storage. - **The book reaches toward microservices** (Ending): Spring Cloud, WebFlux, security, and high-concurrency cases appear as an on-ramp rather than deep dives. 【Reading Tips】 - Deep-read the Early chapters on IoC, Bean lifecycle, and AOP — these underpin every later chapter and are where annotation-based Spring differs most from XML-era habits. - Skim environment setup (Chapter 2) if you already have a working IDE and starter project; return only for the auto-configuration explanation. - Treat the transaction propagation and self-invocation discussion as a hard spot worth re-reading with the code samples, since it is a common production bug source. - Use the persistence chapters as a reference: pick MyBatis if that is your stack, but read the JDBC transaction section first for grounding. - Read the Ending chapters as orientation, not mastery — they signal what to study next rather than fully teaching microservices. 【Coverage Limits】 The excerpts cover the book's framing, core Spring chapters, persistence, transactions, and the start of Redis, but do not include detailed content from the later WebFlux, security, monitoring, or Spring Cloud chapters. Specific chapter titles and figures beyond those shown are not covered.