We are going to cover the concept of dependency injection (DI) in a very simple\u00a0 and clear manner. First let’s take a simple definition.<\/p>\n
Content<\/strong><\/p>\n <\/p>\n Dependency Injection is a design pattern whereon object provides another object with dependencies. So the easiest way to understand it to to use an example. But let’s first understand what dependency means.<\/p>\n Well, dependency means something needs something else to function. For example, a computer needs a hard disk, keyboard, memory etc.<\/p>\n The computer class is represented below.<\/p>\n <\/p>\n Class with no Dependency Injection<\/p>\n <\/p>\n If you look at the computer class, you will notice that the the computer class creates its own HardDisk and RAM. You do this using the new keyword<\/p>\n <\/p>\n The computer object uses the HitachiHD (it depends on the HitachiHD). Now assuming that in future we want to use SeagateHD. It means you need to recreate the class with the new SeagateHD. The could be very difficult if the class in not simple or there are many classes.<\/p>\n This problem is solved by dependency injection. With Dependency injection, you don’t need to create this dependent classes inside the class. You simply get them. They are injected at runtime.<\/p>\n <\/p>\n Basically, there are three types of dependency injection as outlined below.<\/p>\n a. Constructor Injection<\/strong><\/p>\n In this case, the dependencies are provided through a class constructor<\/p>\n b. Setter Injection<\/strong><\/p>\n In this type, the client provides a setter method that is used to inject the dependency into the class that requires it.<\/p>\n c. Interface Injection<\/strong><\/p>\n Here, the dependency (dependent class) provides a method that can be called. The method takes the client that requires the dependency and provides the client with the required dependency.<\/p>\n <\/p>\n Class with Dependency Injection<\/p>\n <\/p>\n So you can see that in this class, there is new instantiation of new dependencies. It is then the work of DI to:<\/p>\n <\/p>\n If therefore, there are changes in these objects, you don’t have to re-write the class. Dependency Injection takes care of it! It doesn’t have to concern the class. The class just gets the updated object.<\/p>\n <\/p>\n This is the principle behind dependency injection. It simply states that a class should not configure its dependencies statically (tight-coupling). The configuration should be done by another class from the outside (loose-coupling). So we are decoupling the class from it’s dependencies.<\/p>\n According to this principle, a class should focus on performing required action and not on creating objects. Object creation should happen elsewhere.<\/p>\n <\/p>\n Easier Code Maintainability:<\/b> this means that code can easily be extended without having to modify all the codes.<\/p>\n Boiler-plate Code Reduction<\/strong>: so code to instantiate new\u00a0 dependent objects are completed move away from the class.<\/p>\n Separation of Concerns<\/strong>: each code could concentrate on handling specific tasks<\/p>\n Easier Unit Testing:<\/strong> with DI, it is easier to test each component of the code. Mock objects could easily be used in place of other required code units.<\/p>\n <\/p>\n Learning Curve<\/strong>: It take some time to learn and master the concept of DI<\/p>\n Overuse:<\/strong> Dependency Injection would actually not be very useful for very small applications. So if overused could add unnecessary complexity to the codes<\/p>\n Runtime Errors:<\/strong> Errors that could have been trapped in compile time are shifted to run-time<\/p>\n <\/p>\n <\/p>\n","protected":false},"excerpt":{"rendered":" We are going to cover the concept of dependency injection (DI) in a very simple\u00a0 and clear manner. First let’s take a simple definition. Content … <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"pagelayer_contact_templates":[],"_pagelayer_content":"","footnotes":""},"categories":[85],"tags":[],"class_list":["post-1889","post","type-post","status-publish","format-standard","hentry","category-java"],"_links":{"self":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1889","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/comments?post=1889"}],"version-history":[{"count":1,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1889\/revisions"}],"predecessor-version":[{"id":2057,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1889\/revisions\/2057"}],"wp:attachment":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/media?parent=1889"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/categories?post=1889"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/tags?post=1889"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
1. What is Dependency Injection?<\/h4>\n
public class<\/span> Computer<\/span> {\n\tprivate HardDisk harddisk =<\/span> new HitachiHD();\n\tprivate RAM ram =<\/span> new SDRAM();\n\t\n\t\/\/<\/span>additional codes\n\n}\n<\/pre>\n2. The Problem with Conventional\u00a0Method<\/h4>\n
3. Types of Dependency Injection<\/h4>\n
public<\/span> class<\/span> Computer<\/span> {<\/span>\n\tprivate<\/span> HardDisk harddisk;<\/span>\n\tprivate<\/span> RAM ram;<\/span>\n\t\n\t\/*<\/span>\n\t * With dependency injection, you don't need to instantiate<\/span>\n\t * the dependencies<\/span>\n\t * They are instantiated in another code and provided to this class<\/span>\n\t * when needed<\/span>\n\t *\/<\/span>\n\t\n\t\n\t\/\/Constructor based DI<\/span>\n\tpublic<\/span> Computer<\/span>(<\/span>HardDisk harddisk,<\/span> RAM ram)<\/span> {<\/span>\n\t\tthis<\/span>.<\/span>harddisk<\/span> =<\/span> harddisk;<\/span>\n\t\tthis<\/span>.<\/span>ram<\/span> =<\/span> ram;<\/span>\n\t}<\/span>\n\t\n\t\n\t\/\/Setter based DI<\/span>\n\tvoid<\/span> setHardDisk<\/span>(<\/span>HardDisk harddisk)<\/span> {<\/span>\n\t\tthis<\/span>.<\/span>harddisk<\/span> =<\/span> harddisk;<\/span>\n\t}<\/span>\n\n\t\/\/other codes\t<\/span>\n}<\/span>\n<\/pre>\n4. How\u00a0 Dependency Injection\u00a0 works<\/h4>\n
\n
5. Concept of Inversion of Control(IoC)<\/h4>\n
6. Some Benefits of Dependency Injection<\/h4>\n
Challenges of Dependency Injection<\/h4>\n