Despite the scary name, the concept is simple: Your class or function should ask for dependencies upfront. It should not reach out for them. This gives you a few powerful advantages:
1. In unit tests you can pass in mock dependencies to verify/fake behavior.
Imagine your class depends on a database. You really don’t want to require a live database to run your tests, but also you want to be able to test a variety of responses from the database without running a bunch of setup queries. What if your logic depends on the time being around 3AM? You can’t reliably test this if your object pulls time from the environment.
2. Your API doesn’t lie to users about what’s really required to use it.
Imagine if you started cooking a recipe and step 7 read, “Go buy 10 mangos now.” Imagine a Skydive class whose jump() method waited 10 seconds then executed Backpack.getInstance().getParachute.deploy(). “Umm, I’m in the air and the Skydive class didn’t tell me I’d need a backpack…”. Skydive should have required a parachute in the constructor.
3. Your API behaves more predictably.
Imagine a function getNumDays(month). If I pass in February, I usually get 28, but sometimes 29! This is because there’s a hidden dependency on the current year. This function would be useless for processing old data.
Baking the dependencies in
Note that the same principles apply to functions (fine for this exercise, but you should avoid global functions/static methods for all sorts of reasons). Consider this function for baking peanut butter cookies:
function makePBCookies(AlbertsonsPB $pb) {
// ... 20 lines of setup code
$egg = new LargePublixEgg();
$sugar = new DixieSugar('1 cup');
$chef = Yelp::find('chef');
// create an oven
// mix and bake for 10 min
return $cookies;
}From the argument list, it isn’t clear you’ll need a large Publix egg on hand. What if you don’t have a Publix in your area? What if you want less sugary cookies? Let’s refactor:
function makePBCookies(Egg $egg, Sugar $sugar, PB $pb) {
// ... 20 lines of setup code
$chef = Yelp::find('chef');
// create an oven
// mix and bake for 10 min
return $cookies;
}Now it’s immediately clear at the top what ingredients you’ll need; you can use any brands you want; and you can even change amounts/sizes to yield all kinds of flavors. This is really flexible, but we can make it even better:
function makePBCookies(Egg $egg, Sugar $sugar, PB $pb, Oven $oven, Chef $chef) {
$mix = $chef->mix(array($egg, $sugar, $pb));
return $chef->bake($oven, $mix);
}In case it wasn’t obvious, it’s now clear we’ll need a chef and oven, and it makes good sense to outsource the oven design because this logic isn’t really specific to peanut butter cookies. A sign that our refactoring is going well is that the function body is starting to read more like a narrative.
Let’s build the ultimate cookie-making function:
function makeCookies(BakeList $list, Chef $chef, Oven $oven, Decorations $decs = null) {
// BakeList is a composite of recipe & ingredients
$mix = $chef->mix($list->getIngredients(), $list->getRecipe());
$cookies = $chef->bake($oven, $mix);
if ($decs) {
$cookies = $chef->decorate($cookies, $decs);
}
return $cookies;
}We’ve refactored into several easy-to-test components, each with a specific task. This function is also easy to test because we just need to verify how the dependencies are passed and what methods are called on them. If we wanted to go even further we might notice that cookies come out differently in Denver vs. NYC (there’s a hidden dependency on altitude).
But that’s all dependency injection is: asking for what you need and not relying on sniffing dependencies from the environment. It makes code more flexible, more reusable, and more testable. It’s awesome.
I highly recommend Miško Hevery’s 2008 talks about dependency injection and testability, which really solidified the concepts and their importance for me. [This is an improved version of an article I wrote around that time hosted elsewhere.]
