The reasonable man adapts himself to the world; the unreasonable one persists in trying to adapt the world to himself. Therefore, all progress depends on the unreasonable man.
So, novice-expert-aficionado-learner, welcome to our dependency injection theme park! We'll begin this tour of dependency injection at the gate: by first defining the problem it solves.
The tour will then proceed down the streams of specific implementations and popular technologies, examining quick solutions in such frameworks as Guice, Spring, and PicoContainer, among others. A long break will follow for the purpose of theoretical nourishment, where we shall discuss the foundational idioms behind dependency injection, its core viral ideology, its types and practices.
Then, we'll peruse the hall of curiosities where we consider such peculiar notions as objects with managed state, lifecycle, and modularity and examine their curious aspectual behaviors.
In turn, we'll descend into the caverns of pitfalls, nuances, and corner cases that ought to titillate and horrify the strongest of constitutions; for when you cross these lines you can expect the demons of class loading, dynamic proxying, and unintended encapsulation to rear their ugly heads, only to be shown up by even greater challenges of concurrency.
We'll make a round about the marvelous gilded architectures of enterprise applications, casting a purposeful eye at their grandeur, which is composed of modular, remote-able service models that separate cleanly between compartments of the enterprise—particularly those nefarious tiers, web and business.
These will leave us with a meditation on the big picture—how we can marry these elegant idioms of dependency injection with their many suitors: applications, third-party libraries, and frameworks.
Finally, dear tourist, you will be presented with a purposed comparison of popular dependency injection frameworks, gauging their performance, features, safety, and rigor (as a functioning example in chapter 11).
The theme park metaphor aside, I have attempted to structure this book as a journey. While the ideas and engineering patterns explored in this book do not refer to a particular language, many of the examples will be in Java. The frameworks we explore will primarily be well-known Java libraries that are widely in use.
A basic understanding of Java (or C#) is preferable; however, for you to get the best out of this book I also recommend familiarity with the principles of objectoriented programming (particularly encapsulation, polymorphism, and inheritance).