Detailed explanation of the three implementation methods of Spring IOC

In the Spring framework, IOC (control inversion) is implemented through dependency injection (DI), and there are three main implementation methods: constructor injection, Setter injection and field injection. Each method has its own characteristics, applicable scenarios, and advantages and disadvantages. Here is a detailed comparison of them:

1. Constructor Injection

Implementation method

Dependencies are injected through the constructor parameters of the class.

Sample code

public class UserService {
    private final UserRepository userRepository;
    @Autowired
    public UserService(UserRepository userRepository) {
         = userRepository;
    }
}

advantage

• Immutability: Dependency throughfinalKeyword declarations ensure that dependencies are immutable and avoid null pointer exceptions.
• Strong dependency guarantee: suitable for scenarios that must be depended on, ensuring that all dependencies have been injected when the object is created.
• Easy to test: Inject dependencies through the constructor, making it easier to pass in Mock objects during unit testing.
• Thread safety: Reliance is initialized when object creation is created, suitable for multi-threaded environments.

shortcoming

• The code is verbose when there are too many parameters: If there are too many dependencies, the constructor parameter list will become very long, affecting the readability of the code.
• Low flexibility: Not suitable for scenarios where optional dependencies are available.

Applicable scenarios

• Strong dependency (must dependency).
• It is necessary to ensure that dependence is immutable.
• Multi-threaded environment.

2. Setter Injection

Implementation method

Inject dependencies through Setter method.

Sample code

public class UserService {
    private UserRepository userRepository;
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
         = userRepository;
    }
}

advantage

• High flexibility: Suitable for scenes with optional dependencies, and can dynamically inject dependencies after object creation.
• Good readability: the setter method is clearly named to facilitate understanding of dependencies.
• Easy to scale: Just add Setter methods when adding new dependencies, no need to modify the constructor.

shortcoming

• Dependency variability: Dependencies may be modified multiple times, resulting in inconsistent states.
• Null pointer risk: Dependencies may not be injected, and you need to check whether they arenull。
• Thread safety issues: Dependencies may be modified in multi-threaded environments.

Applicable scenarios

• Optional dependency.
• Scenarios that require dynamic injection of dependencies.
• Scenarios where dependencies may change.

3. Field Injection

Implementation method

Inject fields directly by reflection.

Sample code

public class UserService {
    @Autowired
    private UserRepository userRepository;
}

advantage

• Concise code: no need to write constructors or Setter methods, and the amount of code is small.
• High development efficiency: suitable for rapid development scenarios.

shortcoming

• Poor testability: Relying on reflection injection, the Mock object cannot be directly passed in during unit testing.
• Poor maintainability: Dependencies are hidden in fields and are not intuitive enough.
• Violating the encapsulation principle: directly operate the fields, destroying the encapsulation of the class.
• Thread safety issue: Dependencies may be modified by multiple threads.

Applicable scenarios

• Rapid development scenarios.
• Small project or prototype development.
• It is not recommended to use extensively in production code.

4. Comparative summary

5. Official recommendation

• Spring officially recommends using constructor injection because it can ensure dependency immutability and thread safety, while also facilitate unit testing.
• Setter injection is suitable for scenarios where optional dependencies or dynamic injection is required.
• Although field injection is convenient, it has many disadvantages and is not recommended to use it in large quantities in production code.

6. Example comparison

Constructor injection

public class OrderService {
    private final PaymentService paymentService;
    private final ShippingService shippingService;
    @Autowired
    public OrderService(PaymentService paymentService, ShippingService shippingService) {
         = paymentService;
         = shippingService;
    }
}

Setter Injection

public class OrderService {
    private PaymentService paymentService;
    private ShippingService shippingService;
    @Autowired
    public void setPaymentService(PaymentService paymentService) {
         = paymentService;
    }
    @Autowired
    public void setShippingService(ShippingService shippingService) {
         = shippingService;
    }
}

Field Injection

public class OrderService {
    @Autowired
    private PaymentService paymentService;
    @Autowired
    private ShippingService shippingService;
}

7. Summary

• Constructor injection: suitable for scenarios with strong dependency, immutability and high thread safety requirements.
• Setter injection: Suitable for scenarios where optional dependencies or dynamic injection is required.
• Field injection: The code is concise, but the testability and maintainability are poor, and it is not recommended to use it in large quantities.

In development, selecting the appropriate injection method according to specific scenarios can improve the quality and maintainability of the code.

If you guys encounter any problems in development, you can post them in the comment section

The above is a detailed explanation of the three implementation methods of Spring IOC. For more information about Spring IOC implementation methods, please pay attention to my other related articles!