daggerandroid
⑴ android dagger 在單個模塊中不能有多個@provides
常情況下我們引用一個類的做法：我們先定義一個簡單的類：1publicclassUser{2privateStringname;34publicStringgetName(){5returnname;6}78publicvoidsetName(Stringname){9this.name=name;10}11}
⑵ android dagger有什麼用
Dagger 是一種android平台的依賴注入框架，是有一家專注於移動支付的公司，Square公司推出的庫，這家公司也推出了其他在Android開發中常用庫：otto，okhttp，retrofit等等。
⑶ android dagger2在fragment中怎麼用
在component中inject fragment就好
AppComponent通常提供全局的對象以便於其他的組件依賴使用，比如context,rest api介面等，這些都是全局的單例對象
MainActivityComponent特意針對MainActivity，所以它只提供其對應的MainActivityPresenter，因為其依賴AppComponent，所以它可以使用AppComponent提供的對象
這里使用http://blog.csdn.net/tiankong1206/article/details/46486401 這里的一個例子，主要把其中的一些細節稍微說的詳細點,下面這一段說明來自網上：
@Inject: 通常在需要依賴的地方使用這個註解。換句話說，你用它告訴Dagger這個類或者欄位需要依賴注入。這樣，Dagger就會構造一個這個類的實例並滿足他們的依賴。
@Mole: Moles類裡面的方法專門提供依賴，所以我們定義一個類，用@Mole註解，這樣Dagger在構造類的實例的時候，就知道從哪裡去找到需要的 依賴。moles的一個重要特徵是它們設計為分區並組合在一起（比如說，在我們的app中可以有多個組成在一起的moles）。
@Provide: 在moles中，我們定義的方法是用這個註解，以此來告訴Dagger我們想要構造對象並提供這些依賴。
@Component: Components從根本上來說就是一個注入器，也可以說是@Inject和@Mole的橋梁，它的主要作用就是連接這兩個部分。 Components可以提供所有定義了的類型的實例，比如：我們必須用@Component註解一個介面然後列出所有的@Moles組成該組件，如 果缺失了任何一塊都會在編譯的時候報錯。所有的組件都可以通過它的moles知道依賴的范圍。
@Scope: Scopes可是非常的有用，Dagger2可以通過自定義註解限定註解作用域。後面會演示一個例子，這是一個非常強大的特點，因為就如前面說的一樣，沒 必要讓每個對象都去了解如何管理他們的實例。在scope的例子中，我們用自定義的@PerActivity註解一個類，所以這個對象存活時間就和 activity的一樣。簡單來說就是我們可以定義所有范圍的粒度(@PerFragment, @PerUser, 等等)。
1、首先是Mole
[java] view plain print?
@Mole
public class MainActivityMole {
private MainActivity mainActivity;
public MainActivityMole(MainActivity mainActivity) {
this.mainActivity = mainActivity;
}
@Provides
@ActivityScope
MainActivity provideMainActivity() {
return mainActivity;
}
@Provides
@ActivityScope
MainActivityPresenter provideMainActivityPresenter(MainActivity mainActivity, User user) {
return new MainActivityPresenter(mainActivity, user);
}
}
注意裡面的provide方法，我們後面還可以看到，這里的語法是@Mole @Providers
然後是Component
[java] view plain print?
@ActivityScope
@Component(moles = {MainActivityMole.class , AppServiceMole.class})
public interface MainActivityComponent {
MainActivity inject(MainActivity mainActivity);
}
這里的MainActivityComponent包含兩個Mole，一個是我們上面列出來的MainActivityMole，另一個是AppServiceMole
接下來就是使用了，在MainActivity中：
[java] view plain print?
@Override
protected void setupActivityComponent() {
DaggerMainActivityComponent.builder()
.mainActivityMole(new MainActivityMole(this))
.appServiceMole(new AppServiceMole())
.build()
.inject(this);
}
這里在build之前把Component用到的每一個Mole的構造函數初始化一下，在build之後inject注入，我們看一下這個自動生成的DaggerMainActivityComponent
[java] view plain print?
package com.example.lwp.mvp.ui.activity.component;
import com.example.lwp.mvp.data.AppServiceMole;
import com.example.lwp.mvp.data.AppServiceMole_ProvideUserFactory;
import com.example.lwp.mvp.model.User;
import com.example.lwp.mvp.ui.activity.MainActivity;
import com.example.lwp.mvp.ui.activity.MainActivity_MembersInjector;
import com.example.lwp.mvp.ui.activity.mole.MainActivityMole;
import com.example.lwp.mvp.ui.activity.mole.MainActivityMole_ProvideMainActivityFactory;
import com.example.lwp.mvp.ui.activity.mole.MainActivityMole_;
import com.example.lwp.mvp.ui.activity.presenter.MainActivityPresenter;
import dagger.MembersInjector;
import dagger.internal.MembersInjectors;
import dagger.internal.ScopedProvider;
import javax.annotation.Generated;
import javax.inject.Provider;
@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerMainActivityComponent implements MainActivityComponent {
private Provider<MainActivity> provideMainActivityProvider;
private Provider<User> provideUserProvider;
private Provider<MainActivityPresenter> ;
private MembersInjector<MainActivity> mainActivityMembersInjector;
private DaggerMainActivityComponent(Builder builder) {
assert builder != null;
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
private void initialize(final Builder builder) {
this.provideMainActivityProvider = ScopedProvider.create(MainActivityMole_ProvideMainActivityFactory.create(builder.mainActivityMole));
this.provideUserProvider = AppServiceMole_ProvideUserFactory.create(builder.appServiceMole);
this. = ScopedProvider.create(MainActivityMole_.create(builder.mainActivityMole, provideMainActivityProvider, provideUserProvider));
this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), );
}
@Override
public MainActivity inject(MainActivity mainActivity) {
mainActivityMembersInjector.injectMembers(mainActivity);
return mainActivity;
}
public static final class Builder {
private MainActivityMole mainActivityMole;
private AppServiceMole appServiceMole;
private Builder() {
}
public MainActivityComponent build() {
if (mainActivityMole == null) {
throw new IllegalStateException("mainActivityMole must be set");
}
if (appServiceMole == null) {
this.appServiceMole = new AppServiceMole();
}
return new DaggerMainActivityComponent(this);
}
public Builder mainActivityMole(MainActivityMole mainActivityMole) {
if (mainActivityMole == null) {
throw new NullPointerException("mainActivityMole");
}
this.mainActivityMole = mainActivityMole;
return this;
}
public Builder appServiceMole(AppServiceMole appServiceMole) {
if (appServiceMole == null) {
throw new NullPointerException("appServiceMole");
}
this.appServiceMole = appServiceMole;
return this;
}
}
}
這裡面有兩個類，一個是DaggerMainActivityComponent,另一個是Build類，Build中就是幾個模塊的初始化以及build方法構建DaggerMainActivityComponent類並初始化。DaggerMainActivityComponent類中定義了很多provider成員，這些成員就是Mole中提供的一些provider方法，還有其中的一些成員方法中的參數，那麼這些各個類構造函數是怎麼調用的呢，其實，我們Mole中每一個定義的provide方法，都會生成一個MainActivityMole_類似的類
[java] view plain print?
package com.example.lwp.mvp.ui.activity.mole;
import com.example.lwp.mvp.model.User;
import com.example.lwp.mvp.ui.activity.MainActivity;
import com.example.lwp.mvp.ui.activity.presenter.MainActivityPresenter;
import dagger.internal.Factory;
import javax.annotation.Generated;
import javax.inject.Provider;
@Generated("dagger.internal.codegen.ComponentProcessor")
public final class MainActivityMole_ implements Factory<MainActivityPresenter> {
private final MainActivityMole mole;
private final Provider<MainActivity> mainActivityProvider;
private final Provider<User> userProvider;
public MainActivityMole_(MainActivityMole mole, Provider<MainActivity> mainActivityProvider, Provider<User> userProvider) {
assert mole != null;
this.mole = mole;
assert mainActivityProvider != null;
this.mainActivityProvider = mainActivityProvider;
assert userProvider != null;
this.userProvider = userProvider;
}
@Override
public MainActivityPresenter get() {
MainActivityPresenter provided = mole.provideMainActivityPresenter(mainActivityProvider.get(), userProvider.get());
if (provided == null) {
throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
}
return provided;
}
public static Factory<MainActivityPresenter> create(MainActivityMole mole, Provider<MainActivity> mainActivityProvider, Provider<User> userProvider) {
return new MainActivityMole_(mole, mainActivityProvider, userProvider);
}
}
可以看到，這裡面在需要MainActivityPresenter時候可以調用它的get方法，MainActivityPresenter的構造函數依賴另外兩個對象，我們看他們其中他一個的Factory函數
[java] view plain print?
package com.example.lwp.mvp.ui.activity.mole;
import com.example.lwp.mvp.ui.activity.MainActivity;
import dagger.internal.Factory;
import javax.annotation.Generated;
@Generated("dagger.internal.codegen.ComponentProcessor")
public final class MainActivityMole_ProvideMainActivityFactory implements Factory<MainActivity> {
private final MainActivityMole mole;
public MainActivityMole_ProvideMainActivityFactory(MainActivityMole mole) {
assert mole != null;
this.mole = mole;
}
@Override
public MainActivity get() {
MainActivity provided = mole.provideMainActivity();
if (provided == null) {
throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
}
return provided;
}
public static Factory<MainActivity> create(MainActivityMole mole) {
return new MainActivityMole_ProvideMainActivityFactory(mole);
}
}
這是MainActivity的Provider，可以看到它的get函數最後調用了mole也就是MainActivityMole中的provideMainActivity，這里就直接返回了一個MainActivity，所以，如果我們的構造函數中含有參數，dragger也會調用相應參數的Provider的Facory來生成相應的參數
從這里也可以看出這些類之間的構造依賴不能構成環路。
}
⑷ Kotlin怎樣使用Android的Dagger2
在Android Studio中打開Settings，選擇Plugins選項，點擊Browse Repositories，在打開的新窗口中搜索Kotlin，如下圖所示。
選擇Kotlin與 Kotlin Extenslons For Android(obsolete)兩個插件分別進行安裝。當插件安裝完畢後，重啟Android Studio即可。
在Android Studio中使用Kotlin插件
打開Android Studio新建一個項目，和往常一樣建立一個項目就可以了，項目建立好以後，我們會在右鍵菜單New下看到多出來Kotlin File/Class和Kotlin Activity兩個選項。
- Kotlin File/Class：一個普通的Kotlin類，類似普通的Java類
- Kotlin Actiivty：一個Activity類
⑸ android dagger 框架怎麼用
dagger是使用依賴注入的方式，使用Annotation給需要注入的對象做標記，通過inject()方法自動注入所有對象，從而完成自動的初始化。
示例代碼：
public class MainActivity extends Activity {
// 通過@Inject對對象進行標記
@Inject SharedPreferences sharedPreferences;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 注入依賴
ObjectGraph.create(AppMole.class).inject(this);
// 獲取name的值並輸出
System.out.println(sharedPreferences.getString("name", ""));
}
}
依賴注入(Dependency Injection)：在類A中要用到一個B的對象（依賴），需要通過新建B的實例或其他一些主動的方式來獲取對象，然後才能調用。而通過外部的方式自動將B的對象分配給A（注入），實現相對被動的獲取對象，這個過程稱為依賴注入。希望更多了解依賴注入可以自行Google。
⑹ android開發要不要用dagger2
用Dagger2在Android中實現依賴注入
依賴注入這個模式（模式已經用爛了，這里再爛一次）是用來給應用的各部分解耦的。使應用開發更加可擴展，更容易維護。通過本文你會學到如何使用Dagger2來處理依賴。
簡介
如果以對象需要另外的一個對象才能完成一個完整功能的話，那麼這里就存在一個依賴。比如，悟空要用金箍棒才能三打白骨精，要筋斗雲才能十萬八千里。悟空有對金箍棒和筋斗雲的依賴。你可以在悟空對象里初始化金箍棒，也可以用一個工廠方法批量生產金箍棒。使用依賴注入可以無需一個專門的類來初始化這些依賴對象。這樣就實現了解耦。
本教程會使用最新的Dagger2（當前的版本是2.2）。這里是官網。你可以在這里找到最新的發布。
准備
Android Studio是必須的。其他：
1. Dagger2 基礎
註解講解：
@Mole這個annotation修飾的類專門用來提供依賴
@Provides這個annotation修飾的方法用在Mole類里
@Inject用來annotation一個依賴（可以是構造方法、field或者一般的方法）
@Component連接@Mole和注入的橋梁
這些名詞看起來非常抽象。下面稍微解釋一下。依賴反射並沒有什麼神奇的地方。只不過是我們需要單獨寫初始化依賴的地方由其他的框架代替了。這個依賴關系也有我們常寫的代碼轉移到了「配置文件」中。
在很久以前，依賴注入的框架就是這樣處理依賴注入的：讀取配置文件的依賴關系，然後用反射的方法初始化被依賴對象並賦值給調用依賴的對象。比如，我們之前在悟空類中初始化金箍棒：
public class Wukong {
private Jingubang jingubang;
public Wukong(){
// 依賴
this.jingubang = Jingubang();
}
}
後來有了使用配置文件的依賴注入（這里都是虛構的文件格式）：
<xml>
<com.xiyou.Wukong>
<dependency field="jingubang">
<com.xiyou.Jingubang />
</dependency>
</com.xiyou.Wukong>
</xml>
在悟空使用金箍棒的時候，依賴注入框架自動初始化好了金箍棒，並賦值給了悟空。
現在使用Dagger2。這里就有不得不說的牛X的地方了。因為是在Android里能用的資源沒有後端那麼多。尤其反射消耗比較大！所以Dagger為了滿足移動開發節約資源的需要，沒有使用反射實現依賴注入。而是在編譯的時候同時生成依賴注入的相關代碼。生成代碼的根據就是前文中說明的那些註解（annotation）以及使用這些annotation的類、介面。
總結起來就一句話，Dagger把你需要在悟空類里寫的金箍棒類的初始化代碼都根據註解替你自動生成了！只不過這種生成的代碼比明晃晃的使用new初始化的方法更加復雜一些。
Dagger2 開發步驟
把大象裝冰箱一共分幾步：
定義依賴和被依賴的對象的類，悟空類和金箍棒類。「悟空類」和「金箍棒類」的構造函數用@Inject註解修飾。
定義一個@Mole註解的類，一般叫做XXXMole。裡面寫的@Provides註解修飾的方法。這些@Provides方法返回「悟空類」和「金箍棒類」對象。比如@Provides Wukong provideWukong(){ return new Wukong(); }
創建一個interface，並用@Component註解修飾。一般叫做XXXComponent。裡面寫一個注入方法：void inject(Wukong wk);。這里Wukong只是一個例子。任何你准備要注入的類都可以代替上面參數的Wukong類。
在需要注入的地方寫@Inject的field。
最後，Dagger會根據上面的內容和最後的@Component介面生成一個DaggerXXXComponent的類型，使用這個類型來實現注入。上面的1到3步可以理解為依賴的配置。最後的XXXComponent代替古老的Reflect方式實現注入。
第一步的@Inject修飾的構造函數和`@Mole`的`provideXXX`方法二者可以省略一個。
Dagger可以根據其中的任意一種配置創建依賴的對象。都寫上等於有了雙保險。
上文提到過多次。Dagger 2厲害的地方就在於這個庫完全不用反射，而是用在編譯期生成代碼的方式實現的依賴注入。這個特點導致在Android Studio配置的時候需要做一些額外的工作。
這里假設你已經創建了一個新的Android應用項目。下面打開build.gradle文件，我們一步一步的來完成Dagger2的配置。
3. Android Studio的配置
第一步、
apply plugin: 'kotlin-android' // 非必須
apply plugin: 'kotlin-android-extensions' // 必須！！！
為什麼要加一個新的plugin呢？這個是為後面使用的kapt和provided提供支持的。gradle本身不支持這兩個操作。
第二步、
buildscript {
ext.kotlin_version = '1.0.1-2'
repositories {
mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version"
}
}
第三步、
dependencies {
// ...其他略...
compile 'com.google.dagger:dagger:2.2'
kapt 'com.google.dagger:dagger-compiler:2.2'
provided 'javax.annotation:jsr250-api:1.0'
}
dagger, 我們要用的正主。
dagger-compiler, 用來生成代碼。
java.annotation, 提供Dagger意外的註解
最後，同步Gradle。
使用Dagger 2
下面就是Dagger一展身手的時候了。
首先，我們已經有悟空和金箍棒了。代碼如下：
悟空：
import javax.inject.Inject;
/**
* Created by uncle_charlie on 6/4/2016.
*/
public class Wukong {
@Inject
JinGuBang jinGuBang;
@Inject
public Wukong() {
}
public String useJinGuBang() {
return this.jinGuBang.use();
}
}
金箍棒：
import javax.inject.Inject;
/**
* Created by uncle_charlie on 6/4/2016.
*/
public class JinGuBang {
@Inject
public JinGuBang() {
}
public String use() {
return "user Jing gu bang";
}
}
悟空對金箍棒有依賴，所以金箍棒屬性有@Inject註解修飾。
因為兩個類都需要Dagger創建，所以在構造函數上都有@Inject註解。
第二步、創建@Mole類
創建@Mole註解的類，並在其中添加@Provides註解修飾的方法。這些方法創建被依賴的對象。
import dagger.Mole;
import dagger.Provides;
/**
* Created by uncle_charlie on 6/4/2016.
*/
@Mole
public class XiYouMole {
@Provides
// @Singleton
Wukong provideWukong() {
return new Wukong();
}
@Provides
// @Singleton
JinGuBang provideJinGuBang() {
return new JinGuBang();
}
}
@Singleton註解表明，這個被依賴的對象在應用的生命周期里只有一個實例。
這個里的@Provides方法和前一步說到的@Inject註解的構造函數兩個可以只寫一個。
第三步、@Component介面，連接@Mole和@Inject
@Mole和@Provides方法提供了被依賴的對象。@Inject在@Component介面出現的地方則是指明了需要注入的地方（一般是一個field）。@Component介面就是用來把他們連接起來的。
import android.app.Activity;
import javax.inject.Singleton;
import dagger.Component;
/**
* Created by uncle_charlie on 6/4/2016.
*/
@Component(moles = {XiYouMole.class})
@Singleton
public interface XiYouComponent {
void inject(Wukong wk);
void inject(Activity a);
}
其中inject()方法里使用的對象，就是包含@Inject的field的需要注入的對象。
在這個介面中也可以不用inject()方法，而使用provideXXX()方法後面會有更多介紹。
注意：@Component介面一定要在直接中指明@Mole類型
第四步、使用@Component介面獲取對象
經過前面的步驟，依賴和被依賴對象關系都已經配置好了。下面就來獲取被依賴對象來注入依賴對象。
public class MainActivity extends AppCompatActivity {
private static final String TAG = "##MainActivity";
@Inject
Wukong wukong;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TextView welcomeTextView = (TextView) findViewById(R.id.welcome_textview);
// 1
XiYouComponent xiYouComponent = DaggerXiYouComponent
.builder()
// 2
.xiYouMole(new XiYouMole())
.build();
xiYouComponent.inject(this);
// 3
welcomeTextView.setText(wukong.useJinGuBang());
}
}
首先主要到屬性@Inject Wukong wukong;已經在MainActivity聲明了。這里表明一個依賴關系：這個activity依賴於悟空，並准備注入悟空對象。
Dagger2會在編譯器自動生成依賴注入的代碼，所以在添加上面的代碼之前需要編譯一下。DaggerXiYouComponent就是Dagger根據我們的XiYouMole類生成的代碼。
在這一步給DaggerXiYouComponent的builder添加XiYouMole的實例。如果這個Mole只需要用到無參構造函數的話可以用一種省略用法：create()方法。可以簡寫為：
DaggerXiYouComponent
.builder()
// 2
//.xiYouMole(new XiYouMole())
//.build()
.create();
Component介面的對象調用inject(this)方法之後注入即完成。所以可以直接使用@Inject Wukong wukong;屬性來調用方法：welcomeTextView.setText(wukong.useJinGuBang());最後在activity中顯示方法返回的文字。
運行代碼，看看結果吧。
結論
以上內容可以概括為：什麼被依賴，就把什麼放在@Mole類里（或者什麼被依賴，就給什麼添加@Inject的無參構造函數）。什麼有依賴（@Inject屬性），就把什麼放在@Component介面的inject()方法參數里。（或者有什麼@Inject屬性，就在@Component介面里provide什麼對象）。這個概括不一定嚴密，但是基本用法全部包括了。
依賴注入是很有用的。以上的內容只是Dagger2依賴注入的一部分。各位讀者還需要根據官方文檔多加練習才能更好的理解依賴注入和Dagger的各種用法。
⑺ dagger2 android 怎麼用
簡單的說 Dagger就是用來創造這個容器，所有需要被依賴的對象在Dagger的容器中實例化，並通過Dagger注入到合適的地方，實現解耦，MVP框架就是為解耦而生，因此MVP和Dagger是絕配；
舉個栗子？
通常情況下我們引用一個類的做法：
我們先定義一個簡單的類：
1 public class User {
2 private String name;
3
4 public String getName() {
5 return name;
6 }
7
8 public void setName(String name) {
9 this.name = name;
10 }
11 }
⑻ Android Dagger2 @Provides問題
GithubApiMole_ProvideGitHubServiceFactory 類中有兩個成員，一個是提供（@Provides）GithubService 所在的 mole 類，一個是創建GithubService方法所需參數的retrofitProvider（從這里可以看出Dagger2需要創建retrofitProvider的工廠）。然後通過 mole.provdeGitHubService()方法來創建 GithubApiService實例，這樣最終穿件了在ReposListActivity中注入的依賴實例。
⑼ android 中各種框架Rxjava，RxBus，dagger這些真的在工作中敢用嗎
RxJava目前項目在用還是很穩定的
目前網路用的是Rxjava+ReTrofit+okHttp這些框架已經很成熟了完全可以引入項目