Spring Boot实战 = Spring Boot in action (Craig Walls)（Z-Library）

【One-Line Pitch】 A hands-on guide for Java developers who want to build production-ready Spring applications with minimal configuration, covering everything from project setup to testing and cloud deployment. 【Book Arc】 - **Opening (~0%–10%)**: Introduces Spring Boot's four core pillars—auto-configuration, starter dependencies, the command-line interface (CLI), and Actuator—and walks through the fastest ways to bootstrap a project, including Spring Initializr and IDE integration. - **Early (~10%–29%)**: Builds a complete reading-list application using only starter dependencies and auto-configuration, demonstrating how to define domain models, repositories, and web controllers without writing explicit Spring XML or Java configuration. - **Middle (~29%–48%)**: Explains how to customize auto-configured behavior through application properties, override defaults with conditional annotations, use Spring Profiles for environment-specific settings, and create custom error pages. - **Middle (~48%–65%)**: Dives into testing strategies, from Spring's integration test support and Mock MVC for controller tests to launching real embedded servlet containers for full-stack web testing. - **Late (~65%–85%)**: Explores the Spring Boot CLI and Groovy scripts for rapid prototyping, then introduces Grails 3 as a framework built on Spring Boot for convention-over-configuration development. - **Ending (~85%–100%)**: Covers Actuator's production-ready features—health checks, metrics, and monitoring endpoints—and finishes with deployment options, including traditional WAR files and cloud platforms like Cloud Foundry. 【Key Takeaways】 - **Starter dependencies eliminate version management** (Early): Instead of tracking library versions manually, you declare a single starter like `spring-boot-starter-web`, and Spring Boot manages compatible transitive dependencies—check the dependency tree with `gradle dependencies` or `mvn dependency:tree` when curious. - **Auto-configuration is conditional, not magic** (Early): Spring Boot's configuration classes use `@ConditionalOnMissingBean` and similar annotations to apply defaults only when you haven't defined your own beans, so your custom configuration always takes precedence. - **Application properties are the primary tuning knob** (Middle): From server ports to HTTPS settings and logging levels, you can adjust auto-configured components without touching code—properties like `server.port=8443` and `server.ssl.*` handle infrastructure concerns declaratively. - **Spring Profiles handle environment differences** (Middle): Use `@Profile` to activate different beans or configuration classes per environment (dev, test, prod), solving the classic problem of database URLs and security settings varying across deployments. - **Custom error pages are just templates** (Middle): Create an `error.html` (or `error.ftl`, `error.vm`, etc.) in the templates directory, and Spring Boot automatically serves it with useful attributes like `timestamp`, `status`, and `message` for debugging. - **Testing scales from unit to full-stack** (Middle): Start with `@SpringJUnit4ClassRunner` for context-loaded integration tests, use Mock MVC for fast controller verification without a server, and switch to `@WebIntegrationTest` when you need a real embedded container and HTTP requests. - **The CLI enables Groovy-based rapid development** (Late): With Spring Boot CLI, you can write entire applications in Groovy scripts and run them directly from the command line, ideal for prototypes and demos—though traditional Maven/Gradle projects remain the norm for production. - **Actuator brings production visibility** (Late): Expose operational endpoints for health, metrics, and application internals via HTTP, remote shell, or JMX, giving you the monitoring capabilities Netflix-style microservices demand. 【Reading Tips】 - **Skim Chapter 1** if you're already familiar with Spring basics—the four-pillar overview and project setup options are useful, but the real value starts with the hands-on example in Chapter 2. - **Deep-read Chapter 2 and 3** to internalize the auto-configuration model; the reading-list application is simple enough to follow line-by-line, and the conditional annotation explanations are the key to mastering customization. - **Pay special attention to the testing chapter** (Chapter 4)—the progression from `@ContextConfiguration` to Mock MVC to `@WebIntegrationTest` mirrors how you'll actually test real applications, so work through the examples rather than skimming. - **Treat the CLI and Grails chapters as optional** unless you're prototyping or prefer Groovy; for most Java developers, the Maven/Gradle workflow with Spring Initializr is the practical path. - **Keep the Actuator chapter (Chapter 7) as a reference** for production—you won't need it daily, but when you do need health checks or metrics, the endpoint details are invaluable. 【Coverage Limits】 The excerpts cover roughly the first half of the book in detail (setup, auto-configuration, customization, and testing), with lighter coverage of the CLI, Grails, Actuator, and deployment chapters—the guide reflects this emphasis.