Use GIN (GWT Injection) framework to implement the dependency injection of the Java class library
Use GIN (GWT Injection) framework to implement the dependency injection of the Java class library
Overview:
Dependency injection is a design pattern, which aims to reduce coupling between categories and improve the maintenance of code and testability.It is injecting the dependent object into the class instead of creating a dependent object within the class, thereby realizing the decoupling between objects.In Java, we can use the Gin (GWT Injection) framework to achieve dependent injection to simplify management of dependencies.
GIN is a lightweight dependency injection framework, which is designed for the development of GWT (Google Web Toolkit) applications.But it can also be used for ordinary Java libraries.GIN provides a statement to configure dependencies, and uses the Google Guice framework to achieve dependency injection.Below we will introduce how to use the GIN framework to implement the dependency injection of the Java library.
step:
1. Add dependencies:
First of all, we need to add GIN dependencies in the project construction file (such as Gradle or Maven) to use the Gin framework in the project.In Gradle, you can use the following code to add dependencies:
dependencies {
implementation 'com.google.gwt.inject:gin:2.1.2'
}
In Maven, you can use the following code fragment to add dependencies:
<dependency>
<groupId>com.google.gwt.inject</groupId>
<artifactId>gin</artifactId>
<version>2.1.2</version>
</dependency>
2. Create a class that needs to be injected:
Next, we need to create a class that needs to be injected.These classes can be an ordinary Java class, not necessarily the component of the GWT application.
public class FooService {
private BarService barService;
@Inject
public void setBarService(BarService barService) {
this.barService = barService;
}
public void doSomething() {
barService.doSomethingElse();
}
}
public class BarService {
public void doSomethingElse() {
// Some logic here
}
}
In the above examples, the Fooservice class relies on the Barservice class.We use the @Inject annotation marking SetBarservice method so that the Gin framework can automatically inject the Barservice object.
3. Create a module class:
Then, we need to create a module class to configure dependencies and binding dependencies.You can create a class inherited from the `Abstractginmodule` and rewrite the` Configure` method.
public class MyModule extends AbstractGinModule {
@Override
protected void configure() {
bind(BarService.class).in(Singleton.class);
}
}
In the above examples, we bind the Barservice class with the Bind method and use it as a single object.
4. Initialize Gin framework:
At the entry point of the application, we need to initialize the Gin framework and create an Injector object.You can use the `Ginfactory` class to complete these operations.
public class MyApp {
public static void main(String[] args) {
GinFactory ginFactory = new GinFactory();
MyModule module = new MyModule();
Injector injector = ginFactory.createInjector(module);
FooService fooService = injector.getInstance(FooService.class);
fooService.doSomething();
}
}
In the above examples, we created a Ginfactory object and passed into the module -class MyModule that we defined.Then, we use the Getinstance method of the Injector object to obtain an instance of the Fooservice class and call the method.
Summarize:
By using the Gin framework, we can easily implement the dependency injection of the Java library.First, we need to add GIN to the project.Create the class that we need to inject the dependent object.Next, we create a module class to configure dependencies and binding dependencies.Finally, we initialize the GIN framework at the inlet point of the application and use the Injector object to obtain the instance of the class we need.
The above is an introduction to the dependency injection of the Java library using the Gin framework.By dependent injection, we can better manage the dependence between classes and improve the maintenance and flexibility of code.
