dagger.android使用解析

发表于 | 分类于

参考资料:
Dagger2 与 AndroidInjector
告别 Dagger2 模板代码：Dagger Android 使用详解
Dagger2 Android

前面都是一些基础概念, 现在开始正式开始使用dagger.android了, 也就是说在正式项目中使用Dagger2. 正如聊聊 GeekNews 架构：MVP + RRD说的那样, 在学习一个框架之前要认清这个框架可以为我们带来什么好处, 能够帮助你找出最适合的使用场景从而灵活运用.Dagger2的好处就是降低耦合, 解除依赖关系, 就不用在Activity或者Fragment中写那么多new一个对象的代码了.所以我们的首要目标是, 学习如何给Activity以及Fragment注入对象.

在Android项目中使用Dagger的问题

我就直接搬用官方文档中的例子了.

在使用 Dagger2 进行 Android 开发时，不可避免的问题是很多类是由系统来实例化的, 比如 Activity 或者 Fragment。最理想的情况是 Dagger 能够创建所有需要依赖注入的对象，但事实上，我们不得不在容器的声明周期中声明这样的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class FrombulationActivity extends Activity {
  @Inject Frombulator frombulator;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // DO THIS FIRST. Otherwise frombulator might be null!
    ((SomeApplicationBaseType) getContext().getApplicationContext())
        .getApplicationComponent()
        .newActivityComponentBuilder()
        .activity(this)
        .build()
        .inject(this);
    // ... now you can write the exciting code
  }
}

可以这段代码需要在生命周期方法中调用, 之后才能正常使用被注入的对象. 可以看到FrombulationActivity需要知道自身是被AppComponent所注入的, 而实际上, 被注入的类不应该了解注入者.
dagger.android就是为了在这一点上进行改进.

为Activity注入对象

首先还是要在build.gradle中添加依赖引入dagger.android

1
2
3
4
5
6
7
// dagger2
compile 'com.google.dagger:dagger:2.16'
annotationProcessor 'com.google.dagger:dagger-compiler:2.16'
// dagger.android
compile 'com.google.dagger:dagger-android:2.16'
compile 'com.google.dagger:dagger-android-support:2.16' // if you use the support libraries
annotationProcessor 'com.google.dagger:dagger-android-processor:2.16'

开始注入:
1.在application component中安装AndroidInjectionModule

1
2
3
4
5
6
7
8
@Singleton
@Component(modules = {
    AndroidInjectionModule.class,
    ...
})
public interface AppComponent {
    void inject(DemoApplication application);
}

2.创建一个subcomponent

1
2
3
4
5
@Subcomponent(modules = UserModule.class)
public interface YourActivitySubcomponent extends AndroidInjector<YourActivity> {
    @Subcomponent.Builder
    abstract class Builder extends AndroidInjector.Builder<YourActivity> {}
}

需要继承AndroidInjector并且提供一个Builder, 并且该builder需要继承AndroidInjector.Builder(它继承自AndroidInjector.Factory)
另外, UserModule中是用来提供给Activity注入的对象, 代码如下:

1
2
3
4
5
6
7
8
9
@Module
public class UserModule {
    
    @Provides
    User provideUser() {
        User user = new User("mundane", 0);
        return user;
    }
}

3.新建一个Module

1
2
3
4
5
6
7
8
@Module(subcomponents = YourActivitySubcomponent.class)
public abstract class YourActivityModule {
    @Binds
    @IntoMap
    @ActivityKey(YourActivity.class)
    abstract AndroidInjector.Factory<? extends Activity>
    bindYourActivityInjectorFactory(YourActivitySubcomponent.Builder builder);
}

使用@Binds来将YourActivitySubcomponent.Builder绑定到接口AndroidInjector.Factory中, 因为在上面说了, YourActivitySubcomponent.Builder是继承了AndroidInjector.Factory的

4.将这个module添加到Application的Component中

1
2
3
4
5
6
7
8
9
@Singleton
@Component(modules = {
    AndroidInjectionModule.class,
    YourActivityModule.class,
    ...
})
public interface AppComponent {
    void inject(DemoApplication application);
}

5.修改我们的Applicatoin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class DemoApplication extends Application implements HasActivityInjector {
    
    @Inject
    DispatchingAndroidInjector<Activity> dispatchingActivityInjector;
    
    @Override
    public void onCreate() {
        super.onCreate();
        DaggerAppComponent.create().inject(this);
    }
    
    @Override
    public AndroidInjector<Activity> activityInjector() {
        return dispatchingActivityInjector;
    }
    
}

首先这个application要实现HasActivityInjector, 然后会实现其中的方法activityInjector, 这时候我们需要注入一个DispatchingAndroidInjector对象(注意DispathingAndroidInjector是实现了AndroidInjector的), 该对象的注入我们直接用@Inject就行了, dagger会自动帮我们注入(注意, 我们并没有提供@Provides这样的方法来提供这个对象).
然后在activityInjector方法中返回DispatchingAndroidInjector对象

6.最后一步, 在Activity.onCreate()方法中, 调用AndroidInjection.inject(this), 要在super.onCreate()之前. 代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class YourActivity extends AppCompatActivity {
    
    private static final String TAG = "YourActivity";
    
    @Inject
    User mUser;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        AndroidInjection.inject(this);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_your);
        Log.d(TAG, "mUser = " + mUser);
        
    }
}

检验一下是否对Activity成功注入, 将程序跑起来, log打印如下:

1
D/YourActivity: mUser = me.mundane.daggerfragmentinjectdemo.bean.User@b1b6f33

可见我们已经成功对Activity注入了User对象.

分析一下原理, 直接看AndroidInjection.inject(this)这个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void inject(Activity activity) {
  checkNotNull(activity, "activity");
  Application application = activity.getApplication();
  if (!(application instanceof HasActivityInjector)) {
    throw new RuntimeException(
        String.format(
            "%s does not implement %s",
            application.getClass().getCanonicalName(),
            HasActivityInjector.class.getCanonicalName()));
  }

  AndroidInjector<Activity> activityInjector =
      ((HasActivityInjector) application).activityInjector();
  checkNotNull(activityInjector, "%s.activityInjector() returned null", application.getClass());

  activityInjector.inject(activity);
}

该方法首先取出Application对象, 如果发现这个application没有实现HasActivityInjector就会报错.
然后调用application的activityInjector()获取一个AndroidInjector对象, 更确切的来说, 是DispatchingAndroidInjector对象, 最后调用该对象的inject方法完成注入.
现在问题集中到了dispatchingActivityInjector对象, 该对象是我们在 Application 中通过 dagger 自动注入的.
但是这篇博客就暂时在这里浅尝辄止了, 具体的原理我会另开一篇博客详细介绍.

简化上述步骤

上面的一些步骤其实有些繁琐, 我们可以简化步骤2和步骤3.现在我们把YourActivitySubcomponent这个类了, 把它删了. 删了之后YourActivityModule这个类就报错了

所以现在修改这个类, 代码如下

1
2
3
4
5
6
@Module
public abstract class YourActivityModule {
    @ActivityScope
    @ContributesAndroidInjector(modules = { UserModule.class})
    abstract YourActivity contributeYourActivityInjector();
}

@ActivityScope是为了限制UserModule.class中提供的对象的作用域.
现在我们再次启动YourActivity, log如下:

1
D/YourActivity: mUser = me.mundane.daggerfragmentinjectdemo.bean.User@b1b6f33

可见这种方式一样能为Activity注入对象

上述简化步骤的原理

我们打开YourActivityModule_ContributeYourActivityInjector这个类, 它是由上述的简化步骤自动生成的, 代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Module(
  subcomponents = YourActivityModule_ContributeYourActivityInjector.YourActivitySubcomponent.class
)
public abstract class YourActivityModule_ContributeYourActivityInjector {
  private YourActivityModule_ContributeYourActivityInjector() {}

  @Binds
  @IntoMap
  @ActivityKey(YourActivity.class)
  abstract AndroidInjector.Factory<? extends Activity> bindAndroidInjectorFactory(
      YourActivitySubcomponent.Builder builder);

  @Subcomponent(modules = UserModule.class)
  @ActivityScope
  public interface YourActivitySubcomponent extends AndroidInjector<YourActivity> {
    @Subcomponent.Builder
    abstract class Builder extends AndroidInjector.Builder<YourActivity> {}
  }
}

没错, 看起来就跟我们第一次中的步骤2和步骤3中的代码一样.

注入以Activity为构造参数的对象

有时候我们需要注入的对象需要以Context甚至Activity作为构造函数中的参数, 比如dialog.那这时代码该怎么写呢?我们改一下UserModule的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Module
public class UserModule {
    
    @Provides
    User provideUser() {
        User user = new User("mundane", 0);
        return user;
    }
    
    @ActivityScope
    @Provides
    TextView provideTextView(YourActivity activity) {
        TextView textView = new TextView(activity);
        return textView;
    }
}

然后是YourActivity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class YourActivity extends AppCompatActivity {
    
    private static final String TAG = "YourActivity";
    
    @Inject
    User mUser;
    @Inject
    TextView mTv;
    private FrameLayout mFl;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        AndroidInjection.inject(this);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_your);
        Log.d(TAG, "mUser = " + mUser);
        mFl = findViewById(R.id.fl);
    
        mTv.setText(mUser.name);
        mFl.addView(mTv);
    }
}

我就直接上应用截图了

可见这个textView对象已经被成功注入了, 那同理, 要注入一个dialog对象也是不成问题的.
那现在我们把provideTextView方法中的入参类型改成Activity或者Context会怎么样呢?试一下吧

结果是, 妥妥的报错了, 所以这里的结论是这样的:
Component的inject方法接收父类型参数，而调用时传入的是子类型对象则无法注入，也就是说无法使用多态方式进行注入。
举个例子, 在不使用dagger.android的时候, 我们是这样写的
LoginActivity.java

1
2
3
4
5
6
7
8
9
10
11
12
13
public class LoginActivity extends AppCompatActivity {

    @Inject
    UserManager mManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        DaggerUserComponet.create().inject(this);
        mManager.login();
    }
}

UserComponet.java

1
2
3
4
5
@Singleton
@Component(modules = {UserModule.class})
public interface UserComponet {
    void inject(MainActivity mainActivity);
}

这时候编译就报错了, 因为 void inject(MainActivity mainActivity); 它里面接收的是MainActivity类型，显然注入LoginActivity类型是不允许的。
我们可能天真的认为，使用多态接收就可以了：

1
2
3
4
5
@Singleton
@Component(modules = {UserModule.class})
public interface UserComponet {
    void inject(Activity mainActivity);
}

还是编译错误, 这里应征了之前的结论:
Component的inject方法接收父类型参数，而调用时传入的是子类型对象则无法注入，也就是说无法使用多态方式进行注入。
那我们再接着看看能不能直接获取到Application呢?改写代码:

1
2
3
4
5
6
@ActivityScope
@Provides
TextView provideTextView(DemoApplication application) {
    TextView textView = new TextView(application);
    return textView;
}

编译报错了, 看样子不经过一点”处理”是不能直接获取到应用的application的, 这点”处理”我们稍后再说.

为Fragment注入对象

我们按照官方文档一步一步来就行.
1.首先需要对frament的宿主Activity进行一定的处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MainActivity extends AppCompatActivity implements HasSupportFragmentInjector {
    
    @Inject
    DispatchingAndroidInjector<Fragment> mFragmentInjector;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        AndroidInjection.inject(this);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    
    }
    
    @Override
    public AndroidInjector<Fragment> supportFragmentInjector() {
        return mFragmentInjector;
    }
}

和上面修改Application类似的步骤, 让MainActivity实现HasSupportFragmentInjector, 实现supportFragmentInjector方法, 然后需要注入一个DispatchingAndroidJnjector<Fragment>对象, 然后在supportFragmentInjector方法中将这个对象返回.

2.创建一个MainFragmentSubcomponent
和Activity类似的步骤, MainFragmentSubcomponent的代码如下:

1
2
3
4
5
6
@Subcomponent(modules = MainFragmentModule.class)
public interface MainFragmentSubcomponent extends AndroidInjector<MainFragment> {
    @Subcomponent.Builder
    abstract class Builder extends AndroidInjector.Builder<MainFragment> {
    }
}

3.创建一个BindMainFragmentModule
和Activity类似的步骤, BindMainFragmentModule的代码如下:

1
2
3
4
5
6
7
8
@Module(subcomponents = MainFragmentSubcomponent.class)
public abstract class BindMainFragmentModule {
    @Binds
    @IntoMap
    @FragmentKey(MainFragment.class)
    abstract AndroidInjector.Factory<? extends Fragment> bindMainFragmentInjectorFactory(
            MainFragmentSubcomponent.Builder builder);
}

4.安装BindMainFragmentModule
按照官方文档的说法, 我们可以把这个你的这个BindMainFragmentModule安装在你想要的位置, 比如另一个fragment的component中, 或者Activity的component中, 或者Application的component中, 取决于你自己. 但是相应的你需要生成相对应的HasFragmentInjector.因为我们这里的HasFragmentInjector是MainActivity, 所以我把它安装在Activity的component上, 代码如下:

1
2
3
4
5
@Subcomponent(modules = {MainActivityModule.class, BindMainFragmentModule.class})
public interface MainActivitySubcomponent extends AndroidInjector<MainActivity> {
    @Subcomponent.Builder
    abstract class Builder extends AndroidInjector.Builder<MainActivity> {}
}

5.修改fragment
最终, fragment的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class MainFragment extends Fragment {
    
    private static final String TAG = "MainFragment";
    
    @Inject
    FragmentUser mFragmentUser;
    
    public MainFragment() {
        // Required empty public constructor
    }
    
    @Override
    public void onAttach(Context context) {
        Log.d(TAG, "context = " + context);
        AndroidSupportInjection.inject(this);
        super.onAttach(context);
    }
    
    
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_blank, container, false);
    }
    
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        Log.d(TAG, "mFragmentUser = " + mFragmentUser);
    }
}

我们将程序跑起来, log打印如下:

1
2
D/MainFragment: context = me.mundane.daggerfragmentinjectdemo.activity.MainActivity@6db1066
D/MainFragment: mFragmentUser = me.mundane.daggerfragmentinjectdemo.bean.FragmentUser@b6c9a25

可见对Fragment的对象注入成功了.

简化对Fragment进行注入的步骤

也是和对Activity的简化的步骤类似.首先抛弃MainFragmentSubcomponent这个类, 然后改写BindMainFragmentModule这个类, 使用注解@ContributesAndroidInjector, 代码如下

1
2
3
4
5
6
@Module
public abstract class BindMainFragmentModule {
    
    @ContributesAndroidInjector(modules = MainFragmentModule.class)
    abstract MainFragment contributeMainFragmentInjector();
}

这样就行了, 跑起来的效果和上面是一样的.

如何使用一些全局性的对象

之前提到了, 想要获取到在activity的module中直接获取到应用的application需要一点处理, 这一小节就是讲这个.
有时候我们需要使用到一些全局性的对象, 比如Application, SharedPreferences, 和网络请求的一些全局对象等等.这时候需要怎么办呢?
首先需要用到@Component.Builder和@BindsInstance这两个注解, 如果不理解, 参考我之前写的这篇Dagger2 初探 (三)
改写AppComponent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Singleton
@Component(modules = {
        AppModule.class,
        BindYourActivityModule.class,
        BindMainActivityModule.class,
        AndroidSupportInjectionModule.class,
        AndroidInjectionModule.class
})
public interface AppComponent {
    void inject(DemoApplication application);
    
    @Component.Builder
    interface Builder {
        
        AppComponent build();
        
        @BindsInstance
        Builder application(Application application);
    }
}

然后再改写Application中的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class DemoApplication extends Application implements HasActivityInjector {
    
    @Inject
    DispatchingAndroidInjector<Activity> dispatchingActivityInjector;
    
    @Override
    public void onCreate() {
        super.onCreate();
        DaggerAppComponent.builder().application(this).build().inject(this);   
    }
    
    @Override
    public AndroidInjector<Activity> activityInjector() {
        return dispatchingActivityInjector;
    }
    
    
}

然后我们在AppModule中提供SharedPreferences对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Module
public abstract class AppModule {
    private static final String TAG = "AppModule";
    
    private static final String DATA_STORE = "DATA_STORE";
    
    @Singleton
    @Provides
    static SharedPreferences providePreferences(Application application) {
        SharedPreferences preferences =
                application.getSharedPreferences(DATA_STORE, Context.MODE_PRIVATE);
        Log.d(TAG, "preferences = " + preferences);
        return preferences;
    }
}

现在mvp的架构模式很流行, 所以我们试着来建立一个YourActivityPresenter, 里面注入一个SharedPreferences对象

1
2
3
4
5
6
7
8
9
10
11
12
public class YourActivityPresenter {
    SharedPreferences mSharedPreferences;
    
    @Inject
    public YourActivityPresenter(@NonNull SharedPreferences sharedPreferences) {
        mSharedPreferences = sharedPreferences;
    }
    
    public SharedPreferences getSharedPreferences() {
        return mSharedPreferences;
    }
}

然后在YourActivity注入这个YourActivityPresenter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class YourActivity extends AppCompatActivity {
    
    private static final String TAG = "YourActivity";
    
    @Inject
    User mUser;
    @Inject
    TextView mTv;
    @Inject
    YourActivityPresenter mPresenter;
    private FrameLayout mFl;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        AndroidInjection.inject(this);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_your);
        Log.d(TAG, "mUser = " + mUser);
        mFl = findViewById(R.id.fl);
    
        mTv.setText(mUser.name);
        mFl.addView(mTv);

        Log.d(TAG, "mPresenter = " + mPresenter);
        Log.d(TAG, "mPresenter.getSharedPreferences() = " + mPresenter.getSharedPreferences());
    }
}

打印的log:

1
2
3
D/AppModule: preferences = android.app.SharedPreferencesImpl@1bfa7fd
D/YourActivity: mPresenter = me.mundane.daggerfragmentinjectdemo.Presenter.YourActivityPresenter@b6c9a25
D/YourActivity: mPresenter.getSharedPreferences() = android.app.SharedPreferencesImpl@1bfa7fd

可以看到perferences已经注入成功了, 并且和AppModule中的perferences是同一个对象.其实也可以在Activity中直接注入这个perferences对象, dagger会自动帮我们找到在AppModule中提供SharedPreferences的方法, 从而注入SharedPreferences对象.如果想注入一个应用的Application对象, 就这么写:

1
2
3
4
5
6
7
8
9
10
11
12
@Module
public abstract class AppModule {
        
    @Singleton
    @Provides
    static Context provideApplicationContext(Application application) {
        return application;
    }
    
    ...
    
}

利用这个特点, 我们可以新建一个叫HttpModule的module, 然后将全局性的对象比如retrofit的service方法在这个module中, 听起来是不是挺不错的呢?

demo地址

https://github.com/mundane799699/AndroidProjects/tree/master/DaggerFragmentInjectDemo

0%