{"id":1867,"date":"2016-10-11T08:44:59","date_gmt":"2016-10-11T08:44:59","guid":{"rendered":"http:\/\/codethataint.com\/blog\/?p=1867"},"modified":"2019-02-25T05:20:52","modified_gmt":"2019-02-25T05:20:52","slug":"dependency-injection","status":"publish","type":"post","link":"https:\/\/codethataint.com\/blog\/dependency-injection\/","title":{"rendered":"Dependency Injection"},"content":{"rendered":"

Dependency Injection<\/strong><\/p>\n

What is Dependency<\/strong><\/p>\n

\r\nQuick Example:EMPLOYEE OBJECT WHEN CREATED,\r\n              IT WILL AUTOMATICALLY CREATE ADDRESS OBJECT\r\n   (if address is defines as dependency by Employee object)\r\n<\/pre>\n
Now in the above EMPLOYEE<\/strong> Class is dependent on ADDRESS<\/strong> Class.<\/p>\n
You can not create the Address Object unless you create Employee  Object<\/em><\/p>\n
EMPLOYEE Class is dependent <\/strong> and ADDRESS Class is dependency<\/strong><\/p>\n
What is the purpose of DI?<\/strong>
\nWith dependency injection, objects don’t define their dependencies themselves, the dependencies are injected to them as needed.The purpose of Dependency Injection is to reduce coupling in your application to make it more flexible and easier to test.<\/p>\n
How does it benefit ?<\/strong> The objects don’t need to know where and how to get their dependencies, which results in loose coupling between objects, which makes them a lot easier to test.<\/p>\n
When to use Dependency Injection<\/strong>
\nOne of the most compelling reasons for DI is to allow easier unit testing without having to hit a database and worry about setting up ‘test’ data.Dependency Injection gives you the ability to test specific units of code in isolation. <\/p>\n
Dependency injection is basically providing the objects that an object needs (its dependencies) instead of having it construct them itself<\/strong>. It’s a very useful technique for testing, since it allows dependencies to be mocked or stubbed out.<\/p>\n
Dependencies can be injected into objects by many means (such as constructor injection or setter injection). One can even use specialized dependency injection frameworks (e.g Spring) to do that, but they certainly aren’t required.<\/p>\n
Example<\/strong>
\nA Car depends on wheels, engine, fuel, battery, etc. to run. Traditionally we define the brand of such dependent objects along with the definition of the Car object<\/p>\n
Without Dependency Injection (DI):<\/strong><\/p>\n
\r\nclass Car\r\n{\r\n  private Wheel wh   = new ApolloWheel();\r\n  private Battery bt = new ExideBattery();\r\n\r\n  \/\/The rest\r\n}\r\n<\/pre>\n
Here, the Car object is responsible for creating the dependent objects.<\/p>\n
What if we want to change the type of its dependent object – say Wheel – after the initial ApolloWheel()<\/strong> punctures? We need to recreate the Car object with its new dependency say SpareWheel()<\/strong>, but only the Car manufacturer can do that.<\/p>\n
Then what does the Dependency Injection do us for…?<\/p>\n
When using dependency injection, objects are given their dependencies at run time rather than compile time (car manufacturing time)<\/strong>. So that we can now change the Wheel whenever we want. Here, the dependency (wheel) can be injected into Car at run time.<\/p>\n
After using dependency injection:<\/strong><\/p>\n
\r\nclass Car\r\n{\r\n  private Wheel wh   = [Inject an Instance of Wheel at runtime];\r\n  private Battery bt = [Inject an Instance of Battery at runtime];\r\n\r\n  Car(Wheel wh,Battery bt) \r\n  {\r\n      this.wh = wh;\r\n      this.bt = bt;\r\n  }\r\n\r\n  \/\/Or we can have setters\r\n  void setWheel(Wheel wh) \r\n  {\r\n      this.wh = wh;\r\n  }\r\n}\r\n<\/pre>\n