Automated Code Refactoring and Modernization with OpenRewrite (Ansgar Schulte)（Z-Library）

【One-Line Pitch】 A practical, hands-on guide to automating large-scale Java code refactoring and modernization with OpenRewrite, from running existing recipes to building, testing, and integrating your own. Best for Java developers, tech leads, and platform engineers facing repetitive migrations or creeping technical debt. 【Book Arc】 - **Opening (~0%–20%)**: Establishes why manual refactoring breaks down at scale and introduces OpenRewrite's core model — lossless semantic trees (LSTs), recipes, visitors, and styles — as the foundation for automated transformations. - **Early (~20%–40%)**: Moves from concepts to usage: how to find, configure, compose, and run existing recipes so you get value from the ecosystem before writing anything yourself. - **Middle (~40%–65%)**: Shifts to authoring, covering declarative recipes and Refaster templates as lower-effort ways to express transformations, then custom imperative recipes for cases those can't handle. - **Late (~65%–85%)**: Deepens the Java-based mechanics — visitors, cursors, testing, validation, and configuration options — the details that separate a fragile recipe from a reliable one. - **Ending (~85%–100%)**: Focuses on complex transformations and integration, so reusable recipes become part of development and build workflows rather than one-off scripts. 【Key Takeaways】 - **Automation beats repetition at scale** (Opening): the book's premise is that applying the same change across hundreds or thousands of files is a consistency problem, not a typing problem — reusable recipes are the answer. - **LSTs are the technical foundation** (Opening): lossless semantic trees preserve formatting and meaning, which is what makes automated transformations safe rather than textual find-and-replace. - **Recipes are the unit of reuse** (Early): learning to find, configure, and compose existing recipes is the fastest path to value before authoring your own. - **Declarative first, imperative when needed** (Middle): declarative recipes and Refaster templates cover many cases with less code; custom imperative recipes handle the rest. - **Visitors and cursors are the working mechanics** (Late): understanding how transformations traverse and locate code is essential for writing correct, non-brittle recipes. - **Testing and validation are not optional** (Late): the book treats recipe testing and validation as core skills, reflecting that untested transformations are a risk to a codebase. - **Integration makes it stick** (Ending): recipes pay off when wired into development and build workflows, turning refactoring into a repeatable, confidence-inspiring process. 【Reading Tips】 - If you only need to run migrations, deep-read the early recipe discovery/configuration material and skim the authoring internals. - If you plan to write recipes, slow down on LSTs, visitors, and cursors — these are the hard spots where misunderstanding produces broken transformations. - Treat the testing and validation material as mandatory, not optional; it's what lets you trust a recipe across a real codebase. - Keep a real project open while reading the later chapters so integration advice lands in context. - Note that examples are Java-based; readers on other stacks should expect to translate concepts rather than copy code. 【Coverage Limits】 This guide is based on the book's description and a single whole-book excerpt; specific chapter titles, code examples, and detailed recipe walkthroughs are not covered here.