Spring dependency injection methods and their respective application scenarios

One of the core functions of the Spring framework is Dependency Injection (DI for short), which can help us achieve loosely coupled and highly cohesive designs. This article will describe the way of dependency injection in Spring and how to choose the appropriate injection method from the following aspects.

1. Three ways of Spring dependency injection

1.1 Constructor injection

To pass dependencies through a constructor, you need to create a constructor with a dependency parameter. One advantage of this approach is that it ensures that the required dependencies are available when the object is instantiated. Spring will call the constructor when the bean is created, and pass the dependencies through the constructor parameters.

public class FooService {
    
    
    private final BarService barService;

    public FooService(BarService barService) {
    
    
        this.barService = barService;
    }
}

1.2 Setter injection

Dependencies are injected via setter methods. This approach requires defining a setter method in the class, and then passing the instance of the dependency to the setter method. Spring will call this setter method after the bean is created.

public class FooService {
    
    
    private BarService barService;

    public void setBarService(BarService barService) {
    
    
        this.barService = barService;
    }
}

1.3 Field injection

Inject dependencies directly on fields. This method does not need to create additional constructors or setter methods, just add the @Autowired annotation to the field, and Spring will automatically inject dependencies.

public class FooService {
    
    
    @Autowired
    private BarService barService;
}

2. How to choose a suitable injection method

2.1 Constructor injection

Consider using constructor injection when your class has the necessary dependencies. This approach ensures that dependencies are injected when the object is created and that dependencies are not modified. Constructor injection is a great option for immutable dependencies. In addition, this method is also more conducive to unit testing, which can be easily tested by passing mock objects.

2.2 Setter injection

Consider using setter injection when your class has optional dependencies or dependencies that may change. This approach allows objects to change dependencies at runtime, providing some flexibility. However, this approach may lead to unstable object state, because dependencies can be modified at any time.

2.3 Field injection

Field injection provides a concise injection method without creating additional constructors or setter methods. However, this approach can make testing difficult since fields are usually private. While it is possible to use reflection to modify private fields, this results in less readable test code. Also, field injection can lead to circular dependencies in some cases.

3. Recommendations and best practices

According to the project requirements and the characteristics of the class, you can choose the appropriate dependency injection method. In actual development, we recommend prioritizing constructor injection because it ensures objects are created with the required dependencies, helps achieve immutability, and simplifies unit testing. However, in some cases it is also reasonable to use setter injection and field injection.

Here are some suggestions and best practices:

1. Prefer constructor injection for necessary and immutable dependencies. This helps achieve immutability, improving the stability and security of your code.
2. For dependencies that are optional or may change, setter injection can be used. This provides some flexibility, allowing dependencies to be changed at runtime.
3. Avoid overuse of field injection. While it provides clean code, it can lead to testing difficulties and circular dependencies.
4. In unit testing, it is preferable to inject mock objects using constructor or setter methods. This helps simplify test code, and improves readability and maintainability.

Choosing a suitable dependency injection method can help us achieve a loosely coupled, highly cohesive design while improving code readability and maintainability. In actual development, we need to weigh various factors and choose an appropriate injection method according to project requirements and class characteristics.