What is dependency injection?

What is dependency injection?

There have been several questions already posted with specific questions about dependency injection, such as when to use it and what frameworks are there for it. However,

What is dependency injection and when/why should or shouldn't it be used?

Answer by wds for What is dependency injection?

Basically, instead of having your objects creating a dependency or asking a factory object to make one for them, you pass the needed dependencies in to the object externally, and you make it somebody else's problem. This "someone" is either an object further up the dependency graph, or a dependency injector (framework) that builds the dependency graph. A dependency as I'm using it here is any other object the current object needs to hold a reference to.

One of the major advantages of dependency injection is that it can make testing lots easier. Suppose you have an object which in its constructor does something like:

public SomeClass() {      myObject = Factory.getObject();  }  

This can be troublesome when all you want to do is run some unit tests on SomeClass, especially if myObject is something that does complex disk or network access. So now you're looking at mocking myObject but also somehow intercepting the factory call. Hard. Instead, pass the object in as an argument to the constructor. Now you've moved the problem elsewhere, but testing can become lots easier. Just make a dummy myObject and pass that in. The constructor would now look a bit like:

public SomeClass (MyClass myObject) {      this.myObject = myObject;  }  

This is one style of dependency injection - via the constructor. Several mechanisms are possible. As noted in the comments, one common alternative is to define a do-nothing constructor, and have the dependencies injected via property setters (h/t @MikeVella). Martin Fowler documents a third alternative (h/t @MarcDix), where classes explicitly implement an interface for the dependencies they wish injected.

When not using dependency injection (such as in classes that do too much work in their constructors etc.), it tends to become much harder to isolate components in unit testing. Back in 2013 when I wrote this answer, this was a major theme on the Google Testing Blog. This remains the biggest advantage to me, as you may not always need the extra flexibility in your run-time design (for instance, for service locator or similar patterns), but you do often need to be able to isolate your classes during testing.

Answer by Adam Ness for What is dependency injection?

Dependency Injection is a practice where objects are designed in a manner where they receive instances of the objects from other pieces of code, instead of constructing them internally. This means that any object implementing the interface which is required by the object can be substituted in without changing the code, which simplifies testing, and improves decoupling.

For example, consider these clases:

public class PersonService {    public void addManager( Person employee, Person newManager ) { ... }    public void removeManager( Person employee, Person oldManager ) { ... }    public Group getGroupByManager( Person manager ) { ... }  }    public class GroupMembershipService() {    public void addPersonToGroup( Person person, Group group ) { ... }    public void removePersonFromGroup( Person person, Group group ) { ... }  }   

In this example, the implementation of PersonService::addManager and PersonService::removeManager would need an instance of the GroupMembershipService in order to do its work. Without Dependency Injection, the traditional way of doing this would be to instantiate a new GroupMembershipService in the constructor of PersonService and use that instance attribute in both functions. However, if the constructor of GroupMembershipService has multiple things it requires, or worse yet, there are some initialization "setters" that need to be called on the GroupMembershipService, the code grows rather quickly, and the PersonService now depends not only on the GroupMembershipService but also everything else that GroupMembershipService depends on. Furthermore, the linkage to GroupMembershipService is hardcoded into the PersonService which means that you can't "dummy up" a GroupMembershipService for testing purposes, or to use a strategy pattern in different parts of your application.

With Dependency Injection, instead of instantiating the GroupMembershipService within your PersonService, you'd either pass it in to the PersonService constructor, or else add a Property (getter and setter) to set a local instance of it. This means that your PersonService no longer has to worry about how to create a GroupMembershipService, it just accepts the ones it's given, and works with them. This also means that anything which is a subclass of GroupMembershipService, or implements the GroupMembershipService interface can be "injected" into the PersonService, and the PersonService doesn't need to know about the change.

Answer by Thiago Arrais for What is dependency injection?

The best definition I've found so far is one by James Shore:

"Dependency Injection" is a 25-dollar term for a 5-cent concept. [...] Dependency injection means giving an object its instance variables. [...].

There is an article by Martin Fowler that may prove useful, too.

Dependency injection is basically providing the objects that an object needs (its dependencies) instead of having it construct them itself. It's a very useful technique for testing, since it allows dependencies to be mocked or stubbed out.

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. You don't need those frameworks to have dependency injection. Instantiating and passing objects (dependencies) explicitly is just as good an injection as injection by framework.

Answer by zby for What is dependency injection?

The accepted answer is a good one - but I would like to add to this that DI is very much like the classic avoiding of hardcoded constants in the code.

When you use some constant like a database name you'd quickly move it from the inside of the code to some config file and pass a variable containing that value to the place where it is needed. The reason to do that is that these constants usually change more frequently than the rest of the code. For example if you'd like to test the code in a test database.

DI is analogous to this in the world of Object Oriented programming. The values there instead of constant literals are whole objects - but the reason to move the code creating them out from the class code is similar - the objects change more frequently then the code that uses them. One important case where such a change is needed is tests.

Answer by gtiwari333 for What is dependency injection?

I found this funny example in terms of loose coupling:

Any application is composed of many objects that collaborate with each other to perform some useful stuff. Traditionally each object is responsible for obtaining its own references to the dependent objects (dependencies) it collaborate with. This leads to highly coupled classes and hard-to-test code.

For example, consider a Car object.

A 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.

Without Dependency Injection (DI):

class Car{    private Wheel wh= new NepaliRubberWheel();    private Battery bt= new ExcideBattery();      //The rest  }  

Here, the Car object is responsible for creating the dependent objects.

What if we want to change the type of its dependent object - say Wheel - after the initial NepaliRubberWheel() punctures? We need to recreate the Car object with its new dependency say ChineseRubberWheel(), but only the Car manufacturer can do that.

Then what does the Dependency Injection do us for...?

When using dependency injection, objects are given their dependencies at run time rather than compile time (car manufacturing time). So that we can now change the Wheel whenever we want. Here, the dependency (wheel) can be injected into Car at run time.

After using dependency injection:

Here, we are injecting the dependencies (Wheel and Battery) at runtime. Hence the term : Dependency Injection.

class Car{    private Wheel wh= [Inject an Instance of Wheel (dependency of car) at runtime]    private Battery bt= [Inject an Instance of Battery (dependency of car) at runtime]    Car(Wheel wh,Battery bt) {        this.wh = wh;        this.bt = bt;    }    //Or we can have setters    void setWheel(Wheel wh) {        this.wh = wh;    }  }  

Source: Understanding dependency injection

Answer by Olivier Liechti for What is dependency injection?

Let's imagine that you want to go fishing:

• Without dependency injection, you need to take care of everything yourself. You need to find a boat, to buy a fishing rod, to look for bait, etc. It's possible, of course, but it puts a lot of responsibility on you. In software terms, it means that you have to perform a lookup for all these things.

• With dependency injection, someone else takes care of all the preparation and makes the required equipment available to you. You will receive ("be injected") the boat, the fishing rod and the bait - all ready to use.

Answer by JaneGoodall for What is dependency injection?

Doesn't "dependency injection" just mean using parameterized constructors and public setters?

James Shore's article shows the following examples for comparison.

Constructor without dependency injection:

public class Example {     private DatabaseThingie myDatabase;       public Example() {       myDatabase = new DatabaseThingie();     }       public void doStuff() {       ...       myDatabase.getData();       ...     }   }   

Constructor with dependency injection:

public class Example {     private DatabaseThingie myDatabase;       public Example(DatabaseThingie useThisDatabaseInstead) {       myDatabase = useThisDatabaseInstead;     }      public void doStuff() {       ...       myDatabase.getData();       ...     }   }  

Answer by TastyCode for What is dependency injection?

From the Book, 'Well-Grounded Java Developer: Vital techniques of Java 7 and polyglot programming

DI is a particular form of IoC, whereby the process of finding your dependencies is outside the direct control of your currently executing code.

Answer by uvsmtid for What is dependency injection?

The whole point of Dependency Injection (DI) is to keep application source code clean and stable:

• clean of dependency initialization code
• stable regardless of dependency used

Practically, every design pattern separates concerns to make future changes affect minimum files.

The specific domain of DI is delegation of dependency configuration and initialization.

Example: DI with shell script

If you occasionally work outside of Java, recall how source is often used in many scripting languages (Shell, Tcl, etc., or even import in Python misused for this purpose).

Consider simple dependent.sh script:

#!/bin/sh  # Dependent  touch         "one.txt" "two.txt"  archive_files "one.txt" "two.txt"  

The script is dependent: it won't execute successfully on its own (archive_files is not defined).

You define archive_files in archive_files_zip.sh implementation script (using zip in this case):

#!/bin/sh  # Dependency  function archive_files {      zip files.zip "$@"  }  

Instead of source-ing implementation script directly in the dependent one, you use an injector.sh "container" which wraps both "components":

#!/bin/sh   # Injector  source ./archive_files_zip.sh  source ./dependent.sh  

The archive_files dependency has just been injected into dependent script.

You could have injected dependency which implements archive_files using tar or xz.

Example: removing DI

If dependent.sh script used dependencies directly, the approach would be called dependency lookup (which is opposite to dependency injection):

#!/bin/sh  # Dependent    # dependency look-up  source ./archive_files_zip.sh    touch         "one.txt" "two.txt"  archive_files "one.txt" "two.txt"  

Now the problem is that dependent "component" has to perform initialization itself.

The "component"'s source code is neither clean nor stable because every changes in initialization of dependencies requires new release for "components"'s source code file as well.

Last words

DI is not as largely emphasized and popularized as in Java frameworks.

But it's a generic approach to split concerns of:

• application development (single source code release lifecycle)
• application deployment (multiple target environments with independent lifecycles)

Using configuration only with dependency lookup does not help as number of configuration parameters may change per dependency (e.g. new authentication type) as well as number of supported types of dependencies (e.g. new database type).

Answer by Chookoos for What is dependency injection?

I think since everyone has written for DI, let me ask a few questions..

1. When you have a configuration of DI where all the actual implementations(not interfaces) that are going to be injected into a class (for e.g services to a controller) why is that not some sort of hard-coding?
2. What if I want to change the object at runtime? For example, my config already says when I instantiate MyController, inject for FileLogger as ILogger. But I might want to inject DatabaseLogger.
3. Everytime I want to change what objects my AClass needs, I need to now look into two places - The class itself and the configuration file. How does that make life easier?
4. If Aproperty of AClass is not injected, is it harder to mock it out?
5. Going back to the first question. If using new object() is bad, how come we inject the implementation and not the interface? I think a lot of you are saying we're in fact injecting the interface but the configuration makes you specify the implementation of that interface ..not at runtime .. it is hardcoded during compile time.

This is based on the answer @Adam N posted.

Why does PersonService no longer have to worry about GroupMembershipService? You just mentioned GroupMembership has multiple things(objects/properties) it depends on. If GMService was required in PService, you'd have it as a property. You can mock that out regardless of whether you injected it or not. The only time I'd like it to be injected is if GMService had more specific child classes, which you wouldn't know until runtime. Then you'd want to inject the subclass. Or if you wanted to use that as either singleton or prototype. To be honest, the configuration file has everything hardcoded as far as what subclass for a type (interface) it is going to inject during compile time.

EDIT

A nice comment by Jose Maria Arranz on DI

DI increases cohesion by removing any need to determine the direction of dependency and write any glue code.

False. The direction of dependencies is in XML form or as annotations, your dependencies are written as XML code and annotations. XML and annotations ARE source code.

DI reduces coupling by making all of your components modular (i.e. replacable) and have well-defined interfaces to each other.

False. You do not need a DI framework to build a modular code based on interfaces.

About replaceable: with a very simple .properties archive and Class.forName you can define wich classes can change. If ANY class of your code can be changed, Java is not for you, use an scripting language. By the way: annotations cannot be changed without recompiling.

In my opinion there is one only reason for DI frameworks: boiler plate reduction. With a well done factory system you can do the same, more controlled and more predictable as your preferred DI framework, DI frameworks promise code reduction (XML and annotations are source code too). The problem is this boiler plate reduction is just real in very very simple cases (one instance-per class and similar), sometimes in the real world picking the appropriated service object is not as easy as mapping a class to a singleton object.

Answer by Waqas Ahmed for What is dependency injection?

In simple words dependency injection (DI) is the way to remove dependencies or tight coupling between different object. Dependency Injection gives a cohesive behavior to each object.

DI is the implementation of IOC principal of Spring which says "Don't call us we will call you". Using dependency injection programmer doesn't need to create object using the new keyword.

Objects are once loaded in Spring container and then we reuse them whenever we need them by fetching those objects from Spring container using getBean(String beanName) method.

Answer by Piyush Deshpande for What is dependency injection?

It means that objects should only have as many dependencies as is needed to do their job and the dependencies should be few. Furthermore, an object?s dependencies should be on interfaces and not on ?concrete? objects, when possible. (A concrete object is any object created with the keyword new.) Loose coupling promotes greater reusability, easier maintainability, and allows you to easily provide ?mock? objects in place of expensive services.

The ?Dependency Injection? (DI) is also known as ?Inversion of Control? (IoC), can be used as a technique for encouraging this loose coupling.

There are two primary approaches to implementing DI:

1. Constructor injection
2. Setter injection

Constructor injection

It?s the technique of passing objects dependencies to its constructor.

Note that the constructor accepts an interface and not concrete object. Also, note that an exception is thrown if the orderDao parameter is null. This emphasizes the importance of receiving a valid dependency. Constructor Injection is, in my opinion, the preferred mechanism for giving an object its dependencies. It is clear to the developer while invoking the object which dependencies need to be given to the ?Person? object for proper execution.

Setter Injection

But consider the following example? Suppose you have a class with ten methods that have no dependencies, but you?re adding a new method that does have a dependency on IDAO. You could change the constructor to use Constructor Injection, but this may force you to changes to all constructor calls all over the place. Alternatively, you could just add a new constructor that takes the dependency, but then how does a developer easily know when to use one constructor over the other. Finally, if the dependency is very expensive to create, why should it be created and passed to the constructor when it may only be used rarely? ?Setter Injection? is another DI technique that can be used in situations such as this.

Setter Injection does not force dependencies to be passed to the constructor. Instead, the dependencies are set onto public properties exposed by the object in need. As implied previously, the primary motivators for doing this include:

1. Supporting dependency injection without having to modify the constructor of a legacy class.
2. Allowing expensive resources or services to be created as late as possible and only when needed.

Here is the example of how the above code would look like:

public class Person {      public Person() {}        public IDAO Address {          set { addressdao = value; }          get {              if (addressdao == null)                throw new MemberAccessException("addressdao" +                               " has not been initialized");              return addressdao;          }      }        public Address GetAddress() {         // ... code that uses the addressdao object         // to fetch address details from the datasource ...      }        // Should not be called directly;      // use the public property instead      private IDAO addressdao;  

Answer by Volksman for What is dependency injection?

Dependency injection is one possible solution to what could generally be termed the "Dependency Obfuscation" requirement. Dependency Obfuscation is a method of taking the 'obvious' nature out of the process of providing a dependency to a class that requires it and therefore obfuscating, in some way, the provision of said dependency to said class. This is not necessarily a bad thing. In fact, by obfuscating the manner by which a dependency is provided to a class then something outside the class is responsible for creating the dependency which means, in various scenarios, a different implementation of the dependency can be supplied to the class without making any changes to the class. This is great for switching between production and testing modes (eg., using a 'mock' service dependency).

Unfortunately the bad part is that some people have assumed you need a specialized framework to do dependency obfuscation and that you are somehow a 'lesser' programmer if you choose not to use a particular framework to do it. Another, extremely disturbing myth, believed by many, is that dependency injection is the only way of achieving dependency obfuscation. This is demonstrably and historically and obviously 100% wrong but you will have trouble convincing some people that there are alternatives to dependency injection for your dependency obfuscation requirements.

Programmers have understood the dependency obfuscation requirement for years and many alternative solutions have evolved both before and after dependency injection was conceived. There are Factory patterns but there are also many options using ThreadLocal where no injection to a particular instance is needed - the dependency is effectively injected into the thread which has the benefit of making the object available (via convenience static getter methods) to any class that requires it without having to add annotations to the classes that require it and set up intricate XML 'glue' to make it happen. When your dependencies are required for persistence (JPA/JDO or whatever) it allows you to achieve 'tranaparent persistence' much easier and with domain model and business model classes made up purely of POJOs (i.e. no framework specific/locked in annotations).

Answer by mohit sarsar for What is dependency injection?

Dependency injection is the heart of the concept related with Spring Framework.While creating the framework of any project spring may perform a vital role,and here dependency injection come in pitcher.

Actually,Suppose in java you created two different classes as class A and class B, and whatever the function are available in class B you want to use in class A, So at that time dependency injection can be used. where you can crate object of one class in other,in the same way you can inject an entire class in another class to make it accessible. by this way dependency can be overcome.

DEPENDENCY INJECTION IS SIMPLY GLUING TWO CLASSES AND AT THE SAME TIME KEEPING THEM SEPARATE.

Answer by Ali Issa for What is dependency injection?

I know there are already many answers, but I found this very helpful: http://tutorials.jenkov.com/dependency-injection/index.html

No Dependency:

public class MyDao {      protected DataSource dataSource =      new DataSourceImpl("driver", "url", "user", "password");      //data access methods...    public Person readPerson(int primaryKey) {...}    }  

Dependency:

public class MyDao {      protected DataSource dataSource = null;      public MyDao(String driver, String url, String user, String   password){      this.dataSource = new DataSourceImpl(driver, url, user, password);    }      //data access methods...    public Person readPerson(int primaryKey)    {...}    }  

Notice how the DataSourceImpl instantiation is moved into a constructor. The constructor takes four parameters which are the four values needed by the DataSourceImpl. Though the MyDao class still depends on these four values, it no longer satisfies these dependencies itself. They are provided by whatever class creating a MyDao instance.

Answer by StuartLC for What is dependency injection?

What is Dependency Injection (DI)?

As others have said, Dependency Injection(DI) removes the responsibility of direct creation, and management of the lifespan, of other object instances upon which our class of interest (consumer class) is dependent (in the UML sense). These instances are instead passed to our consumer class, typically as constructor parameters or via property setters (the management of the dependency object instancing and passing to the consumer class is usually performed by an Inversion of Control (IoC) container, but that's another topic).

DI, DIP and SOLID

Specifically, in the paradigm of Robert C Martin's SOLID principles of Object Oriented Design, DI is one of the possible implementations of the Dependency Inversion Principle (DIP). The DIP is the D of the SOLID mantra - other DIP implementations include the Service Locator, and Plugin patterns.

The objective of the DIP is to decouple tight, concrete dependencies between classes, and instead, to loosen the coupling by means of an abstraction, which can be achieved via an interface, abstract class or pure virtual class, depending on the language and approach used.

Without the DIP, our code (I've called this 'consuming class') is directly coupled to a concrete dependency and is also often burdened with the responsibility of knowing how to obtain, and manage, an instance of this dependency, i.e. conceptually:

"I need to create/use a Foo and invoke method `GetBar()`"  

Whereas after application of the DIP, the requirement is loosened, and the concern of obtaining and managing the lifespan of the Foo dependency has been removed:

"I need to invoke something which offers `GetBar()`"  

Why use DIP (and DI)?

Decoupling dependencies between classes in this way allows for easy substitution of these dependency classes with other implementations which also fulfil the prerequisites of the abstraction (e.g. the dependency can be switched with another implementation of the same interface). Moreover, as others have mentioned, possibly the most common reason to decouple classes via the DIP is to allow a consuming class to be tested in isolation, as these same dependencies can now be stubbed and/or mocked.

One consequence of DI is that the lifespan management of dependency object instances is no longer controlled by a consuming class, as the dependency object is now passed into the consuming class (via constructor or setter injection).

This can be viewed in different ways:

• If lifespan control of dependencies by the consuming class needs to be retained, control can be re-established by injecting an (abstract) factory for creating the dependency class instances, into the consumer class. The consumer will be able to obtain instances via a Create on the factory as needed, and dispose of these instances once complete.
• Or, lifespan control of dependency instances can be relinquished to an IoC container (more about this below).

When to use DI?

• Where there likely will be a need to substitute a dependency for an equivalent implementation,
• Any time where you will need to unit test the methods of a class in isolation of its dependencies,
• Where uncertainty of the lifespan of a dependency may warrant experimentation (e.g. Hey, MyDepClass is thread safe - what if we make it a singleton and inject the same instance into all consumers?)

Example

Here's a simple C# implementation. Given the below Consuming class:

public class MyLogger  {     public void LogRecord(string somethingToLog)     {        Console.WriteLine("{0:HH:mm:ss} - {1}", DateTime.Now, somethingToLog);     }  }  

Although seemingly innocuous, it has two static dependencies on two other classes, System.DateTime and System.Console, which not only limit the logging output options (logging to console will be worthless if no one is watching), but worse, it is difficult to automatically test given the dependency on a non-deterministic system clock.

We can however apply DIP to this class, by abstracting out the the concern of timestamping as a dependency, and coupling MyLogger only to a simple interface:

public interface IClock  {      DateTime Now { get; }  }  

We can also loosen the dependency on Console to an abstraction, such as a TextWriter. Dependency Injection is typically implemented as either constructor injection (passing an abstraction to a dependency as a parameter to the constructor of a consuming class) or Setter Injection (passing the dependency via a setXyz() setter or a .Net Property with {set;} defined). Constructor Injection is preferred, as this guarantees the class will be in a correct state after construction, and allows the internal dependency fields to be marked as readonly (C#) or final (Java). So using constructor injection on the above example, this leaves us with:

public class MyLogger : ILogger // Others will depend on our logger.  {      private readonly TextWriter _output;      private readonly IClock _clock;        // Dependencies are injected through the constructor      public MyLogger(TextWriter stream, IClock clock)      {          _output = stream;          _clock = clock;      }        public void LogRecord(string somethingToLog)      {          // We can now use our dependencies through the abstraction           // and without knowledge of the lifespans of the dependencies          _output.Write("{0:yyyy-MM-dd HH:mm:ss} - {1}", _clock.Now, somethingToLog);      }  }  

(A concrete Clock needs to be provided, which of course could revert to DateTime.Now, and the two dependencies need to be provided by an IoC container via constructor injection)

An automated Unit Test can be built, which definitively proves that our logger is working correctly, as we now have control over the dependencies - the time, and we can spy on the written output:

[Test]  public void LoggingMustRecordAllInformationAndStampTheTime()  {      // Arrange      var mockClock = new Mock();      mockClock.Setup(c => c.Now).Returns(new DateTime(2015, 4, 11, 12, 31, 45));      var fakeConsole = new StringWriter();        // Act      new MyLogger(fakeConsole, mockClock.Object)          .LogRecord("Foo");        // Assert      Assert.AreEqual("2015-04-11 12:31:45 - Foo", fakeConsole.ToString());  }  

Next Steps

Dependency injection is invariably associated with an Inversion of Control container(IoC), to inject (provide) the concrete dependency instances, and to manage lifespan instances. During the configuration / bootstrapping process, IoC containers allow the following to be defined:

• mapping between each abstraction and the configured concrete implementation (e.g. "any time a consumer requests an IBar, return a ConcreteBar instance")
• policies can be set up for the lifespan management of each dependency, e.g. to create a new object for each consumer instance, to share a singleton dependency instance across all consumers, to share the same dependency instance only across the same thread, etc.
• In .Net, IoC containers are aware of protocols such as IDisposable and will take on the responsibility of Disposing dependencies in line with the configured lifespan management.

Typically, once IoC containers have been configured / bootstrapped, they operate seamlessly in the background allowing the coder to focus on the code at hand rather than worrying about dependencies.

The key to DI-friendly code is to avoid static coupling of classes, and not to use new() for the creation of Dependencies

As per above example, decoupling of dependencies does require some design effort, and for the developer, there is a paradigm shift needed to break the habit of newing dependencies directly, and instead trusting the container to manage dependencies.

But the benefits are many, especially in the ability to thoroughly test your class of interest.

Note : The creation / mapping / projection (via new ..()) of POCO / POJO / Serialization DTOs / Entity Graphs / Anonymous JSON projections et al - i.e. "Data only" classes or records - used or returned from methods are not regarded as Dependencies (in the UML sense) and not subject to DI. Using new to project these is just fine.

Answer by Phil Goetz for What is dependency injection?

The popular answers are unhelpful, because they define dependency injection in a way that isn't useful. Let's agree that by "dependency" we mean some pre-existing other object that our object X needs. But we don't say we're doing "dependency injection" when we say

$foo = Foo->new($bar);  

We just call that passing parameters into the constructor. We've been doing that regularly ever since constructors were invented.

"Dependency injection" is considered a type of "inversion of control", which means that some logic is taken out of the caller. That isn't the case when the caller passes in parameters, so if that were DI, DI would not imply inversion of control.

DI means there is an intermediate level between the caller and the constructor which manages dependencies. A Makefile is a simple example of dependency injection. The "caller" is the person typing "make bar" on the command line, and the "constructor" is the compiler. The Makefile specifies that bar depends on foo, and it does a

gcc -c foo.cpp; gcc -c bar.cpp  

before doing a

gcc foo.o bar.o -o bar  

The person typing "make bar" doesn't need to know that bar depends on foo. The dependency was injected between "make bar" and gcc.

The main purpose of the intermediate level is not just to pass in the dependencies to the constructor, but to list all the dependencies in just one place, and to hide them from the coder (not to make the coder provide them).

Usually the intermediate level provides factories for the constructed objects, which must provide a role that each requested object type must satisfy. That's because by having an intermediate level that hides the details of construction, you've already incurred the abstraction penalty imposed by factories, so you might as well use factories.

Answer by Berguiga.M.Amine for What is dependency injection?

from Book Apress.Spring.Persistence.with.Hibernate.Oct.2010

The purpose of dependency injection is to decouple the work of resolving external software components from your application business logic.Without dependency injection, the details of how a component accesses required services can get muddled in with the component?s code. This not only increases the potential for errors, adds code bloat, and magnifies maintenance complexities; it couples components together more closely, making it difficult to modify dependencies when refactoring or testing.

Answer by hariprasad for What is dependency injection?

Dependency Injection is one from Design Patterns, which uses basic feature of OOP - relationship in one object with another object. While inheritance inherits one object to do more complex and specific another object, relationship or association simply creates pointer to another object from one object using attribute. The power of DI is in combination with another features of OOP as are interfaces and hiding code. Suppose, we have customer (subscriber) in library, which can borrow only one book for simplicity.

Interface of book:

package com.deepam.hidden;    public interface BookInterface {    public BookInterface setHeight(int height);  public BookInterface setPages(int pages);     public int getHeight();  public int getPages();      public String toString();  }  

Next we can have many kind of books; one of type is fiction:

package com.deepam.hidden;    public class FictionBook implements BookInterface {  int height = 0; // height in cm  int pages = 0; // number of pages    /** constructor */  public FictionBook() {      // TODO Auto-generated constructor stub  }    @Override  public FictionBook setHeight(int height) {    this.height = height;    return this;  }    @Override  public FictionBook setPages(int pages) {    this.pages = pages;    return this;        }    @Override  public int getHeight() {      // TODO Auto-generated method stub      return height;  }    @Override  public int getPages() {      // TODO Auto-generated method stub      return pages;  }    @Override  public String toString(){      return ("height: " + height + ", " + "pages: " + pages);  }  }  

Now subscriber can have association to the book:

package com.deepam.hidden;    import java.lang.reflect.Constructor;  import java.lang.reflect.InvocationTargetException;    public class Subscriber {  BookInterface book;    /** constructor*/  public Subscriber() {      // TODO Auto-generated constructor stub  }    // injection I  public void setBook(BookInterface book) {      this.book = book;  }    // injection II  public BookInterface setBook(String bookName) {      try {          Class cl = Class.forName(bookName);          Constructor constructor = cl.getConstructor(); // use it for parameters in constructor          BookInterface book = (BookInterface) constructor.newInstance();          //book = (BookInterface) Class.forName(bookName).newInstance();      } catch (InstantiationException e) {          e.printStackTrace();      } catch (IllegalAccessException e) {          e.printStackTrace();      } catch (ClassNotFoundException e) {          e.printStackTrace();      } catch (NoSuchMethodException e) {          e.printStackTrace();      } catch (SecurityException e) {          e.printStackTrace();      } catch (IllegalArgumentException e) {          e.printStackTrace();      } catch (InvocationTargetException e) {          e.printStackTrace();      }      return book;  }    public BookInterface getBook() {    return book;  }    public static void main(String[] args) {    }    }  

All the three classes can be hidden for it's own implementation. Now we can use this code for DI:

package com.deepam.implement;    import com.deepam.hidden.Subscriber;  import com.deepam.hidden.FictionBook;    public class CallHiddenImplBook {    public CallHiddenImplBook() {      // TODO Auto-generated constructor stub  }    public void doIt() {      Subscriber ab = new Subscriber();        // injection I      FictionBook bookI = new FictionBook();      bookI.setHeight(30); // cm      bookI.setPages(250);      ab.setBook(bookI); // inject      System.out.println("injection I " + ab.getBook().toString());        // injection II      FictionBook bookII = ((FictionBook) ab.setBook("com.deepam.hidden.FictionBook")).setHeight(5).setPages(108); // inject and set      System.out.println("injection II " + ab.getBook().toString());        }    public static void main(String[] args) {      CallHiddenImplBook kh = new CallHiddenImplBook();      kh.doIt();  }  }  

There are many different ways how to use dependency injection. It is possible to combine it with Singleton, etc., but still in basic it is only association realized by creating attribute of object type inside another object.

Answer by Harleen for What is dependency injection?

What is dependency Injection?

Dependency Injection(DI) means to decouple the objects which are dependent on each other. Say object A is dependent on Object B so the idea is to decouple these object from each other. We don?t need to hard code the object using new keyword rather sharing dependencies to objects at runtime in spite of compile time. If we talk about

How Dependency Injection works in Spring:

We don?t need to hard code the object using new keyword rather define the bean dependency in the configuration file. The spring container will be responsible for hooking up all.

Inversion of Control (IOC)

IOC is a general concept and it can be expressed in many different ways and Dependency Injection is one concrete example of IOC.

Two types of Dependency Injection:

1. Constructor Injection
2. Setter Injection

1. Constructor-based dependency injection:

Constructor-based DI is accomplished when the container invokes a class constructor with a number of arguments, each representing a dependency on other class.

public class Triangle {    private String type;    public String getType(){      return type;   }    public Triangle(String type){   //constructor injection      this.type=type;   }  }                  

2. Setter-based dependency injection:

Setter-based DI is accomplished by the container calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

public class Triangle{     private String type;     public String getType(){      return type;    }   public void setType(String type){          //setter injection      this.type = type;    }   }                   

NOTE: It is a good rule of thumb to use constructor arguments for mandatory dependencies and setters for optional dependencies. Note that the if we use annotation based than @Required annotation on a setter can be used to make setters as a required dependencies.