When dependency resolution is made by an external agent rather than the class itself, then it is known as dependency injection. There are two standard ways of dependency injection that are being supported in the Spring framework, through a constructor argument or via using the setter method. The former type of dependency injection is known as the constructor injection, and the latter one is known as the setter injection. Both the methods are used for different purposes and have their own pros and cons.
Constructor Injection vs Setter Injection
The difference between Constructor injection and Setter injection is that constructor injection uses constructor, and on the other hand, setter injection uses setter methods to inject dependency. These two types of injection ways differ from one another on the basis of several parameters like security, readability, supporting immutability, and so on.
Constructor injection is a type of dependency injection in the spring framework that uses a constructor to inject dependency. The dependencies that are required for any of the classes are specified as the parameters of that specific class’s constructor. Constructor injection does not allow the developer to construct any object unless all the dependencies are ready, and thus, it ensures successful dependency injection.
Setter injection is a type of dependency injection in the spring framework that uses setter methods to inject dependency. It has setter methods of the form setXXX() where XXX denotes a dependency that injects the dependent objects into the client. This way of resolving dependency is very common in the Spring framework.
Comparison Table Between Constructor Injection and Setter Injection
|Parameters of Comparison||Constructor Injection||Setter Injection|
|Dependency injected||It uses a constructor.||It uses setter methods.|
|Readability||It is not much readable in comparison to the setter.||It is more readable.|
|Override property||Cannot override dependency.||Can override certain dependencies.|
|Changes||It always creates a new bean instance.||It does not create any new bean instance.|
|Immutability||It supports immutability.||It does not support.|
What is Constructor Injection?
Constructor injection is one of the standard ways of resolving dependency within the Spring framework, which statically defines the list of dependencies required for classes by assigning those as the parameters to the class’s constructor. All the classes that require dependency are must have a public constructor inside them, which takes an instance as the constructor argument, and that constructor should necessarily be the only public constructor inside that class.
If there is a need for more than one dependency, then the additional arguments should be added to the same constructor. To ensure that the dependency is injected completely, a single responsibility principle should be followed, which states that members should do only one thing. The constructor should be kept free from any other logic to make the constructor of the classes faster and more reliable.
One important fact of constructor injection is that the objects won’t be constructed unless all the dependencies are ready. As it creates new instances every time the constructor is being called thus, overriding is not possible in it. Constructor injection is basically used in cases when there is a necessity of creating objects with all of the dependencies. This is the most generally applicable and easiest way to implement dependencies correctly.
What is Setter Injection?
Setter injection is one of the standard ways of resolving dependency within the Spring framework, which uses the setter methods to resolve the dependencies. The setter methods are of the form setXXX(), where XXX specifies the dependency that needs to be injected. In this type of injection method, first, the object is created, and later on, the dependency is injected. For configuring Spring, XML files are used, and thus, readability is a big concern.
As setter methods have a specified form of method names, it enhances the readability in many ways. When there is a need to inject a larger number of dependencies, then the setter injection type is very favored and preferred over other types of injection methods. In addition to that, by using setter injection, the developers can easily override and change the values because it does not create a new bean instance every time. The only drawback of setter injection is that it does not ensures complete dependency injection.
There is no guarantee as to whether a certain object has dependency injected or not. In other words, it means that there might be an object with incomplete dependency. Setter injection is the most flexible and the most common way of implementing dependency injection.
Main Differences Between Constructor Injection and Setter Injection
- When constructor injection is used to inject the dependency, it is done by using constructor on any Spring-managed bean, whereas the Setter injection uses setter methods like set dependency() for the purpose of injecting dependency on any of the bean-managed by the Spring’s IOC container.
- Setter injection is more readable in comparison to the constructor injection as the setter method always has names starting with the word set like setXXX() and thus, it is easy to read in the Spring XML config file and interpret the dependency that is being set whereas the Constructor injection uses an index for the purpose of injecting dependency.
- Certain dependencies can be overridden using the setter injection, whereas this is not possible by using the constructor injection as every time a new object is created when the constructor is called.
- By using the setter injection, the value can easily be changed as it does not create any new bean instances, whereas that is not the case while using the constructor injection because it always creates a new bean instance.
- Constructor injection supports immutability, whereas, on the other hand, setter injection does not support immutability.
The bottom line is that both ways of injecting dependencies let either it be constructor injection or setter injection, have their own pros and cons. In addition to that, Spring does not abstain the developers from using anyone but rater. They are free to use both constructor injection and setter injection in one Spring configuration file. The important thing to contain in mind while injecting dependency is to use the constructor injection when there is a compulsory need of creating objects with all of the dependencies and to use setter injection when the number of dependencies is more or if there is a need for better readability.