Dependency Inversion is one of the five SOLID OO principles that’s become so popular in recent years (sometimes referred to as DIP). My opinion is that it’s a highly valuable concept, and is not well-named. “Dependency inversion” doesn’t mean a great deal on its own, and a lot of attempts to explain it tend to get very heady.
(Speaking of unfortunate naming, “hexagonal architecture” is another concept that I find poorly named. Ironic that the concept is about using abstraction to avoid unnecessary coupling, yet the name itself couples the idea to the number 6, which is totally unrelated to the idea. Fortunately, it’s slowly being renamed as “ports and adapters” in most discussions, which is a much better description.)
My personal preference is towards explanations that are more intuitive, and I’d like to put my two cents in for Dependency Inversion.
To me, a way of describing Dependency Inversion is to use classes to separate the features of the application (the parts that a user might use) from the technology that makes the feature work.
For example, let’s say you have a feature where a user can sign themselves up, and once the user’s information is saved to the database, you have some more steps that need to take place. You could make an interactor called
and it will handle the actions necessary (instead of using a callback).
Let’s say one of the things it needs to do is send an email welcoming the user. Let’s also pretend that you use SendGrid to manage emails. That would mean we could end up with something like
class CompleteUserSetup def self.perform SendGridClient.email "subjectline", "body of email" end end CompleteUserSetup.perform
Will this run? Absolutely. Is it a good example of code that meets the criteria for Dependency Inversion? No.
What’s happening here is that the feature (user setup) is directly mentioning the technology that implements it (SendGrid). It literally has the name of the tool in the code that is defining the feature.
Since there are probably lots of places in the code that send email, if you ever need to switch away from SendGrid, you need to change all those places. Usually it’s not as simple as find-replacing all the instances of “SendGrid” from the code, so a better way is to abstract all of the email interactions into your own class.
class CompleteUserSetup def self.perform OurEmailClient.send_welcome_email end end class OurEmailClient def self.send_welcome_email SendGridClient.email "subjectline", "body of email" end end CompleteUserSetup.perform
Now the feature doesn’t mention the implementation technology. If you kept this pattern going, “SendGrid” would only ever appear in your email client class, and this means that the technology would be decoupled from the features. This is an Adapter pattern, which is basically the first half of Dependency Inversion. (IMHO this is the most common implementation of DI, and this makes testing really easy)
To close the loop of “Dependency Inversion” is to actually pass the client an instance of an email client so it can use more than one.
class CompleteUserSetup def self.perform(client) client.send_welcome_email end end class OurEmailClient def send_welcome_email SendGridClient.email 'subjectline', 'body of email' end end class OurOtherEmailClient def send_welcome_email MailChimpClient.email 'subject, 'body of email' end end email_client = OurEmailClient.new CompleteUserSetup.perform(email_client) # or email_client = OurOtherEmailClient.new CompleteUserSetup.perform(email_client)
Now we’re actually passing the dependency into the location where it’s needed. This means the CompleteUserSetup interactor is totally decoupled from which messaging system it will use.
The reason this matters is that now we can choose any type of email provider we currently support, and we can also add new types of email providers that we didn’t previously use.
To be fair, in Ruby, this isn’t quite the same as in Java. Ruby will allow duck typing, which means that we don’t have to write an Interface. Also, Ruby doesn’t support Interfaces at all, so that aspect of this is missing. Still — the principle behind decoupling does make it very easy to write readable code, and testable code, and I always love that.