The relationship between Javax Inject framework and IOC container
The Javax Inject framework is a technology in Java to support the implementation of dependencies.Dependent injection is a design mode, which can make the dependencies between components more loose, easy to manage and test.
In Java, dependency injection is usually implemented through IOC (Inversion of Control) container.The IOC container is responsible for the dependency relationship between management components, and through the mechanism of reflection and other mechanisms, it comes from the establishment and injection dependencies.The Javax Inject framework provides a set of annotations to identify dependency relationships so that IOC containers can correctly create and inject objects.
Here are some commonly used Javax Inject Note:
1. @inject: Used to mark the constructor, method or field that needs to be injected.
2. @Named: The name of the object that needs to be injected is specified.When one interface has multiple implementation, you can use @named annotation to specify which implementation classes need to be injected.
3. @SINGLETON: Used to specify a class instance as a single example mode, that is, only one instance is created in the entire application, and it is shared with other components that need to inject this class.
4. @qualifier: Used to create custom annotations to identify different dependent examples.
Below is a simple example, demonstrate how to use the Javax Inject framework and IOC container:
public interface MessageService {
String getMessage();
}
@Named("english")
public class EnglishMessageService implements MessageService {
public String getMessage() {
return "Hello!";
}
}
@Named("chinese")
public class ChineseMessageService implements MessageService {
public String getMessage() {
Return "Hello!";;
}
}
public class Application {
@Inject
@Named("english")
private MessageService messageService;
public void run() {
String message = messageService.getMessage();
System.out.println(message);
}
public static void main(String[] args) {
Application app = new Application();
app.run();
}
}
In the above example, we define a MESSAGESERVICE interface and create two implementation classes: EnglishmessageService and ChineseMessageService.In the Application class, we inject the implementation class of MESSAGESERVICE through @Inject and @named annotations.
When we run the Application Run () method, the IOC container will automatically create an instance of MessageService and inject it into the MessageService field.According to the specification of @named annotations, we injected an instance of EnglishmessageService.Finally, call the MESSAGESERVICE.GetMessage () method, we will get the output of "Hello!".
Summary: The Javax Inject framework is closely related to the IOC container.Javax Inject provides a set of annotations to identify dependency relationships and achieve dependency injection through IOC containers.Using the Javax Inject framework and IOC container, we can more flexibly manage the dependencies between objects in Java applications.
