Android dagger2使用

AppComponent通常提供全局的对象以便于其他的组件依赖使用，比如context,rest api接口等，这些都是全局的单例对象

MainActivityComponent特意针对MainActivity，所以它只提供其对应的MainActivityPresenter，因为其依赖AppComponent，所以它可以使用AppComponent提供的对象

这里使用http://blog.csdn.net/tiankong1206/article/details/46486401 这里的一个例子，主要把其中的一些细节稍微说的详细点,下面这一段说明来自网上：

@Inject: 通常在需要依赖的地方使用这个注解。换句话说，你用它告诉Dagger这个类或者字段需要依赖注入。这样，Dagger就会构造一个这个类的实例并满足他们的依赖。

@Module: Modules类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样Dagger在构造类的实例的时候，就知道从哪里去找到需要的 依赖。modules的一个重要特征是它们设计为分区并组合在一起（比如说，在我们的app中可以有多个组成在一起的modules）。

@Provide: 在modules中，我们定义的方法是用这个注解，以此来告诉Dagger我们想要构造对象并提供这些依赖。

@Component: Components从根本上来说就是一个注入器，也可以说是@Inject和@Module的桥梁，它的主要作用就是连接这两个部分。 Components可以提供所有定义了的类型的实例，比如：我们必须用@Component注解一个接口然后列出所有的@Modules组成该组件，如 果缺失了任何一块都会在编译的时候报错。所有的组件都可以通过它的modules知道依赖的范围。

@Scope: Scopes可是非常的有用，Dagger2可以通过自定义注解限定注解作用域。后面会演示一个例子，这是一个非常强大的特点，因为就如前面说的一样，没 必要让每个对象都去了解如何管理他们的实例。在scope的例子中，我们用自定义的@PerActivity注解一个类，所以这个对象存活时间就和 activity的一样。简单来说就是我们可以定义所有范围的粒度(@PerFragment, @PerUser, 等等)。

1、首先是Module

@Module
public class MainActivityModule {

    private MainActivity mainActivity;

    public MainActivityModule(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方法，我们后面还可以看到，这里的语法是@Module @Providers

然后是Component

@ActivityScope
@Component(modules = {MainActivityModule.class , AppServiceModule.class})
public interface MainActivityComponent {
    MainActivity inject(MainActivity mainActivity);

}

这里的MainActivityComponent包含两个Module，一个是我们上面列出来的MainActivityModule，另一个是AppServiceModule

接下来就是使用了，在MainActivity中：

@Override
    protected void setupActivityComponent() {
        DaggerMainActivityComponent.builder()
                .mainActivityModule(new MainActivityModule(this))
                .appServiceModule(new AppServiceModule())
                .build()
                .inject(this);

    }

这里在build之前把Component用到的每一个Module的构造函数初始化一下，在build之后inject注入，我们看一下这个自动生成的DaggerMainActivityComponent

package com.example.lwp.mvp.ui.activity.component;

import com.example.lwp.mvp.data.AppServiceModule;
import com.example.lwp.mvp.data.AppServiceModule_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.module.MainActivityModule;
import com.example.lwp.mvp.ui.activity.module.MainActivityModule_ProvideMainActivityFactory;
import com.example.lwp.mvp.ui.activity.module.MainActivityModule_ProvideMainActivityPresenterFactory;
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> provideMainActivityPresenterProvider;
  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(MainActivityModule_ProvideMainActivityFactory.create(builder.mainActivityModule));
    this.provideUserProvider = AppServiceModule_ProvideUserFactory.create(builder.appServiceModule);
    this.provideMainActivityPresenterProvider = ScopedProvider.create(MainActivityModule_ProvideMainActivityPresenterFactory.create(builder.mainActivityModule, provideMainActivityProvider, provideUserProvider));
    this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideMainActivityPresenterProvider);
  }

  @Override
  public MainActivity inject(MainActivity mainActivity) {  
    mainActivityMembersInjector.injectMembers(mainActivity);
    return mainActivity;
  }

  public static final class Builder {
    private MainActivityModule mainActivityModule;
    private AppServiceModule appServiceModule;
  
    private Builder() {  
    }
  
    public MainActivityComponent build() {  
      if (mainActivityModule == null) {
        throw new IllegalStateException("mainActivityModule must be set");
      }
      if (appServiceModule == null) {
        this.appServiceModule = new AppServiceModule();
      }
      return new DaggerMainActivityComponent(this);
    }
  
    public Builder mainActivityModule(MainActivityModule mainActivityModule) {  
      if (mainActivityModule == null) {
        throw new NullPointerException("mainActivityModule");
      }
      this.mainActivityModule = mainActivityModule;
      return this;
    }
  
    public Builder appServiceModule(AppServiceModule appServiceModule) {  
      if (appServiceModule == null) {
        throw new NullPointerException("appServiceModule");
      }
      this.appServiceModule = appServiceModule;
      return this;
    }
  }
}

这里面有两个类，一个是DaggerMainActivityComponent,另一个是Build类，Build中就是几个模块的初始化以及build方法构建DaggerMainActivityComponent类并初始化。DaggerMainActivityComponent类中定义了很多provider成员，这些成员就是Module中提供的一些provider方法，还有其中的一些成员方法中的参数，那么这些各个类构造函数是怎么调用的呢，其实，我们Module中每一个定义的provide方法，都会生成一个MainActivityModule_ProvideMainActivityPresenterFactory类似的类

package com.example.lwp.mvp.ui.activity.module;

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 MainActivityModule_ProvideMainActivityPresenterFactory implements Factory<MainActivityPresenter> {
  private final MainActivityModule module;
  private final Provider<MainActivity> mainActivityProvider;
  private final Provider<User> userProvider;

  public MainActivityModule_ProvideMainActivityPresenterFactory(MainActivityModule module, Provider<MainActivity> mainActivityProvider, Provider<User> userProvider) {  
    assert module != null;
    this.module = module;
    assert mainActivityProvider != null;
    this.mainActivityProvider = mainActivityProvider;
    assert userProvider != null;
    this.userProvider = userProvider;
  }

  @Override
  public MainActivityPresenter get() {  
    MainActivityPresenter provided = module.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(MainActivityModule module, Provider<MainActivity> mainActivityProvider, Provider<User> userProvider) {  
    return new MainActivityModule_ProvideMainActivityPresenterFactory(module, mainActivityProvider, userProvider);
  }
}

可以看到，这里面在需要MainActivityPresenter时候可以调用它的get方法，MainActivityPresenter的构造函数依赖另外两个对象，我们看他们其中他一个的Factory函数

package com.example.lwp.mvp.ui.activity.module;

import com.example.lwp.mvp.ui.activity.MainActivity;
import dagger.internal.Factory;
import javax.annotation.Generated;

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class MainActivityModule_ProvideMainActivityFactory implements Factory<MainActivity> {
  private final MainActivityModule module;

  public MainActivityModule_ProvideMainActivityFactory(MainActivityModule module) {  
    assert module != null;
    this.module = module;
  }

  @Override
  public MainActivity get() {  
    MainActivity provided = module.provideMainActivity();
    if (provided == null) {
      throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
    }
    return provided;
  }

  public static Factory<MainActivity> create(MainActivityModule module) {  
    return new MainActivityModule_ProvideMainActivityFactory(module);
  }
}

这是MainActivity的Provider，可以看到它的get函数最后调用了module也就是MainActivityModule中的provideMainActivity，这里就直接返回了一个MainActivity，所以，如果我们的构造函数中含有参数，dragger也会调用相应参数的Provider的Facory来生成相应的参数

从这里也可以看出这些类之间的构造依赖不能构成环路。

参考：http://yongjhih.gitbooks.io/feed/content/dagger2.html#%E4%BB%80%E9%BA%BC%E6%98%AF-di
http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2015/0519/2892.html http://blog.csdn.net/tiankong1206/article/details/45967935 http://www.bkjia.com/Androidjc/1009010.html http://www.educity.cn/java/501521.html http://blog.csdn.net/tiankong1206/article/details/46486401