Android StudioAndroid-Dagger2

Dagger2-Android基本使用（一）

2019-08-06  本文已影响0人  因为我的心

一、前言：

gitHub 地址：https://github.com/lyyRunning/DaggerAndroid

1. Dagger2的缺点

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

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
  }
}

这样的确可以实现Android的依赖注入，但还有两个问题需要我们去面对：

  1. 类似的复制性的代码以后会很难维护。而且随着越来越多的开发者去复制粘贴这些代码，很少会有人知道它的作用。
  2. 更重要的是，它要求注射类型（FrombulationActivity）知道其注射器。 即使这是通过接口而不是具体类型完成的，它打破了依赖注入的核心原则：一个类不应该知道如何实现依赖注入。

瑕不掩瑜，虽然Dagger2在Android开发中有一些问题，但是它强大的功能依然使得开发人员趋之若鹜，无数的工程师们尝试弥补Dagger的这个问题，于是Dagger2-Android,基于Dagger2，应用于Android开发，由google开发的的拓展库应运而生。

二、基本使用：

1. 依赖

//一定要添加dagger2的annotationProcessor！
annotationProcessor 'com.google.dagger:dagger-compiler:2.11' 
compile 'com.google.dagger:dagger-android:2.11'
//使用支持的类库
compile 'com.google.dagger:dagger-android-support:2.11' 
annotationProcessor 'com.google.dagger:dagger-android-processor:2.11 '

注意：依赖的包单引号一定要成对。

2. 先看看Demo效果

image.png

结构如下：


image.png

可以看到，我们在MainActivity中需要通过依赖注入，获得4个对象，同时MainPresenter和MainModel也同样得到了实例化，我们先看下MVP这个架构中三个成员的代码：

三、详细代码相关：

1. MyApplication 代码：

我们先声明我们的Application类，然后记得一定要记得添加到清单文件中：

public class MyApplication  extends Application implements HasActivityInjector {

    @Inject
    DispatchingAndroidInjector<Activity> dispatchingAndroidInjector;

    @Override
    public void onCreate() {
        super.onCreate();
        //全局注入
        DaggerAppComponent.create().inject(this);

    }

    @Override
    public AndroidInjector<Activity> activityInjector() {
        return dispatchingAndroidInjector;
    }

}

我们在这里做了几件事：

  1. 实现HasActivityInjector接口
  2. 实现HasActivityInjector接口的activityInjector()方法
  3. 声明一个泛型为Activity的DispatchingAndroidInjector成员变量并在activityInjector()方法中返回

注意：我们要先写AppComponent接口，然后编译，才能让编译器自动生成DaggerAppComponent类。

2. AppComponent 代码：

/**
 * Created by luo on 2019/8/7.
 * 全局的快递员
 */
@Component(modules = {AndroidInjectionModule.class,
        AndroidSupportInjectionModule.class,
        AppModule.class})
public interface AppComponent {
    void inject(MyApplication application);
}

我们在这里做了几件事：

  1. 在这个Component中添加了 AndroidInjectionModule 和 AndroidSupportInjectionModule
  2. 同时添加了MainActivityModule 和 SecondActivityModule的依赖
  3. 声明注入方法inject，参数类型为MyApplication

3. MainACtivity 代码：

/**
 * Created by luo on 2019/8/7.
 * 整个 APP 统一的 Moudle，类似大箱子
 *
 */
@Module
public abstract class AppModule {

    /**
     * 引入MainActivityModule
     * @return
     */
    @ActivityScope
    @ContributesAndroidInjector(modules = MainActivityModule.class)
    abstract MainActivity contributeMainActivityInject();

    /**
     * 引入SecondActivityModule
     * @return
     */
    @ActivityScope
    @ContributesAndroidInjector(modules = SecondActivityModule.class)
    abstract SecondActivity contributeSecondActivityInject();

}

4. MainACtivity 代码：

public class MainActivity extends BaseActivity implements MainContract.View {

    @Inject
    String className;
    @Inject
    SharedPreferences sp;
    @Inject
    MainPresenter presenter;
    @Inject
    Student s1;
    @Inject
    Student s2;

    @BindView(R.id.tv_content)
    TextView tvContent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
        tvContent.setText(className + "\n" +
                s2.toString() + "\n" +
                s1.toString() + "\n" +
                sp.toString()
        );
    }


    public void gotoSecond(View view) {
        startActivity(new Intent(this, SecondActivity.class));
    }

    public void requestHttp(View view) {
        presenter.requestHttp();
    }

    /**
     * 返回数据
     *
     * @param message
     */
    public void onGetMessage(String message) {
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
    }
}

显然，从结果来看，我们根本没有在Activity中添加上文所述的模板代码：

//就是这些，模板代码
    ((SomeApplicationBaseType) getContext().getApplicationContext())
        .getApplicationComponent()
        .newActivityComponentBuilder()
        .activity(this)
        .build()
        .inject(this);

5. MainContract代码：

public interface MainContract {

    public interface View {

    }

    public interface Presenter {

    }

    public interface Model {

    }
}

6. MainContract代码：

public class MainPresenter implements MainContract.Presenter {

    private final MainActivity view;
    private final MainModel model;

    @Inject
    public MainPresenter(MainActivity view, MainModel model) {
        this.view = view;
        this.model = model;
    }

    public void requestHttp() {
        view.onGetMessage(model.returnMessage());
    }
}

7. MainModel代码：

public class MainModel implements MainContract.Model {

    @Inject
    public MainModel() {
    }

    public String returnMessage() {
        return "小明";
    }
}

和Dagger2的使用没有区别，其根本原理，都是通过@Inject注解，使Dagger2自动生成对应的工厂类，以提供MainPresenter和MainModel的实例。

8. MainActivityModule代码：

@Module
public class MainActivityModule {


    @Provides
    static String provideName() {
        return MainActivity.class.getName();
    }

    @Provides
    static SharedPreferences provideSp(MainActivity activity) {
        return activity.getSharedPreferences("def", Context.MODE_PRIVATE);
    }

    @Provides
    @ActivityScope
    static Student provideStudent() {
        return new Student();
    }
}

9. ActivityScope代码：

@Scope
@Retention(RUNTIME)
public @interface ActivityScope {
}

10. SecondActivity代码：

public class SecondActivity extends BaseActivity {

    @Inject
    String className;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        TextView tv = (TextView) findViewById(R.id.tv_content);
        tv.setText(className);
    }
}

和MainActivity基本一样，为了简便我们只注入了一个String，用来展示类名。

可以看到，我们依然没有添加冗余的模板代码，试想，一个app中这样几十个Activity容器都不需要这样的模板代码，我们的工作量确实减少了很多，同时，也达到了我们的目的，即：

依赖注入的核心原则：一个类不应该知道如何实现依赖注入。

实际上，我们只是在BaseActivity中，添加了这样一行代码，就实现了我们想要的效果

11. BaseActivity代码：

public class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        //一处声明，处处依赖注入
        AndroidInjection.inject(this);
        super.onCreate(savedInstanceState);
    }
}

接下来，让我们看看Dagger2-Android 的Module和Component怎么写

参考:谷歌官方Demo https://google.github.io/dagger//android.html

12. SecondActivityModule代码：

/**
 * Created by luo on 2019/8/7.
 * 对应每一个 Activity 的小箱子
 */
@Module
public class SecondActivityModule {
    @Provides
    static String provideName(){
        return SecondActivity.class.getName();
    }
}

好的，所有配置全部结束，我们使用ctrl+F9（Mac:cmd+F9）进行编译,运行app，依赖注入成功。

四、总结：

注意：除Activity之外，Dagger-Android还提供了Fragment，BroadCast,Service等其他组件的注入方式，详情请参照官方网站，本文不赘述。

https://google.github.io/dagger//android.html

简述如下：

  1. AppComponent 的module : AllActivity的Module，其负责所有ActivityModule实例的管理
  2. AppComponent 为 AllActivity 的 Module 的 subcomponent,管理了提供各activity所需对象的module
  3. MainActivityModule 负责提供所有对应Activity所需要对象实例的提供。

参考作者：却把清梅嗅
链接：https://www.jianshu.com/p/917bf39cae0d

上一篇下一篇

猜你喜欢

热点阅读