Dagger2 在 Android 项目的正确使用方式【完整篇】
Dagger2的入門難度極大，我們直奔主題，先使用起來 再去思考原理。網(wǎng)上幾乎都是Java的用法，謹(jǐn)慎參考。
當(dāng)你看到?jīng)]有使用dagger.android這個庫的講解，都是Java用的，Android如果那樣用人都會累死的。。
Java用法是Android的基礎(chǔ)，是最原始的用法，Android所有的庫都是對Java用法做了優(yōu)化，我們先從最基礎(chǔ)的來講。
很多人開發(fā)Android都不看Google的文檔，總用Java那套，還真把Android手機(jī)當(dāng)服務(wù)器用了，你的App不卡誰的卡？？
官網(wǎng)說明，其實Java這種用法在Android端大有問題！查閱官網(wǎng)的Android用法。?如果熟悉dagger2基礎(chǔ)，可以直接跳到后面。
贈送源碼：https://github.com/Pangu-Immortal: 🔥免root實現(xiàn) Android改機(jī)（一鍵新機(jī)）技術(shù)解密，微信無限多開等。。
《最完整的Android逆向知識體系》
集成 Dagger2 依賴
Android studio 3.2.1 如下Gradle方式引用，Java工程僅需引用如下兩個庫，Android也可以這么用。
// dagger 2.x implementation 'com.google.dagger:dagger:2.17' annotationProcessor 'com.google.dagger:dagger-compiler:2.17'(推薦) 建議使用谷歌為Android提供的 dagger.android 依賴庫，需要引用完整，如下。可查閱Dagger2 在GitHub官網(wǎng)集成方法
// dagger 2.x // implementation 'com.google.dagger:dagger:2.17'// android部分接口也會需要這個庫annotationProcessor 'com.google.dagger:dagger-compiler:2.17'// dagger2針對Android的庫，如果你使用Android的開發(fā)方式，僅依賴這三個庫。implementation 'com.google.dagger:dagger-android:2.17'implementation 'com.google.dagger:dagger-android-support:2.17'annotationProcessor 'com.google.dagger:dagger-android-processor:2.17'// 本文前部分demo中使用了dagger 2.x的基本用法，需要引入dagger 2.x的兩個Java庫 // 后半部分dagger只使用Android方式開發(fā)，實際的Android開發(fā)中你只需要引用Android庫即可。如果你使用的是2.2以下的低版本gradle，可以使用apt的方式引用。（Dagger2 現(xiàn)在都不用 apt 方式了）
最新的AndroidStudio在使用apt插件的時候已經(jīng)會報warn了，但是還能用，如果你看到集成方式還是apt的，就沒必要看下去了。
apt插件使用Dagger2方法如下（不建議用，已過時）：
Project的 build.gradle中添加如下代碼
dependencies {classpath 'com.android.tools.build:gradle:3.2.1'//添加apt插件classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'}App的 build.gradle中添加如下代碼
apply plugin: 'com.android.application' apply plugin: 'com.neenbedankt.android-apt'... // 網(wǎng)上這么寫的都是Java用法，Android不要使用這種apt方式，會發(fā)警告 dependencies {implementation 'com.google.dagger:dagger:2.17'apt 'com.google.dagger:dagger-compiler:2.17'implementation 'org.glassfish:javax.annotation:10.0-b28' }開始使用 Dagger2
從最簡單方式? @Inject 注解開始，看代碼來體會 創(chuàng)建對象的過程。（基礎(chǔ) 僅此而已）
/*** (核心功能)：json解析的Javabean類(注意必須public修飾)** @author qihao* @date on 2018/12/18 17:07*/ public class User {private String name;// 這個 @Inject 表示可以提供User類型的對象實例@Injectpublic User() {this.name = "我的名字…User…";}public String getName() {return name;} } public class LoginActivity extends AppCompatActivity {@InjectUser user; // 必須 public class User@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_login);ButterKnife.bind(this);/**** 添加依賴關(guān)系*///第一種方式DaggerLoginComponent.create().inject(this);//第二種方式DaggerLoginComponent.builder().build().inject(this);}@OnClick(R.id.login_button)public void onViewClicked() {Logger.i(user.getName());} } @Component() public interface LoginComponent {/*** 必須讓Component知道需要往哪個類中注入* 這個方法名可以是其它的，但是推薦用inject* 目標(biāo)類LoginActivity必須精確，不能用它的父類*/void inject(LoginActivity activity); }需要Make Project之后才會在build目錄下生成 DaggerLoginComponent 類，Dagger開頭的一個編譯類。
LoginActivity 中使用?User 中的方法，需要一個注入--Component類，通過 @Component()把雙方關(guān)聯(lián)。
LoginActivity 中需要初始化 DaggerTestComponent.builder().build().inject(this);
要理解記憶，要理解記憶，要理解記憶……這三個類之間的調(diào)用必須先理解了，@Inject注解和@Component()兩處，僅此而已。
現(xiàn)在就用上?Dagger2 了（ 配合MVP的結(jié)構(gòu)使用，接下來講，先理解了這個調(diào)用過程。）建議新手停留片刻思考一會再往下看。
接下來我們要考慮該如何調(diào)用第三方庫中的方法呢？？總不能改源碼去加@Inject吧，稍作修改，如下。
使用@Module?@Provides 標(biāo)簽，稍稍改一處。
（目前不要去想MVP結(jié)構(gòu)，只是演示我們在Activity中調(diào)用一個類，不使用?new 的過程，思路簡單些，僅此而已。）
@Component(modules = ActivityModule.class) public interface LoginComponent {void inject(LoginActivity activity); } @Module public class ActivityModule {// 使用Provider 注解 提供實例化對象@ProvidesUser providerUser() {return new User();} }我們只添加了一個Module。此處User() 只是一個普通類，并沒有使用@Inject。
public class User {private String name;public User() {this.name = "我的名字…User…";}public String getName() {return name;} }最初我們 LoginActivity --> 通過 Component類 --> 得到并使用User對象
現(xiàn)在我們 LoginActivity --> 通過 Component類 --> 查找Module中的Provides提供的類?--> 得到并使用User對象
（好多人入門時的困惑是Dagger2比普通寫法代碼量還要大，這是真的，因為他的目的是方便解耦。丟掉疑慮看下去）
Module其實是一個簡單工廠模式，Module里面的函數(shù)基本都是創(chuàng)建類實例的方法。
什么時候使用@Provide，比如你使用的第三方庫，或者你引用的類，它的構(gòu)造方法沒有@Inject時。
Component首先搜索User類中用Inject注解標(biāo)注的屬性，沒找到，Component就會去Module中查找Provides注解標(biāo)注的位置，這樣就可以解決第三方類庫用dagger2實現(xiàn)依賴注入了。。
接下來按照真實項目的使用場景，開始一步一步的優(yōu)化，優(yōu)化到最后我們會把Dagger2中的注解標(biāo)簽都用上。最后封裝成完美的MVP開發(fā)框架，源碼會提供GitHub地址，請耐心看完全篇。接下來我們繼續(xù)優(yōu)化……
簡單總結(jié)：
- @Inject? 主要是用來標(biāo)注目標(biāo)類的依賴和依賴的構(gòu)造函數(shù)。
- @Module? ?Module和Provides是為解決第三方類庫而生的。
- @Component??它是一個橋梁，一端是目標(biāo)類，另一端是目標(biāo)類所依賴類的實例。
接下來我們再稍微改一點，用@Named玩一玩。。
public interface BasePresenter {void postHttplogin(); } public class HomePresenter implements BasePresenter {@Overridepublic void postHttplogin(){Logger.i("Activity調(diào)用了home P層代碼");} } public class LoginPresenter implements BasePresenter {@Overridepublic void postHttplogin(){Logger.i("Activity調(diào)用了login P層代碼");} }隨便寫了幾個類，我們可以通過@Named改一個參數(shù)就可以調(diào)用不同的類，原理如此，怎么玩都行。
@Module public class ActivityModule {// 使用Provider 注解 實例化對象@ProvidesUser providerUser() {return new User();}@Provides@Named("login")BasePresenter getLoginP(){return new LoginPresenter();}@Provides@Named("home")BasePresenter getHomeP(){return new HomePresenter();} } @Component(modules = ActivityModule.class) public interface LoginComponent {void inject(LoginActivity activity); } public class User {private String name;public User() {this.name = "我的名字…User…";}public String getName() {return name;} } public class LoginActivity extends AppCompatActivity {@InjectUser user;@Inject@Named("home")BasePresenter hoemPresenter;@Inject@Named("login")BasePresenter loginPresenter;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_login);ButterKnife.bind(this);DaggerLoginComponent.create().inject(this);}@OnClick(R.id.login_button)public void onViewClicked() {hoemPresenter.postHttplogin();Logger.i(user.getName());loginPresenter.postHttplogin();} }這次貼的代碼有點多，把完整的所有代碼都貼上了，以免有些地方疑惑。。
相信看一遍代碼心里都清楚這個@Named("login")是什么意思了，用法就是利用Module提供不同的對象。
在這其實我想舉很多例子，其實就是利用Module提供對象的過程。。使用場景和思路千變?nèi)f化。
classA中存在對classB的依賴該怎么使用呢？？如下場景。
public class User {private String name = "我的名字…User…";@InjectWorkInfo workInfo;public String getName() {DaggerLoginComponent.create().inject(this);return name + " <==> " + workInfo.getInfo();}}我們再user中使用 @Inject?WorkInfo workInfo;? 需要注入，否則是個空對象。
注意這一行：DaggerLoginComponent.create().inject(this);
@Component(modules = ActivityModule.class) public interface LoginComponent {void inject(LoginActivity activity);void inject(User user); } public class WorkInfo {private String job = "財務(wù)";private int jobYear = 5;private String jobSite = "北京";public String getInfo(){return "工作："+job+", 工齡："+jobYear+", 工作地點："+jobSite;} }LoginActivity依然是打印user.getName()，代碼和之前一樣……
我們只是加了一個Component，通過這個例子可以進(jìn)一步理解Component的作用，哪里用就要哪里注入。
一個工程幾千幾萬的類，要是全這么用肯定不爽……于是谷歌又發(fā)布了dagger.android 依賴庫。。
現(xiàn)在回到頂部依賴處，看看自己是否集成dagger.android 依賴庫，純用Dagger2多累啊。
單利是我們最常用的設(shè)計模式，dagger2構(gòu)建的對象怎么保證單利呢？？
@Singleton注解 輕輕松松解決單例。我們稍微改一下user的引用。加個注解即可。
@Module public class ActivityModule {@Singleton@ProvidesUser providerUser() {return new User();} }注意: 第一個坑！！！ 如果 module所依賴的Component 中有被單利的對象，那么Conponnent也必須是單利的
@Singleton @Component(modules = ActivityModule.class) public interface LoginComponent {void inject(LoginActivity activity); }接下來我們創(chuàng)建兩個對象打印一下：
public class LoginActivity extends AppCompatActivity {@InjectUser user;@InjectUser user2;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_login);DaggerLoginComponent.create().inject(this);Logger.i(user.toString());Logger.i(user2.toString());}}注意: 第二個坑，單利對象只能在同一個Activity中有效。不同的Activity 持有的對象不同
沒什么辦法么，我就想全局只要一個實例化對象啊？
自定義Scoped就可以解決，實現(xiàn)全局單例模式。
下面是@Singleton的源碼
可以看到定義一個Scope注解，必須添加以下三部分：
- @Scope ：注明是Scope?
- @Documented ：標(biāo)記在文檔?
- @Retention(RUNTIME) ：運(yùn)行時級別
Dagger2 Scope 如何實現(xiàn)全局單例，開始純Android用法。
Dagger2的Android庫支持support-v4包，導(dǎo)包時請記得使用support下的Dagger相關(guān)類
舉例：import dagger.android.support.DaggerApplication;? 先講完全局單例我們再玩這個類。一點點感受生命周期。
最基礎(chǔ)的引用對象我們已經(jīng)講完，接下來就是正題，Android如何使用Dagger2，并綁定生命周期，并且按照mvp的模式拆分。
@Scope @Documented @Retention(RUNTIME) public @interface ActivityScoped { } @ActivityScoped @Component(modules = {ActivityModule.class}, dependencies = AppComponent.class) public interface LoginComponent { // 依賴了AppComponent作父類void inject(LoginActivity activity);void inject(HomeActivity activity); } @Singleton @Component(modules = AppModules.class) public interface AppComponent {// 如果不暴露，外面是調(diào)不到的。User providerUser(); } @Module public class AppModules {@Singleton@ProvidesUser providerUser() {return new User();} } public class ComponentHolder {private static AppComponent myAppComponent;public static void setAppComponent(AppComponent component) {myAppComponent = component;}public static AppComponent getAppComponent() {return myAppComponent;} } public class MyApp extends Application {@Overridepublic void onCreate() {super.onCreate();inject();}private void inject() {AppComponent appComponent = DaggerAppComponent.builder().appModules(new AppModules(this)).build();ComponentHolder.setAppComponent(appComponent);} } @Module public class ActivityModule extends AppModules {}我們只是對基礎(chǔ)的代碼做了簡單的修改，講一下再繼續(xù)寫：（Activity中的代碼沒多少變動）
- 第一，我們的注入類 LoginComponent 繼承了?AppComponent，這個類是在Application中初始化，并且@Singleton標(biāo)記了單例，綁定了全局，來保證單例，我們使用?Component時就是依賴它，dependencies = AppComponent.class 。
- 第二，我們使用?Component時無法使用@Singleton標(biāo)記，因為父類已經(jīng)用過了，再用會報錯。。所以我們自己實現(xiàn)了一個ActivityScoped，和Singleton源碼一樣的，這就是子類權(quán)限低于父類的問題。
Modules和我們上面使用單例一樣@Singleton標(biāo)記，沒變化。
全局單例的區(qū)別就在于Component初始化放在了Application中。
我寫了一個AppModules只是留個父類而已，實際開發(fā)中我們會有很多的類，總要提取一個基類出來。
public class LoginActivity extends AppCompatActivity {@InjectUser user;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_login);ButterKnife.bind(this);DaggerLoginComponent.builder().activityModule(new ActivityModule(MyApp.getInstance())).appComponent(ComponentHolder.getAppComponent()).build().inject(this);}@OnClick(R.id.login_button)public void onViewClicked() {Logger.i("login="+user.toString());startActivity(new Intent(this,HomeActivity.class));} } public class HomeActivity extends AppCompatActivity {@InjectUser user;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);DaggerLoginComponent.builder().activityModule(new ActivityModule(MyApp.getInstance())).appComponent(ComponentHolder.getAppComponent()).build().inject(this);Logger.i("home="+user.toString());} }dagger.android的使用，MVP模式的設(shè)計。請保證依賴了Android庫。
DaggerLoginComponent.builder().activityModule(new ActivityModule(MyApp.getInstance())).appComponent(ComponentHolder.getAppComponent()).build().inject(this);我們發(fā)現(xiàn)了這段代碼會到處都是……而且這段代碼重復(fù)率很高。
官網(wǎng)說明，其實Java這種用法在Android端大有問題！查閱官網(wǎng)的Android用法。
- 第一點，代碼重復(fù)度過高：我們要在幾乎每一個需要注入依賴項的 Activity 和 Fragment 里面來一套這樣的代碼。這是因為我們在 Android 編程中要用到的 Activity、Fragment 等類是繼承自系統(tǒng)的，同時生命周期都由系統(tǒng)管理，所以使用 Dagger 2 的時候就不得不進(jìn)行手動的處理，也就只有在純粹自己寫的 Java 類中使用 Dagger 2 才感覺更舒服一些。
- 第二點，違反了控制反轉(zhuǎn)原則：原有的用法使得被注入的目標(biāo)類必須要了解注入管理工具的詳細(xì)信息，才能讓注入工作順利進(jìn)行。即使可以通過接口使得實際代碼中不必書寫太多的實際類名，但這仍然造成了嚴(yán)重的目標(biāo)類和管理類的緊耦合。
下面我們看一下Android的正確使用方式，
這次也不循序漸進(jìn)了，直接上最終的優(yōu)化版。官網(wǎng)用法很詳細(xì)了，我就不從官網(wǎng)的demo一點點講優(yōu)化了，太累，寫了太多了……
我們盡量簡潔，整體理解，application下初始化，和activity初始化。然后關(guān)聯(lián)，全局使用。
@Singleton @Component(modules = {AppModule.class,BuildersModule.class,ConfigModule.class,AndroidSupportInjectionModule.class} ) public interface AppComponent extends AndroidInjector<MyApp> {@Component.Builderinterface Builder {@BindsInstanceBuilder application(Application application);AppComponent build();} } @Module public class AppModule {@Singleton@ProvidesContext provideContext(Application application) {return application;} } public class MyApp extends DaggerApplication {@Overrideprotected AndroidInjector<? extends DaggerApplication> applicationInjector() {return DaggerAppComponent.builder().application(this).build();} } @Module public abstract class BuildersModule {@ActivityScope@ContributesAndroidInjectorabstract LoginActivity loginActivityInject();@ActivityScope@ContributesAndroidInjectorabstract SplashActivity splashActivityInject(); } @Module public abstract class ConfigModule {@Provides@Singletonstatic Student provideStudent() {return new Student();} } @Documented @Scope @Retention(RetentionPolicy.RUNTIME) public @interface ActivityScope { } public class LoginActivity extends BaseActivity implements MainContract.View {@InjectStudent student;@InjectLoginPresenter presenter;@BindView(R.id.login_button)Button login;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_login);ButterKnife.bind(this);}@OnClick(R.id.login_button)public void onViewClicked() {Logger.i("student:"+student.getName());Logger.i("對象:"+student.toString());presenter.requestHttp();startActivity(new Intent(this, SplashActivity.class));}public void showMessage(String message) {Toast.makeText(this, message, Toast.LENGTH_SHORT).show();}} public class SplashActivity extends BaseActivity {@InjectStudent student;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_splash);Logger.i("對象2:"+student.toString());} } public class BaseActivity extends AppCompatActivity {@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {AndroidInjection.inject(this);super.onCreate(savedInstanceState);} } public interface MainContract {interface View{}interface Presenter {}interface Model {} } public class MainModel implements MainContract.Model {@Injectpublic MainModel() {}public String returnMessage() {return "qi_hao";} } public class LoginPresenter extends BasePresenter implements MainContract.Presenter {private final LoginActivity view;private final MainModel model;@Injectpublic LoginPresenter(LoginActivity view, MainModel model) {this.view = view;this.model = model;}public void requestHttp() {view.showMessage(model.returnMessage());} }App--> AppCompat --->AppModule-->調(diào)用類
Activity--> ActCompat --->ActModule-->調(diào)用類
拆開看其實就這幾條思路，在看代碼的時候?qū)ふ揖涂梢粤?#xff0c;我們說一下Android的正確用法的注意點。。
先回顧前面的基礎(chǔ)，現(xiàn)在全局沒有了那么多ActCompat，現(xiàn)在只有一個Compat類，所有的Module都關(guān)聯(lián)到這個Compat類。
到這一步資料就很多了，看一眼代碼基本上也能理解。
注意點：Activity不可以繼承DaggerActivity，看源碼可知，必須使用源碼中的Fragment才可以繼承此類。
所以老老實實在BaseActivity中寫 AndroidInjection.inject(this); 就一行初始化而已，也不麻煩。。。
Fragment可以繼承DaggerFragment。
Application可以繼承DaggerApplication。
如果使用V4 V7包的Fragment或者Activity，就要導(dǎo)入support包下的類，例如：?dagger.android.support.DaggerApplication;
源碼下載GitHub：已簡單封裝了MVP，會持續(xù)不斷的完善為便捷開發(fā)框架。
贈送源碼：https://github.com/Pangu-Immortal。《最完整的Android逆向知識體系》
總結(jié)
以上是生活随笔為你收集整理的Dagger2 在 Android 项目的正确使用方式【完整篇】的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Xposed是如何为所欲为的？
- 下一篇： Android Studio使用Goog