foreword
Dependency injection is a common implementation when developing Java projects. The Spring Boot framework implements the dependency injection function through the @Autowired annotation, which is also a skill point that Spring Boot development engineers must master. This article will introduce the principle of @Autowired annotation implementation in Spring Boot.
1. What is @Autowired annotation
@Autowired is a dependency injection method provided by the Spring framework, which can automatically assemble beans and inject member variables, method parameters or objects required in constructors into corresponding positions. It is implemented based on Java's reflection mechanism, which can easily manage the dependencies between objects.
2. @Autowired injection method
In Spring Boot, the @Autowired annotation can be used to inject beans into member variables, constructors, and methods of classes. The following is the specific usage method:
2.1 Using @Autowired annotations in member variables
Putting the @Autowired annotation on the member variable of the class allows Spring to automatically inject the Bean of the specified type into the member variable. For example:
@Component
public class UserService {
@Autowired
private UserDao userDao;
// ...
}
In the above example, the userDao member variable in the UserService class will be automatically injected into the Bean of the UserDao type.
2.2 Using the @Autowired annotation in the constructor
Putting the @Autowired annotation on the constructor of the class allows Spring to automatically inject the required Bean into the constructor parameters. For example:
@Component
public class UserService {
private final UserDao userDao;
@Autowired
public UserService(UserDao userDao) {
this.userDao = userDao;
}
// ...
}
In the above example, when Spring initializes UserService, it will automatically inject the Bean of UserDao type into the constructor of UserService.
2.3 Using @Autowired annotations in methods
Putting the @Autowired annotation on the method parameter allows Spring to automatically inject the specified type of Bean into the method parameter. For example:
@Component
public class UserService {
private UserDao userDao;
@Autowired
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
// ...
}
In the above example, the parameter userDao of the setUserDao method will be automatically set to bean of type UserDao.
3. @Autowired annotation implementation principle
The implementation principle of the @Autowired annotation is based on the Java reflection mechanism. When the Spring container is initialized, all bean definitions are scanned and injected into the container. Then, when a dependent bean needs to be injected, Spring will find the corresponding bean through the reflection mechanism and inject it into the specified location.
By default, Spring will use the byType method to find the beans that need to be injected, that is, automatically match the beans according to the type. An exception is thrown if there are multiple beans of the same type. You can also use the @Qualifier annotation to specify specific beans. For example:
@Component
public class UserService {
@Autowired
@Qualifier("userDaoImpl")
private UserDao userDao;
// ...
}
In the above example, the specific Bean name is specified as "userDaoImpl" through the @Qualifier annotation.
4. Summary
The @Autowired annotation in Spring Boot implements dependency injection based on Java's reflection mechanism. It can easily manage the dependencies between objects and improve the readability and maintainability of the code. Mastering the usage and principle of @Autowired annotation will help developers optimize the code structure and performance of Spring Boot projects.