Continuous Delivery in Java (Abraham Marín-Pérez Daniel Bryant)（Z-Library）

【One-Line Pitch】 A practical field guide for experienced Java developers who need to move beyond writing code and own the whole path to production—architecture, build pipelines, packaging, testing, and deployment. Read it if you want to make releases boring, safe, and frequent. 【Book Arc】 - **Opening (~0%–10%)**: Frames continuous delivery as a business and lifecycle concern, then lays the CI foundation—version control, branching strategies (trunk-based, feature branching, Gitflow), code review, and the anatomy of a pipeline from unit tests through acceptance and user acceptance testing. - **Early (~10%–30%)**: Shifts to architecture, arguing that loosely coupled, highly cohesive, observable services make CD tractable; covers microservices impacts on pipelines and the learning curves of PaaS and FaaS/serverless platforms. - **Middle (~30%–55%)**: Gets hands-on with the toolchain—JVM build tools (Maven, Gradle, Bazel-style monorepo tools, SBT, Leiningen, Make), dependency management and "dependency hell," artifact packaging (fat JARs, WARs, Spring Boot), and machine/container image creation with tools like Packer. - **Late (~55%–85%)**: Moves into quality assurance and the deploy/release split—functional and system quality attribute testing (performance, load, soak, scalability, security scanning), plus controlled failure and chaos-style testing in the pipeline. - **Ending (~85%–100%)**: Closes on running and observing systems in production—local build/test workflows, monitoring, metrics, and APM adapted to distributed services. (Excerpts do not cover the final chapters in detail.) 【Key Takeaways】 - **CD is a lifecycle discipline, not a tool** (Opening): it spans version control, review, build, test, and deploy—each stage must be automated and gated. - **Branching strategy is a deliberate choice** (Opening): trunk-based development, feature branching, and Gitflow each trade off integration speed against isolation; there is no one-size-fits-all answer. - **Architecture determines CD feasibility** (Early): loose coupling, high cohesion, and observability make services easier to test, diagnose, and deploy independently. - **Microservices multiply pipeline complexity** (Early): multiple pipelines, orchestrated deployments, service virtualization, version compatibility, and adapted monitoring all become new concerns. - **Modern platforms impose learning curves** (Early): PaaS sandboxes restrict runtime and OS access, while FaaS demands event-driven, asynchronous thinking—budget for this. - **Builds should be deterministic** (Middle): version ranges and "dependency hell" undermine reproducibility; pin versions and treat artifacts as immutable. - **Packaging choices matter** (Middle): fat JARs, WARs, VM images, and Docker images each suit different deployment targets and pipeline stages. - **Test beyond functionality** (Late): acceptance tests must validate nonfunctional attributes—reliability, performance, scalability, and security—and simulate failure in a controlled way. 【Reading Tips】 - Deep-read the architecture and pipeline-design chapters; skim the CLI/tool walkthroughs (ls, curl, Maven snippets) if you already know them. - Treat the tool sections as a menu, not a checklist—pick the build tool, artifact format, and platform that match your stack. - Pay closest attention to the deploy/release separation and quality-attribute testing; these are the concepts most often skipped in practice. - Keep a notebook of "learning curve" warnings for PaaS/FaaS before committing your team to a platform. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering roughly the first half of the book; later production-observability and advanced pipeline chapters are only lightly represented.