Up until now we had a look on the single responsibility, open/closed, liskov substitution and interface segregation principles.
Dependency Inversion is one of the last principle we are gone look at.
The principle states that
A. High-level modules should not depend on low-level modules. Both should depend on abstractions.
B. Abstractions should not depend on details. Details should depend on abstractions.
Let’s get started with some code that violates that principle.
As a software team and we need to implement a project. For now the software team consists of:
A BackEnd Developer
package com.gkatzioura.solid.di;
public class BackEndDeveloper {
public void writeJava() {
}
}And a FrontEnd developer
package com.gkatzioura.solid.di;
public class FrontEndDeveloper {
public void writeJavascript() {
}
}And our project uses both throughout the development process.
package com.gkatzioura.solid.di;
public class Project {
private BackEndDeveloper backEndDeveloper = new BackEndDeveloper();
private FrontEndDeveloper frontEndDeveloper = new FrontEndDeveloper();
public void implement() {
backEndDeveloper.writeJava();
frontEndDeveloper.writeJavascript();
}
}So as we can see the Project class is a high level module and it depends on low level modules such as BackEndDeveloper and FrontEndDeveloper. We are actually violating the first part of the dependency inversion principle.
Also by the inspecting the implement function of the Project.class we realise that the methods writeJava and writeJavascript are methods bound to the corresponding classes. Regarding the project scope those are details since in both cases they are forms of development. Thus the second part of the dependency inversion principle is violated.
In order to tackle this problem we shall implement and interface called the Developer interface.
package com.gkatzioura.solid.di;
public interface Developer {
void develop();
}Therefore we introduce an abstraction.
The BackEndDeveloper shall be refactored to
package com.gkatzioura.solid.di;
public class BackEndDeveloper implements Developer {
@Override
public void develop() {
writeJava();
}
private void writeJava() {
}
}And the FrontEndDeveloper shall be refactored to
package com.gkatzioura.solid.di;
public class FrontEndDeveloper implements Developer {
@Override
public void develop() {
writeJavascript();
}
public void writeJavascript() {
}
}
[/sourecode]
The next step in order to tackle the violation of the first part would be to refactor the Project class so that it will not depend on the FrontEndDeveloper and the BackendDeveloper class.
package com.gkatzioura.solid.di;
import java.util.List;
public class Project {
private List<Developer> developers;
public Project(List<Developer> developers) {
this.developers = developers;
}
public void implement() {
developers.forEach(d->d.develop());
}
}The outcome is that the Project class does not depend on lower level modules but abstractions. Also low-level modules and their details depend on abstractions.
You can find the source code on github.
Also I have compiled a cheat sheet containing a summary of the solid principles. Sign up in the link to receive it.
| Published on Java Code Geeks with permission by Emmanouil Gkatziouras, partner at our JCG program. See the original article here: Solid Principles: Dependency inversion principle Opinions expressed by Java Code Geeks contributors are their own. |
