Common annotation analysis in the Javax Inject framework
Common annotation analysis in the Javax Inject framework
Javax Inject is a JSR-330 standard in Java, which defines a set of annotations to achieve dependent injection.Dependent injection is a design pattern that implements loose coupling. It is managed by entrusting the dependent relationship between objects to the container, thereby reducing the coupling between components.
In the Javax Inject framework, there are some common annotations to identify different dependent injection scenarios.The following are the analysis of these common annotations:
1. @Inject：
@Inject annotations can be used to mark a constructor, method, or field, indicating that it needs to be relying on injection.It tells the container that when a marked object needs to be created, it should be automatically parsed and injected into its dependence.
For example, the following code demonstrates how to use the @Inject annotation marking a constructor:
public class UserService {
private UserRepository userRepository;
@Inject
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
}
2. @Qualifier：
@Qualifier annotations are used to solve multiple ambiguity that can be injected.When there are multiple types of the same type, by using different @qualifier annotations, you can tell the container which dependencies should be injected.
For example, the following code demonstrates how to use @qualifier annotation definition of a customized limited character:
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface DataSource {
}
Then, you can combine @DataSource annotations to limit specific dependencies injection:
public class UserService {
private UserRepository userRepository;
@Inject
public UserService(@DataSource UserRepository userRepository) {
this.userRepository = userRepository;
}
}
3. @Named：
@NAMED Note is an implementation of @qualifier, which is suitable for relying injection for named names.By adding @Named annotations to dependence, and specifying a unique name, you can identify the specific instance that should be dependent.
For example, the following code demonstrates how to use @named annotations as a dependency injection specified name:
public class UserService {
@Inject
@Named("userRepository")
private UserRepository userRepository;
}
Then, the dependencies can be injected through the name:
@Singleton
@Named("userRepository")
public class UserRepository {
// ...
}
4. @Singleton：
@SINGLETON annotation is used to identify a singles object, that is, only one of this type of instance will be created, and it will be shared throughout the application range.
For example, the following code demonstrates how to use the @SINGLETON annotation marking a single case class:
@Singleton
public class UserService {
// ...
}
5. @Scope：
@Scope annotation is used to customize the scope of action. By injecting a specific scope for dependencies, the life cycle of the object can be controlled.
For example, the following code demonstrates how to use @Scope annotation definition of a customized scope:
@Retention(RetentionPolicy.RUNTIME)
@Scope
public @interface RequestScoped {
}
Then, the annotation mark is required where the scope needs to be used:
@RequestScoped
public class UserService {
// ...
}
Summarize:
There are many common annotations in the Javax Inject framework, which is used to achieve dependency injection.These annotations can help developers mark dependencies on constructors, methods, or fields to achieve loose coupling design patterns.Through annotations, multiple injecting dependencies can be solved, defining naming dependencies injection, identifying single -example objects, and customized scope.Using the Javax Inject framework, developers can more conveniently practice dependency injection and improve the maintenance and testability of code.
