前言

dagger2确实学习曲线比较陡峭，但是忘掉生命周期，忘掉局部单例，忘掉SubComponent这样的进阶用法，只用最基础最简单的部分一样可以给项目带来一定程度的便利

依赖的提供方式

@Inject注解构造器
@Provides注解提供依赖的方法

@Inject注解构造器-用来提供依赖

表示该类可以作为依赖注入到依赖需求方
如果构造器带参数，则这些参数也需要是可以提供的依赖，dagger2会自动找到这些依赖并注入
对于有多个构造器的类，@Inject只能注解其中一个

public class SimpleInjectExtraBean {
    @Inject
    public SimpleInjectExtraBean() {
    }
}

@Inject构造函数带参数的情况

构造函数中的参数需要是@Inject注解构造器的对象或者是@Provides方法提供的依赖

public class SimpleInjectBean extends BaseBean {
    public SimpleModuleBean mSimpleModuleBean;
    public SimpleInjectExtraBean mSimpleInjectExtraBean;

    @Inject
    public SimpleInjectBean(SimpleModuleBean simpleModuleBean,
            SimpleInjectExtraBean simpleInjectExtraBean) {
        mSimpleModuleBean = simpleModuleBean;
        mSimpleInjectExtraBean = simpleInjectExtraBean;
    }
}

@Module @Provides 提供无法修改构造器的依赖

使用@Inject注解构造器是最简单的提供依赖的方式，但是如果是一个第三方库中的代码无法修改构造函数添加注解呢，这时候就需要module出场了

@Module //@Module注解可以提供依赖的类
public class SimpleModule {

    @Provides // @Provides 注解提供依赖的方法
    public SimpleModuleBean provideSimpleModuleBean() {
        return new SimpleModuleBean();
    }
}

@Provides注解的方法带参数

和@Inject注解的构造函数带的参数一样，也需要是@Inject注解构造器的对象或者是@Provides方法提供的依赖

依赖的接收方式

@Inject注解实例变量-用来接受依赖

public class SimpleActivity extends AppCompatActivity {
    @Inject
    SimpleInjectBean mSimpleInjectBean;
    ...
}

连接依赖提供方和依赖接收方的Component

component是依赖提供方和依赖需求方的连接者，使用@Component注解，注意dagger2只能注解接口和抽象类，具体类注解了也生成不了注入相关的代码

对于@Inject不需要在Component中显示指定

对于module，需要在用@Component的modules属性显示指定

@Component(modules = SimpleModule.class)
public interface SimpleComponent {
    void inject(SimpleActivity simpleActivity);
}

框架会生成DaggerXXXComponent的类，使用DaggerXXXComponent完成注入

public class SimpleActivity extends AppCompatActivity {
    @Inject
    SimpleInjectBean mSimpleInjectBean;
    @Inject
    SimpleInjectExtraBean mSimpleInjectExtraBean;
    @Inject
    SimpleModuleBean mSimpleModuleBean;
    ...
    private SimpleComponent mSimpleComponent;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSimpleComponent = DaggerSimpleComponent.create();
        mSimpleComponent.inject(this);
        ...
    }
}

以上就用dagger2实现了最简单的依赖注入
不过这基本上接近于写了一个HelloWorld
下面看一下更接近真实的简单场景

提供一个运行时的依赖

dagger2实现依赖注入的实质是创建编译期可以确定的所有类的工厂，在运行时通过dagger2生成的工厂代码（依赖注入框架内部）完成依赖的创建与管理

但是像Application，Activity这样的对象的创建过程是android框架完成的，dagger2无法接管这个过程，而非常多的对象的创建会依赖于context，activity这样的对象

为了解决这样的问题，需要将这些运行时对象作为参数提供给dagger框架

为dagger框架提供参数有两种方式

构造器带参数的Module

以Application为例

@Module
public class BaseAppModule {
    private Application mApplication;

    public BaseAppModule(Application application) {
        mApplication = application;
    }

    @Provides
    @Singleton
    Application provideApplication() {
        return mApplication;
    }

    @Provides
    @Singleton
    Context provideContext() {
        return mApplication;
    }
}

Component的获取方式也会变化

//before Component依赖的所有module的构造函数都没带参数，则可以直接通过DaggerXXXComponent.create()直接获取对应的Component实例
DaggerBaseAppComponent.create();
//等价于DaggerXXXComponent.builder().build();
DaggerBaseAppComponent.builder().build();

//after 如果module中带了参数，则编译期不会生成create()方法
//需要使用.builder()传入对应的Module作为参数，这时可以将Application实例作为Module的构造参数传入
DaggerBaseAppComponent.builder().baseAppModule(new BaseAppModule(this)).build();

直接通过@Component.Builder传入参数

@Component.Builder注解一个用来向Component绑定参数的接口

这里以Activity为例,在Component.Builder中使用@BindsInstance注解一个传入Activity的方法

//provideSimpleModuleActivityBean有一个Activity作为参数
@Module
public class SimpleModule {

    @Provides
    public SimpleModuleActivityBean provideSimpleModuleActivityBean(Activity activity) {
        return new SimpleModuleActivityBean(activity);
    }
}

@Component(modules = SimpleModule.class)
public interface SimpleComponent {
    void inject(SimpleActivity simpleActivity);

    @Component.Builder
    interface Builder {
        //创建Component的时候绑定实例
        @BindsInstance
        Builder simpleActivity(Activity simpleActivity);
        
        SimpleComponent build();
    }
}

注意：如果SimpleModule构造函数还带了参数，因为此时的Component.Builder是按照我们定义的而不是完全自动生成的，所以为能够传入Module中需要的参数，需要显式指定该module作为builder的参数

@Component(modules = SimpleModule.class)
@SimpleScope
public interface SimpleComponent {
    void inject(SimpleActivity simpleActivity);

    @Component.Builder
    interface Builder {
        //创建Component的时候绑定实例
        @BindsInstance
        Builder simpleActivity(Activity simpleActivity);

        //使用了Builder就需要显式的指定带参数的module作为builder的参数
        Builder simpleModule(SimpleModule simpleModule);

        SimpleComponent build();
    }
}

总结

这篇文章介绍了为dagger提供依赖和注入依赖以及提供运行时参数的方法，不过离真实场景还是有一定的区别那就是生命周期的管理

下一篇文章将介绍dagger2中依赖的生命周期管理

dagger2从入门到放弃-概念
dagger2从入门到放弃-最基础的用法介绍
dagger2从入门到放弃-Component的继承体系、局部单例
dagger2从入门到放弃-ActivityMultibindings
dagger2从入门到放弃-dagger.android
dagger2从入门到放弃-其他用法
dagger2从入门到放弃-多模块项目下dagger的使用
dagger2从入门到放弃-为何放弃

参考资料

https://google.github.io/dagger/
https://github.com/google/dagger
使用Dagger 2依赖注入
Dagger 2 完全解析

示例代码

DaggerInAction
欢迎star
master分支上最新的代码可能会比当前文章的示例代码稍微复杂点，提交记录里包含了每一步的迭代过程,可以顺藤摸瓜

dagger2从入门到放弃-最基础的用法介绍

前言