Home > Store > Software Development & Management
Java Application Architecture: Modularity Patterns with Examples Using OSGi
- By Kirk Knoernschild
- Published Mar 15, 2012 by Prentice Hall. Part of the Robert C. Martin Series series.
- Copyright 2012
- Dimensions: 7" x 9-1/8"
- Pages: 384
- Edition: 1st
- Book
- ISBN-10: 0-321-24713-2
- ISBN-13: 978-0-321-24713-1
Register your product to gain access to bonus material or receive a coupon.
Product Author Bios
Kirk Knoernschild is an analyst at Gartner Group covering many aspects of application platform strategies, including development platforms, programming languages and frameworks, mobile application platforms, and the software development life cycle (SDLC). He was previously an analyst at Burton Group, and before that Mr. Knoernschild was a software developer who could be found working in the trenches on enterprise software development projects. With more than seventeen years of software development experience, Mr. Knoernschild has filled most roles on the software development team. In 2002, Mr. Knoernschild wrote the book "Java Design: Objects, UML, and Process," published by Addison-Wesley. Mr. Knoernschild is an open source contributor, has written numerous articles, and is a frequent conference speaker. He has trained and mentored thousands of software professionals on topics including Java/J2EE, modeling, software architecture and design, component-based development, service-oriented architecture, and software process. Mr. Knoernschild is trapped in a software developer's body, and continues to enjoy hacking in a variety of languages, including Java, .NET, Ruby, and PHP.
“I’m dancing! By god I’m dancing on the walls. I’m dancing on the ceiling. I’m ecstatic. I’m overjoyed. I’m really, really pleased.”
–From the Foreword by Robert C. Martin (a.k.a. Uncle Bob)
This isn’t the first book on Java application architecture. No doubt it won’t be the last. But rest assured, this title is different. The way we develop Java applications is about to change, and this title explores the new way of Java application architecture.
Over the past several years, module frameworks have been gaining traction on the Java platform, and upcoming versions of Java will include a module system that allows you to leverage the power of modularity to build more resilient and flexible software systems. Modularity isn’t a new concept. But modularity will change the way we develop Java applications, and you’ll only be able to realize the benefits if you understand how to design more modular software systems.
Java Application Architecture will help you
- Design modular software that is extensible, reusable, maintainable, and adaptable
- Design modular software today, in anticipation of future platform support for modularity
- Break large software systems into a flexible composite of collaborating modules
- Understand where to place your architectural focus
- Migrate large-scale monolithic applications to applications with a modular architecture
- Articulate the advantages of modular software to your team
Java Application Architecture lays the foundation you’ll need to incorporate modular design thinking into your development initiatives. Before it walks you through eighteen patterns that will help you architect modular software, it lays a solid foundation that shows you why modularity is a critical weapon in your arsenal of design tools. Throughout, you’ll find examples that illustrate the concepts. By designing modular applications today, you are positioning yourself for the platform and architecture of tomorrow. That’s why Uncle Bob is dancing.
Related Article
Paradoxes of Software Architecture
Author's Site
Companion Site
Book companion site: http://modularity.kirkk.com
|
14 of 14 people found the following review helpful
Good modularization advice; not a general software architecture book,
Amazon Verified Purchase(What's this?)
This review is from: Java Application Architecture: Modularity Patterns with Examples Using OSGi (Robert C. Martin Series) (Paperback)
Review: 3.5 starsThis is a readable introduction to the principles of code modularity written from the perspective of a practitioner, not an academic. I can recommend it for programmers early in their careers since we all wrote code with poor dependency management when we were young, and this book guides programmers down a better path. Beware: The book's title should be "Modularizing Java Programs" since it covers only that aspect of program design. The author appears unaware of the published field of software architecture, which would have helped him situate his good advice. This is NOT a book on software architecture, generally. Pro: * Chapter 7 showing the progressive packaging of the example system by applying the patterns. This provides an excellent context to understand the value of each pattern since each refactoring is preceded by a business goal like "We'd like to use this part of the code elsewhere, but not that part"... Read more
1 of 1 people found the following review helpful
Should be superfluous,
This review is from: Java Application Architecture: Modularity Patterns with Examples Using OSGi (Robert C. Martin Series) (Paperback)
Kirk Knoernschild's book ought to be made superfluous, but as it stands it is direly needed.At least the first two parts: "The Case for Modularity" and "The Patterns" should be known by heart by any Java developer. It should be second nature for disciplined and professional developers. I highly recommend the book for anyone interested in modularity, especially developers looking at an existing code base resembling a big ball of mud who wants to disentangle it.
5 of 7 people found the following review helpful
The most Important Software Architecture Practices, By
This review is from: Java Application Architecture: Modularity Patterns with Examples Using OSGi (Robert C. Martin Series) (Paperback)
Finally someone has put the most important software architecture practices into words. Within this book lies the concepts that are the heart of true agility. Without a modularized architecture, any decent size project can not achieve agility. I have seen so many agile projects flop because they ignored architecture, in particular they ignored modularization.This book also provides the keys concepts needed to ensure modifiability, the number one quality attribute for any architecture. It drives home the importance of physical design. An often overlooked aspect of designing modularity, yet it is the most important. Good logical design does not really matter if you have a poor physical design. The book is broken down into 3 parts and includes an appendix that gives an overview of the SOLID Principles. Part 1 The Case for Modularity introduces modularity and how it relates to complexity, architecture, SOA, Reuse, Design Rot, and Technical Debt. Part 1... Read more |
Online Sample Chapters
Introduction to Java Application Architecture: Modularity Patterns with Examples Using OSGi
Java Application Architecture: Architecture and Modularity
Table of Contents
Foreword by Robert C. Martin xix
Foreword by Peter Kriens xxi
Acknowledgments xxv
About the Author xxvii
Introduction 1
Object-Oriented Design 2
Logical versus Physical Design 3
Modularity 4
Who This Book Is For 6
How This Book Is Organized 7
Pattern Form 10
Pattern Catalog 12
The Code 13
An Opening Thought on the Modularity Patterns 14
Reference 14
Part I: The Case for Modularity 15
Chapter 1: Module Defined 17
1.1 Defining a Module 17
1.2 Succinct Definition of a Software Module 20
1.3 Conclusion 20
Chapter 2: The Two Facets of Modularity 21
2.1 The Runtime Model 21
2.2 The Development Model 22
2.3 Modularity Today 25
2.4 Conclusion 27
Chapter 3: Architecture and Modularity 29
3.1 Defining Architecture 29
3.2 A Software Architecture Story 30
3.3 The Goal of Architecture 33
3.4 Modularity: The Missing Ingredient 36
3.5 Answering Our Questions 43
3.6 Conclusion 44
3.7 References 44
Chapter 4: Taming the Beast Named Complexity 45
4.1 Enterprise Complexity 46
4.2 Technical Debt 47
4.3 Design Rot 48
4.4 Cyclic Dependencies–The Death Knell 50
4.5 Joints, Modules, and SOLID 56
4.6 Managing Complexity 57
4.7 Benefits of Modularity 59
4.8 Conclusion 60
4.9 References 60
Chapter 5: Realizing Reuse 61
5.1 The Use/Reuse Paradox 62
5.2 The Reuse Disclaimer 63
5.3 Reuse or Use 64
5.4 Modular Tension 65
5.5 Modular Design 66
5.6 Conclusion 67
5.7 Reference 68
Chapter 6: Modularity and SOA 69
6.1 All the Way Down, Revisited 69
6.2 Granularity–Architecture’s Nemesis 72
6.3 An Alternate View 79
6.4 Conclusion 80
Chapter 7: Reference Implementation 83
7.1 Why No OSGi? 83
7.2 Background on This Exercise: Building the System 84
7.3 Version 1 85
7.4 First Refactoring 87
7.5 Second Refactoring 90
7.6 Third Refactoring 93
7.7 Fourth Refactoring 95
7.8 Fifth Refactoring 98
7.9 Sixth Refactoring 99
7.10 Seventh Refactoring 102
7.11 The Postmortem 103
7.12 Conclusion 110
7.13 Reference 110
Part II: The Patterns 111
Chapter 8: Base Patterns 115
Manage Relationships 116
Module Reuse 125
Cohesive Modules 139
Chapter 9: Dependency Patterns 145
Acyclic Relationships 146
Levelize Modules 157
Physical Layers 162
Container Independence 170
Independent Deployment 178
Reference 185
Chapter 10: Usability Patterns 187
Published Interface 188
External Configuration 200
Default Implementation 206
Module Facade 212
Chapter 11: Extensibility Patterns 221
Abstract Modules 222
Implementation Factory 229
Separate Abstractions 237
Reference 244
Chapter 12: Utility Patterns 245
Colocate Exceptions 246
Levelize Build 253
Test Module 263
Part III: Poma and OSGi 271
Chapter 13: Introducing OSGi 273
13.1 Some History 273
13.2 Benefits of OSGi 274
13.3 Digesting OSGi 276
13.4 OSGi Bundle 277
13.5 OSGi Runtime Management 279
13.6 The Two Facets of Modularity, Revisited 279
13.7 OSGi and the Patterns 279
Chapter 14: The Loan Sample and OSGi 283
14.1 Getting Started 283
14.2 The Manifests 285
14.3 μServices 286
14.4 Installation and Execution 292
14.5 Conclusion 293
Chapter 15: OSGi and Scala 295
15.1 Getting Started 295
15.2 The Scala Code 296
15.3 Scala Bean Configuration 299
15.4 Scala μService Configuration 299
15.5 Building the Scala Module 300
15.6 Installation and Execution 300
15.7 Conclusion 301
Chapter 16: OSGi and Groovy 303
16.1 Getting Started 303
16.2 The Groovy Code 304
16.3 Groovy Bean Configuration 306
16.4 Groovy Service Configuration 307
16.5 Building the Groovy Module 307
16.6 Installation and Execution 308
16.7 Conclusion 309
Chapter 17: Future of OSGi 311
17.1 OSGi as an Enabler 312
17.2 The Disruption 312
17.3 The Power of Ecosystems 314
17.4 The Ecosystem 316
17.5 Conclusion 317
Appendix: SOLID Principles of Class Design 319
Single Responsibility Principle (SRP) 320
Open Closed Principle (OCP) 320
Liskov Substitution Principle (LSP) 323
Dependency Inversion Principle (DIP) 325
Interface Segregation Principle 327
Composite Reuse Principle (CRP) 329
References 335
Index 337
Sample Pages
Download the sample pages (includes Chapter 3 and Index)
This book includes free shipping!
This book includes free shipping!
eBook (Watermarked)
$35.99
$28.79
Includes EPUB, MOBI, and PDF
About eBook Formats
This eBook includes the following formats, accessible from your Account page after purchase:
EPUBThe open industry format known for its reflowable content and usability on supported mobile devices.
MOBIThe eBook format compatible with the Amazon Kindle and Amazon Kindle applications.
PDFThe popular standard, used most often with the free Adobe® Reader® software.
This eBook requires no passwords or activation to read. We customize your eBook by discretely watermarking it with your name, making it uniquely yours.
- Request an Instructor or Media review copy.
- Corporate, Academic, and Employee Purchases
- International Buying Options
Get access to thousands of books and training videos about technology, professional development and digital media from more than 40 leading publishers, including Addison-Wesley, Prentice Hall, Cisco Press, IBM Press, O'Reilly Media, Wrox, Apress, and many more. If you continue your subscription after your 30-day trial, you can receive 30% off a monthly subscription to the Safari Library for up to 12 months. That's a total savings of $199.
