- 出版社: Wiley; 1 (2006年6月5日)
- 平装: 286页
- 语种： 英语
- ISBN: 0470858923
- 条形码: 9780470858929
- 商品尺寸: 19.1 x 1.6 x 23.6 cm
- 商品重量: 531 g
- ASIN: 0470858923
- 用户评分: 分享我的评价
Refactoring in Large Software Projects: Performing Complex Restructurings Successfully (英语) 平装 – 2006年6月5日
Stefan Roock works as a consultant and coach for it-agile GmbH (located in Germany). His areas of expertise include agile software development, refactoring techniques and agile project management and among his special interests are refactoring, incremental design and agile customer coaching. Stefan also is frequently a speaker at technical conferences and has published a number of papers and articles. He is co-author of the book "Extreme Programming in Action". You can contact him at firstname.lastname@example.org or http://www.stefanroock.de.
Martin Lippert works as a consultant and coach for it-agile GmbH (located in Germany) and is an expert on agile software development, refactoring techniques and Eclipse technology. His special interests include aspect-oriented programming, refactoring, incremental design and the Eclipse platform. Martin is a frequent speaker at technical conferences and has published a number of papers and articles. He is co-author of the book "Extreme Programming in Action". You can contact him at email@example.com or http://www.martinlippert.com
1.1 Architecture Smells.
1.2 Large Refactorings.
1.3 Refactoring and Databases.
1.4 Refactoring and Published-APIs.
1.5 Recommended Reading.
1.6 For Whom Was this Book Written?.
1.7 The Background of this Book.
2. Refactoring - An Overview.
2.1 Emergent Design.
2.2 What Does Refactoring Mean?.
2.3 The Role of Tests.
2.4 Tools Support for Refactorings.
2.5 Experiences and Recommendations.
3. Architecture Smells.
3.1 Design Principles.
3.2 Smells in Dependency Graphs.
3.3 Smells in Inheritance Hierarchies.
3.4 Smells in Packages.
3.5 Smells in Subsystems.
3.6 Smells in Layers.
3.7 Locating Smells.
3.8 Preventing Smells.
4. Large Refactorings.
4.2 Best Practices for Large Refactorings.
4.3 Fragments of Large Refactorings.
4.4 Example: Lists.
5. Refactoring of Relational Databases.
5.1 Differences between Databases and OO Programming Languages.
5.2 Problems in the Interaction of Programs and Database.
5.3 Refactoring of Relational Database Schemas.
5.4 Migration of Data between Different Versions of a Database Schema.
5.5 Refactoring Database Access Codes.
5.6 Roles in a Project.
5.9 A Typical Data Models.
5.10 An Example.
6. API Refactorings.
6.2 Problems of API Refactorings.
6.3 Compatibility Classes.
6.4 Refactoring Tags.
6.5 API Refactorings in Detail.
6.7 Application Migration with Incompatible Subsystem Changes.
6.8 Tips for Designing APIs.
6.9 An Example.
6.10 Another Approach: "Catch Up and Replay".
7. Tool-based Detection and Avoidance of Architecture Smells.
7.1 Specifications of an Analysis Tool.
7.2 Architecture Analysis with Sotograph.
7.3 Architecture Analysis Based on Cycles.
7.4 Metrics-based Architecture Analysis.
7.5 Support for the Preparation of Large Refactorings.
7.6 Support of the Refactoring Process.
Contents: Introduction; Refactoring - An Overview; Architecture Smells; Large Refactorings; Refactoring of Relational Databases; API Refactorings; Tool-Based Detection and Avoidance of Architecture Smells; Conclusion; Glossary; Index
This book will be most helpful at the architecture level of a system; that is, when you determine that you've painted yourself into a design corner. It may be necessary to introduce a new feature that is somewhat similar to an existing one, but you can't just kill off the old feature due to unknown usage by others. Roock and Lippert show how it's possible to make these wholesale changes in a manner that allows for a graceful degradation of current functionality without sacrificing the new design. It's also helpful if you've solely focused on refactoring at the code level. The term "code smells" refer to situations where code develops a "stench" due to bad design or practices. This book takes that concept and stretches it out to the design level. Even if you're not in a situation where you need to redesign a system to remove some architectural smells, you'll learn what types of designs will introduce those "aromas" and how to avoid them. Much better not to make the mistake up front, than to have to refactor it out later.
Not an easy read, and you'll probably find some areas a bit more useful or applicable to where you're at. But if you're responsible for a system that is showing some age and getting harder to maintain, this might be a book that helps you turn the situation around.
This book should be required reading for all developers and architects prior to attempting to refactor any application.
The material is presented very clearly. It touches on all aspects of refactoring form databases and published API's to single classes and methods. It emphasizes the importance of testing in refactoring and the use of emerging technologies (IDE's, plugin, and third party tools) to achieve this refactoring. It also concentrates on problems in applications which they refer to as smells. They identify the most common types of smells, how to locate them and refactor them in existing code and how to prevent them in future developments.
It provides a review of popular design principles and how to successfully refactor applications according to those principles. The examples are practical enough to understand but simple enough to follow without putting the book down. The book also reviews some of the most popular refactoring tools in the market PMD, JDepend, ClassCycle, Eclipse Metrics Plugin, RefactorIT, Dr. Freud, and SA4J.
Each chapter is organized differently. When covering the best practices for a large refactoring the author presents with a set of the most common problems and solutions. When covering how to refactor databases the author presents a very methodical approach. The constant throughout the reading is that every chapter presents a topic, provides experiences and recommendations as well as further reading that is available on any covered material.
I would definitely recommend that every java developer read this book sooner rather than later. It will provide you with a different perspective to guide you as you build your applications. After all, knowing what not to do is often as important as knowing what to do.