Constructor Vs Setter Injection

Constructor vs Setter Injection are two common methods used in Dependency Injection (DI) to provide dependencies to a class. Each method has its own advantages and use cases.

1. Constructor Injection

Definition:

• Dependencies are provided through the class constructor.
• Ensures that the class is instantiated with all its required dependencies.

Advantages

1. Immutability: The class can be made immutable, as all dependencies are injected at creation time.
2. Required Dependencies: Guarantees that required dependencies are provided, reducing the risk of NullPointerExceptions.
3. Easier Testing: Facilitates testing by ensuring dependencies are set when the object is created.

Disadvantages:

Complexity: If a class has many dependencies, the constructor can become cumbersome.

2. Setter Injection

Definition:

1. Dependencies are provided through setter methods after the object is created.
2. Allows optional dependencies to be set at runtime.

Advantages:

• Flexibility: Dependencies can be set or changed after object creation, providing more flexibility.
• Optional Dependencies: Useful for dependencies that are not required for the class to function properly.

Disadvantages:

• Mutability: Allows dependencies to be changed, which can lead to inconsistency or unintended modifications.
• Risk of Unset Dependencies: Dependencies may be unset or null if not properly initialized.

Define a Service Class:
```java
package com.example.demo.service;

import org.springframework.stereotype.Service;

@Service
public class MyService {
    public String getServiceName() {
        return "MyService";
    }
}
```

Define a Client Class with Constructor Injection:
```java
package com.example.demo.component;

import com.example.demo.service.MyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    private final MyService myService;

    @Autowired
    public MyComponent(MyService myService) {
        this.myService = myService;
    }

    public void printServiceName() {
        System.out.println(myService.getServiceName());
    }
}
```

Explanation:

• @Autowired: Injects MyService into the constructor of MyComponent.
• Constructor Injection: Ensures MyService is provided when MyComponent is created.

Define a Client Class with Setter Injection:
```java
package com.example.demo.component;

import com.example.demo.service.MyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    private MyService myService;

    @Autowired
    public void setMyService(MyService myService) {
        this.myService = myService;
    }

    public void printServiceName() {
        System.out.println(myService.getServiceName());
    }
}
```

Explanation:

• @Autowired: Injects MyService into the setter method of MyComponent.
• Setter Injection: Allows MyService to be set after MyComponent is created, providing flexibility.

Conclusion of Constructor Vs Setter Injection

• Constructor Injection:
  • Purpose: Provides dependencies through the constructor at object creation.
  • Advantages: Ensures immutability and required dependencies.
  • Disadvantages: Can become complex with many dependencies.

• Setter Injection:
  • Purpose: Provides dependencies through setter methods after object creation.
  • Advantages: Offers flexibility and handles optional dependencies.
  • Disadvantages: May lead to mutable objects and unset dependencies.

Homepage

Readmore