How to introduce Dagger2
-
Configure the apt plugin (add the following code in build.gradle(Project:xxx))
dependencies { classpath 'com.android.tools.build:gradle:2.1.0' //添加apt插件 classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' }
-
Add dependency (add the following code in build.gradle(Module:app))
apply plugin: 'com.android.application' //添加如下代码,应用apt插件` apply plugin: 'com.neenbedankt.android-apt' ... dependencies { ... compile 'com.google.dagger:dagger:2.4' apt 'com.google.dagger:dagger-compiler:2.4' //java注解 compile 'org.glassfish:javax.annotation:10.0-b28' ... }
-
Don't forget to add lint warning
android { ... lintOptions { warning 'InvalidPackage' } }
.
Use of Dagger2
Classes that need to be injected with dependencies
public class MainPresenter {
//MainContract是个接口,View是他的内部接口,这里看做View接口即可
private MainContract.View mView;
@Inject
MainPresenter(MainContract.View view) {
mView = view;
}
public void loadData() {
//调用model层方法,加载数据
...
//回调方法成功时
mView.updateUI();
}
Function:
@Inject The attribute or construction method with this annotation will participate in dependency injection, and Dagger2 will instantiate the class with this annotation
.
Module class
@Module
public class MainModule {
private final MainContract.View mView;
public MainModule(MainContract.View view) {
mView = view;
}
@Provides
MainView provideMainView() {
return mView;
}
}
Function:
@Module class with this annotation is used to provide dependencies. It defines some methods annotated with @Provides beginning with provide. These methods are the provided dependencies. Dagger2 will look for and instantiate a certain class in this class The dependencies needed.
.
Component interface
@Component(modules = MainModule.class)
public interface MainComponent {
void inject(MainActivity activity);
}
Function:
@Component is used to connect @Inject and @Module, obtain dependencies from @Module and inject them to @Inject
Use in Activity
public class MainActivity extends AppCompatActivity implements MainContract.View {
@Inject
MainPresenter mainPresenter;
...
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerMainComponent.builder()
.mainModule(new MainModule(this))//绑定Module,并传递Activity的view对象
.build()
.inject(this);
//调用Presenter方法加载数据
mainPresenter.loadData();
...
}
}
Let’s first look at the code in MainActivity. Before we declared MainPresenter directly, we now add an annotation @Inject to the declaration, indicating that MainPresenter needs to be injected into MainActivity, that is, MainActivity depends on MainPresenter. Here, we should pay attention to the use of @ When Inject, you cannot use the private modifier to modify the member attributes of the class.
Then we also added the @Inject annotation to the constructor of MainPresenter. In this way, the mainPresenter in MainActivity establishes a certain connection with his constructor. We can understand this connection in this way. When a certain class is marked by @Inject, it will go to its construction method. If the construction method is also marked by @Inject, this class will be automatically initialized to complete the dependency. injection.
Then, they will not establish a connection out of thin air, so we thought that a bridge must be needed to connect them, which is the Component to be introduced below.
Component is an interface or abstract class, annotated with @Component annotation (here, regardless of the modules in brackets), we define an inject() method in this interface, and the parameter is Mainactivity. Then rebuild the project, a Component class prefixed with Dagger will be generated, here is DaggerMainComponent, and then complete the following code in MainActivity.
DaggerMainComponent.builder()
.mainModule(new MainModule(this))
.build()
.inject(this);
.
Reference materials: