Hement：关于项目中的Dagger2的使用（三）

时间  2019-12-10
标签 hement 关于 项目 dagger2 dagger 使用 繁體版
原文   原文链接
  • 写在前面的话，要讲好这个Dagger2真的不是一件简单的事情
  • Dagger 1 :匕首 一个用于Android和Java的快速依赖注入。由SQUAR公司开发
  • Dagger 2:由谷歌公司接手开发 Dagger 2

依赖注入的原理

  • 首先记住：new 建立一个对象是有毒的；
  • 首先什么是依赖注入的原理：在软件工程领域中，依赖注入是用于实现控制反转的最多见的方式之一
  • 引用Martin Flower在解释介绍注入时使用的一部分代码来讲明这个问题
public class MovieLister {
    private MovieFinder finder;
    public MovieLister() {
        finder = new MovieFinderImpl();
    }
    public Movie[] moviesDirectedBy(String arg) {
        List allMovies = finder.findAll();
        for (Iterator it = allMovies.iterator(); it.hasNext();) {
            Movie movie = (Movie) it.next();
            if (!movie.getDirector().equals(arg)) it.remove();
        }
        return (Movie[]) allMovies.toArray(new Movie[allMovies.size()]);
    }
    ...
}
复制代码
  • MovieFinder
public interface MovieFinder {
    List findAll();
}
复制代码
  • 建立类MovieFinder 来提供须要的电影列表，moviesDirectedBy方法提供导演的名称来搜索电影，真正负责搜索电影的是MovieFinderImpl类，目前看起来状况不错，可是当咱们须要修改MovieFinderImpl的实现的方法，增长一个参数代表Movie的数据来源是那个数据库，咱们不只仅须要修改MovieFinderImpl类中的实现的代码，同时也要修改MovieLister类中建立的MovieFinderImpl对象。
  • 这就须要依赖注入要处理耦合，这种在MovieLister中建立MoviefinderImpl的方式，是的MovieLister不只仅依赖于MovieFinder这个接口，它还依赖于MovieListImpl这个实现，这种在一个类建立两位一个类的对象的代码，和硬编码以及硬编码数字同样，是一种致使耦合的坏味道，能够把这种坏味道称为硬初始化，咱们也该要像记住硬编码同样，new 建立一个对象是有毒的。
  • 以上带来的坏处有两点
  • 一、修改其实现的时候，也会修改建立地方的代码
  • 二、以上建立代码的方法不便于测试，也会致使代码的可读性变差（若是一段代码不便于测试，那么它必定不便于阅读），固然MVP这种模式也是解决这种问题的！
  • 这个时候就须要依赖注入了
  • 依赖注入的三种方式
  • 一、构造函数的注入
public class MovieLister {
    private MovieFinder finder;
    public MovieLister(MovieFinder finder) {
        this.finder = finder;
    }
    ...
}
复制代码
  • 二、set注入
public class MovieLister {
    s...
    public void setFinder(MovieFinder finder) {
        this.finder = finder;
    }
}
复制代码
  • 三、接口注入
  • 建立一个注入的接口
public interface InjectFinder {
    void injectFinder(MovieFinder finder);
}
复制代码
  • 以后实现这个接口
class MovieLister implements InjectFinder {
    ...
    public void injectFinder(MovieFinder finder) {
      this.finder = finder;
    }
    ...
}
复制代码
  • 依赖注入下降了依赖和被依赖类型的耦合，在修改被依赖的类型实现时候，不须要修改依赖类型的实现，同时对于依赖类型的测试更加方便

Hement中Dagger2的使用

  • 引入依赖
//dagger2
    api "com.google.dagger:dagger:2.15"
    compileOnly 'org.glassfish:javax.annotation:10.0-b28'
复制代码
  • 一、构建依赖：Dagger2中，这个负责提供依赖的组件被称为Module，@Module标识类型为module，并用@Provides标识提供依赖的方法。
  • ActivityModule
@Module
public class ActivityModule {
    private Activity mActivity;

    public ActivityModule(Activity activity) {
        mActivity = activity;
    }

    @Provides
    Activity provideActivity() {
        return mActivity;
    }

    @Provides
    @ActivityContext
    Context providesContext() {
        return mActivity;
    }
}

复制代码
  • ApplicationModule:提供远程Server，说通俗就是接口IRemoteServer,经过Retrofit获得，这个有个坏处，就是全部的接口请求信息都放在一个类了，后续应该根据项目的壮大，须要增长多个Server
@Module
public class ApplicationModule {

    protected final HementApplication mApplication;

    public ApplicationModule(HementApplication application) {
        mApplication = application;
    }

    @Provides
    Application provideApplication() {
        return mApplication;
    }

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


    @Provides
    @Singleton
    IRemoteServer provideRibotsService() {
        return IRemoteServer.Creator.newHementService();
    }
}
复制代码
  • 二、构建Injector
  • 有了提供依赖的组件，还须要把依赖注入到须要的对象中，链接提供依赖和消费依赖对象的组件被称为Injector. Dagger2中，咱们将其称为component。ActivityComponent代码以下：
@PerActivity
@Subcomponent(modules = ActivityModule.class)
public interface ActivityComponent {

    /**
     * 注入activity
     * @param mainActivity
     */
    void inject(MainActivity mainActivity);

    /**
     * 每个类都得单独的注入
     * @param baseActivity
     */
    void inject(NetWorkActivity baseActivity);

    void inject(SPreferencesActivity sPreferencesActivity);

    void inject(DBNetWorkDemoActivity dbDemoActivity);

    void inject(RxEventBusActivity rxEventBusActivity);

    void inject(RxPermissionsActivity rxPermissionsActivity);

    void inject(ImageLoaderActivity imageLoaderActivity);
}
复制代码
  • 注入的类或者对象所有是null的问题？
  • 缘由是必须是真正消耗依赖的类型MainActivity，而不能够写成其父类，好比Activity。由于Dagger2在编译时生成依赖注入的代码，会到inject方法的参数类型中寻找能够注入的对象，可是实际上这些对象存在于MainActivity，而不是Activity中。若是函数声明参数为Activity，Dagger2会认为没有须要注入的对象。当真正在MainActivity中建立Component实例进行注入时，会直接执行按照Activity做为参数生成的inject方法，致使全部注入都失败。
  • 同时提供了ApplicationComponent 来初始化和应用生命周期同样的类
@Singleton
@Component(modules = ApplicationModule.class)
public interface ApplicationComponent {

    @ApplicationContext
    Context context();
    Application application();

    IRemoteServer remoteServer();

    PreferencesHelper preferencesHelper();

    DatabaseHelper databaseHelper();

    DataManager dataManager();

    RxEventBus eventBus();
}

复制代码
  • 三、关于Scope和Qualifier的使用
  • Scope 的用法，@Scope是元注解，是用来标注自定义注解的
@Scope //  Scope 的用法，@Scope是元注解，是用来标注自定义注解的
@Retention(RetentionPolicy.RUNTIME)
public  @interface ConfigPersistent {
}
复制代码
  • 若是使用了ConfigPersistent注解的话,能够复用以前的依赖实例,在Hement中我使用在了NetWorkPresenter类中
@ConfigPersistent
public class NetWorkPresenter  extends BasePresenter<NetWorkView> {
    .....
}
复制代码
  • 同时为了获得Activity的复用,定义ConfigPersistentComponent：意思就是持久的Component，和App的生命周期同样
@ConfigPersistent
@Component(dependencies = ApplicationComponent.class)
public interface ConfigPersistentComponent {

    ActivityComponent activityComponent(ActivityModule activityModule);
}
复制代码
  • dependencies 依赖关系，一个 Component 依赖其余 Compoent 公开的依赖实例，用 Component 中的dependencies声明。
  • Component 和Subcomponent继承关系，一个 Component 继承（也能够叫扩展）某 Component 提供更多的依赖，SubComponent 就是继承关系的体现。
  • @Qualifier 限定符,ApplicationContext 标识是Application的Context对象
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface ApplicationContext {
}
复制代码
  • 在须要使用的地方，加上这个注解便可,好比是在DbOpenHelper中。
@Singleton
public class DbOpenHelper extends SQLiteOpenHelper {

    public static final String DATABASE_NAME = "hement.db";
    public static final int DATABASE_VERSION = 1;

    @Inject
    public DbOpenHelper(@ApplicationContext Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
}
复制代码

Hement中BaseActivity、BaseFragment关于Dagger2的封装

  • 在这里讲一种在BaseActivity中的封装，Hement中定义了一个持久的ConfigPersistentComponent,在BaseActivity定义一个LongSparseArray 具体原理请看 经常使用集合的原理分析
    • LongSparseArray是android里为<Long,Object> 这样的Hashmap而专门写的类,目的是提升效率，其核心是折半查找函数（binarySearch）。 SparseArray仅仅提升内存效率，而不是提升执行效率 因此也决定它只适用于android系统（内存对android项目有多重要）SparseArray不须要开辟内存空间来额外存储外部映射，从而节省内存。
private static final LongSparseArray<ConfigPersistentComponent> sComponentsMap = new LongSparseArray<>();
   @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //建立ActivityComponent，若是配置更改后调用缓存的ConfigPersistentComponent，则重用它。
        mActivityId = savedInstanceState != null ? savedInstanceState.getLong(KEY_ACTIVITY_ID) : NEXT_ID.getAndIncrement();

        ConfigPersistentComponent configPersistentComponent = sComponentsMap.get(mActivityId, null);
        if (null == configPersistentComponent) {
            Timber.tag(getClassName()).i("建立新的configPersistentComponent id=%d",mActivityId);
            configPersistentComponent = DaggerConfigPersistentComponent.builder()
                    .applicationComponent(HementApplication.get(this).getComponent())
                    .build();
            sComponentsMap.put(mActivityId, configPersistentComponent);
        }
        mActivityComponent = configPersistentComponent.activityComponent(new ActivityModule(this));

        //状态栏的颜色
        QMUIStatusBarHelper.setStatusBarLightMode(this);
    }

复制代码
  • 同时也定义了一个 AtomicLong对象：AtomicLong是做用是对长整形进行原子操做,线程安全.主要做用就是 NEXT_ID.getAndIncrement()获取一个自增加的Id。
private static final AtomicLong NEXT_ID = new AtomicLong(0);
复制代码

  • 在java1.8中新加入了一个新的原子类LongAdder，该类也能够保证Long类型操做的原子性，相对于AtomicLong，LongAdder有着更高的性能和更好的表现，能够彻底替代AtomicLong的来进行原子操做可是对 java的版本有要求，这里就不使用 LongAdder了java

  • 原子递增一个当前值。android

NEXT_ID.getAndIncrement()
复制代码
  • 完整的BaseActivity中的代码
package com.shiming.hement.ui.base;

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.util.LongSparseArray;
import android.support.v7.app.AppCompatActivity;

import com.shiming.base.ui.QMUIActivity;
import com.shiming.base.utils.QMUIDisplayHelper;
import com.shiming.base.utils.QMUIStatusBarHelper;
import com.shiming.hement.HementApplication;
import com.shiming.hement.injection.component.ActivityComponent;
import com.shiming.hement.injection.component.ConfigPersistentComponent;
import com.shiming.hement.injection.component.DaggerConfigPersistentComponent;
import com.shiming.hement.injection.module.ActivityModule;

import java.util.concurrent.atomic.AtomicLong;

import timber.log.Timber;

import static com.shiming.base.BaseApplication.getContext;

/**
 * <p>
 *  抽象应用程序中的其余活动必须实现的活动。它处理Dagger组件的建立，并确保ConfigPersistentComponent的实例跨配置更改存活。
 * </p>
 *
 * @author shiming
 * @version v1.0
 * @since 2018/11/28 10:04
 */

public class BaseActivity extends QMUIActivity {

    private static final String KEY_ACTIVITY_ID = "KEY_ACTIVITY_ID";
    /**
     * AtomicLong是做用是对长整形进行原子操做。 线程安全
     */
    private static final AtomicLong NEXT_ID = new AtomicLong(0);
    /**
     * java1.8中新加入了一个新的原子类LongAdder，该类也能够保证Long类型操做的原子性，
     * 相对于AtomicLong，LongAdder有着更高的性能和更好的表现，能够彻底替代AtomicLong的来进行原子操做
     * 可是对 java的版本有要求，这里就不使用 LongAdder了
     */
   // private static final LongAdder NEXT_ID = new LongAdder();

    /**
     * LongSparseArray是android里为<Long,Object> 这样的Hashmap而专门写的类,目的是提升效率，其核心是折半查找函数（binarySearch）。
     * SparseArray仅仅提升内存效率，而不是提升执行效率
     * ，因此也决定它只适用于android系统（内存对android项目有多重要）SparseArray不须要开辟内存空间来额外存储外部映射，从而节省内存。
      */
    // https://www.jianshu.com/p/a5f638bafd3b   经常使用集合的原理分析 Dagger does not support injection into private fields
    private static final LongSparseArray<ConfigPersistentComponent> sComponentsMap = new LongSparseArray<>();

    private long mActivityId;

    private ActivityComponent mActivityComponent;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //建立ActivityComponent，若是配置更改后调用缓存的ConfigPersistentComponent，则重用它。
        mActivityId = savedInstanceState != null ? savedInstanceState.getLong(KEY_ACTIVITY_ID) : NEXT_ID.getAndIncrement();

        ConfigPersistentComponent configPersistentComponent = sComponentsMap.get(mActivityId, null);
        if (null == configPersistentComponent) {
            Timber.tag(getClassName()).i("建立新的configPersistentComponent id=%d",mActivityId);
            configPersistentComponent = DaggerConfigPersistentComponent.builder()
                    .applicationComponent(HementApplication.get(this).getComponent())
                    .build();
            sComponentsMap.put(mActivityId, configPersistentComponent);
        }
        mActivityComponent = configPersistentComponent.activityComponent(new ActivityModule(this));

        //状态栏的颜色
        QMUIStatusBarHelper.setStatusBarLightMode(this);
    }
    protected String getClassName(){
        return this.getClass().getSimpleName();
    }
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putLong(KEY_ACTIVITY_ID, mActivityId);
    }

    /**
     * isChangingConfigurations()函数在是Api level 11（Android 3.0.x） 中引入的
     * 也就是用来检测当前的Activity是否 由于Configuration的改变被销毁了，而后又使用新的Configuration来建立该Activity。
     * 常见的案例就是 Android设备的屏幕方向发生变化，好比从横屏变为竖屏。
     */
    @Override
    protected void onDestroy() {
        //检查此活动是否处于销毁过程当中，以便用新配置从新建立。
        if (!isChangingConfigurations()) {
            Timber.tag(getClassName()).i("销毁的configPersistentComponent id=%d",mActivityId);
            sComponentsMap.remove(mActivityId);
        }
        super.onDestroy();
    }
    public ActivityComponent activityComponent() {
        return mActivityComponent;
    }

    @Override
    protected int backViewInitOffset() {
        return QMUIDisplayHelper.dp2px(getContext(), 100);
    }

}


复制代码

  • 未完待续 下一篇文章git

  • GitHub地址：Hement:持续更新中github

  • 最后说明几点数据库

    • 若是一段代码不便于测试，那么它必定不便于阅读），固然MVP这种模式也是解决这种问题的！
    • 依赖注入只是控制反转的一种实现方式。控制反转还有一种常见的实现方式称为依赖查找。
    • dependencies 依赖关系，一个 Component 依赖其余 Compoent 公开的依赖实例，用 Component 中的dependencies声明。
    • Component 和Subcomponent继承关系，一个 Component 继承（也能够叫扩展）某 Component 提供更多的依赖，SubComponent 就是继承关系的体现。
    • 在java1.8中新加入了一个新的原子类LongAdder，该类也能够保证Long类型操做的原子性，相对于AtomicLong，LongAdder有着更高的性能和更好的表现，能够彻底替代AtomicLong的来进行原子操做可是对 java的版本有要求，这里就不使用 LongAdder了

  • 谢谢一下博客对个人帮助api

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程