Difference between creating new object and dependency injection

Question

What is the difference between creating a new object and dependency injection? Please explain in detail.

Answer 1

When using an inversion-of-control container to perform dependency injection, the container creates the objects, and not the developer. This is done so that the container can "inject" these objects into other objects.

I'd suggest you read some articles about dependency-injection and/or spring. Or read other topics on dependency injection here on SO.

Answer 2

Well, creating a new object is as explicit as it can get - you create a new instance of the desired class.

Dependency injections is a mechanism that provides you with references where you need them. Imagine a class that represents a connection pool to your database - you usually only have one instance of that class. Now you need to distribute that reference to all the classes that use it. Here is where Dependency Injection comes in handy - by using a DI framework such as Spring you can define that the one instance of your pool will be injected into the classes that need it.

Your question itself is not easy to answer since the creation of an object and dependency injection can't be compared that easily...

Answer 3

Of course both create objects. The difference is in who is responsible for the creation. Is it the class which needs its dependencies or a container like Spring for example, which wires the components dependencies. You configure the dependencies in a separate(typically XML) configuration file.

It is really a separation of concerns. The class says I need this, this and this component so I functionate properly. The class doesn't care how it gets its components. You plug in them into the class with a separate configuration file.

To give you an example lets consider having a shopping class which needs a payment module. You don't want to hardcode which payment module will be used. To achieve this you inverse the control. You can change the used payment module with a few keystrokes in the configuration file of the container. The power is that you aren't touching any Java code.

Answer 4

Well, they're not exactly comparable. You will always have to create a new object by instantiating a class at some point. And dependency injection also have to create new objects.

Dependency injection really comes into play when you want to control or verify the behaviour of instances used by a class that you use, or want to test. (For Test Driven Development dependency injection is key for any except the smallest example)

Assume a class Holder which requires an object of class Handle. The traditional way to do that would be to let the Holder instance create and own it:

class Holder {
    private Handle myHandle;
    public void handleIt() {
        handle.handleIt();
    }
}

The Holder instance creates myHandle and noone outside the class can get at it. In some cases, unittesting being on of them, this is a problem because it is not possible to test the Holder class without creating the Handle instance which in turn might depend on many other classes and instances. This makes testing unwieldy and cumbersome.

By injecting the Handle instance, for example in the constructor, someone from the outside becomes responsible for the creation of the instance.

class Holder {
    private Handle myHandle;

    public Holder(Handle injectedHandle) {
        myHandle = injectedHandle;
    }

    public void handleIt() {
        handle.handleIt();
    }
}

As you can see the code is almost the same, and the Handle is still private, but the Holder class now has a much loser coupling to its outside world which makes many things simpler. And when testing the Holder class a mock or stub object can be injected instead of a real instance making it possible to verify or control the interaction between the Holder, its caller and the handle.

Answer 5

Dependency injections adds a layer of configurability into your application. In the sense, when you hard code object construction, you need to re-build and re-deploy your app, but when you use dependency injection, you can re configure the XML and change the behavior without re-building and re-deploying. There are a large variety of use cases where this can save a lot of tie and effort.