Dagger2 入门实战

最新推荐文章于 2024-05-06 03:45:38 发布

hofe

最新推荐文章于 2024-05-06 03:45:38 发布

阅读量239

点赞数

分类专栏： #安卓文章标签： android 安卓 dagger

本文链接：https://blog.csdn.net/qq_41011723/article/details/106916931

版权

#安卓专栏收录该内容

1 篇文章 0 订阅

订阅专栏

看了网上很多篇关于Dagger2的入门文章，说真的对新手而言很难看懂，由于自己也是刚学习Dagger2，所以这篇文章站在初学者的角度编写完成。

参考如下文章：https://www.jianshu.com/p/c7caadaf28af

简单依赖

首先，先来看看为引入Dagger2之前，我们是在怎么构造一个对象依赖的。

定义SimpleA、SimpleB对象

public class SimpleA {

    private String name;

    public SimpleA(){

    }

    public void print(){
        System.out.println("Simple A 被调用了");
    }
}

public class SimpleB {

    SimpleA simpleA;

    public SimpleB(){
    }

    public SimpleB(SimpleA a){
        this.simpleA = a;
    }

    public SimpleA getSimpleA() {
        return simpleA;
    }
}

Simple在其它类中被依赖

public class ExSimpleAActivity extends AppCompatActivity {

    SimpleA simpleA;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ex_simplea_activity);

        simpleA = new SimpleA();
    }
}

使用dagger2之后

先在需要调用的注入的类（container）中，使用@Inject 代替new SimpleA()

public class ExSimpleAActivity extends AppCompatActivity {

    @Inject 
    SimpleA simpleA;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ex_simplea_activity);

        simpleA.print();
    }
}

将new 对象替换成了@inject注解，当然这样还是不行的，在Spring中用注解也是需要在bean.xml中配置的对吧，这里也一样。有两种解决方案

方案一：在类中的构造函数上加注解@Inject

public class SimpleA {

    private String name;
    
    @Inject		// 注意这儿
    public SimpleA(){

    }

    public void print(){
        System.out.println("Simple A 被调用了");
    }
}

@Component
public interface SimpleAComponent {
    SimpleA getSimpleA();
}

public class ExSimpleAActivity extends AppCompatActivity {

    @Inject
    SimpleA simpleA;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ex_simplea_activity);
        simpleA = DaggerSimpleAComponent.create().getSimpleA();
        simpleA.print();
    }
}

方案二：添加一个Module

public class SimpleA {

    private String name;
    
    // @Inject	注意这儿可以没有
    public SimpleA(){

    }

    public void print(){
        System.out.println("Simple A 被调用了");
    }
}

@Module
public class SimpleAModule {
    
    @Provides
    SimpleA providerSimpleA(){
        return new SimpleA();
    }
}

@Component(modules = SimpleAModule.class)	// 注意传入的是Module
public interface SimpleAComponent {
//    SimpleA getSimpleA();

    void injectSimpleAActivity(ExSimpleAActivity simpleAActivity);
}

public class ExSimpleAActivity extends AppCompatActivity {

    @Inject
    SimpleA simpleA;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ex_simplea_activity);
        DaggerSimpleAComponent.create().injectSimpleAActivity(this);
        simpleA.print();
    }
}

这部分表示了一个类可以通过在构造方法上加注解@Inject或在Module中提供实例的方式来注入到另一个类中，并通过对应的Dagger**Component来获取。第二种方案主要用于引入第三方库时无法修改源代码，故需要在Module中提供实例。

多层依赖

当需要依赖SimpleB的时候，它可能又依赖SimpleA，在以前的代码中就是下面这样

public class MainActivity extends AppCompatActivity {
    ...
	SimpleA a = new SimpleA();
	SimpleB b = new SimpleB(a)
    ...
}

所以这时候在A Module中也需要提供B 的实例。也有两种方案：

方案一：如果已经有定义了依赖SimpleA的Module直接include即可，没有则也需要在这里提供

@Module(includes = SimpleAModule.class)
public class SimpleBModule {


    @Provides
    public SimpleB provideSimpleB(SimpleA a){
        return new SimpleB(a);
    }

//	  如果没有提供SimpleA()的module
//    @Provides
//    public SimpleA providerSimpleA(){
//        return new SimpleA();
//    }
}

对应Activity

public class ExSimpleActivity extends AppCompatActivity {

    @Inject
    SimpleA simpleA;

    @Inject
    SimpleB simpleB;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ex_simple_activity);

        DaggerSimpleComponent.builder()
                .simpleAModule(new SimpleAModule())
                .simpleBModule(new SimpleBModule())
                .build()
                .injectSimpleACtivity(this);

//        DaggerSimpleComponent.create().injectSimpleACtivity(this);
        
        Log.v("simpleA", String.valueOf(simpleA.hashCode()));
        Log.v("simpleB", String.valueOf(simpleB.hashCode()));
        Log.v("simpleB.A", String.valueOf(simpleB.getSimpleA().hashCode()));
    }
}

这里插一句，会发现DaggerSimpleComponent的写法怎么不一样的，其实create方法中的实现就是builder，所以两种是一样的。同时，如果需要依赖两个类的话，在component中需要加载他们的module。

@Component(modules = {SimpleAModule.class, SimpleBModule.class})
public interface SimpleComponent {

    void injectSimpleACtivity(ExSimpleActivity simpleActivity);
}

方案二

@Module
public class SimpleBModule {

    public SimpleA simpleA;

    public SimpleBModule(SimpleA A){	// 构造传参
        this.simpleA = A;
    }

    @Provides
    public SimpleB provideSimpleB(){
        return new SimpleB(simpleA);
    }
}

public class ExSimpleActivity extends AppCompatActivity {

    @Inject
    SimpleA simpleA;

    @Inject
    SimpleB simpleB;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ex_simple_activity);

        DaggerSimpleComponent.builder()
                .simpleAModule(new SimpleAModule())
                .simpleBModule(new SimpleBModule(simpleA))
                .build()
                .injectSimpleACtivity(this);

//        DaggerSimpleComponent.create().injectSimpleACtivity(this);

        Log.v("simpleA", String.valueOf(simpleA.hashCode()));
        Log.v("simpleB", String.valueOf(simpleB.hashCode()));
        Log.v("simpleB.A", String.valueOf(simpleB.getSimpleA().hashCode()));
    }
}

Singleton问题

局部单例

通过打印它们的hashcode发现即使在SimpleBModule中include了SimpleAModule，但还是产生了两个SimpleA

修改下SimpleBModule、SimpleAModule。由于我们的目的是B中的A是要成为单例的，所以将SimpleAModule注解为Singleton即可，注意@Module上不要加！

@Module
public class SimpleAModule {

    @Singleton
    @Provides
    public SimpleA providerSimpleA(){
        return new SimpleA();
    }
}

@Module(includes = SimpleAModule.class)
public class SimpleBModule {

    @Provides
    public SimpleB provideSimpleB(SimpleA a){
        return new SimpleB(a);
    }
}

在对应component中也需要添加上@Singleton

@Singleton
@Component(modules = {SimpleAModule.class, SimpleBModule.class})
public interface SimpleComponent {

    void injectSimpleACtivity(ExSimpleActivity simpleActivity);
}

可以看到，传入B的A也是同一个对象。这是因为B中的A本质上也是由SimpleAModule提供的。

那局部单例和全局单例又是怎么回事呢？我们创建一个新的活动来看看。

在SimpleAComponent注入两个活动，分别在两个活动中@Inject一个SimpleA实例，启动活动A的时候跳转到活动B，打印出各自SimpleA的hashcode

@Singleton
@Component(modules = SimpleAModule.class)
public interface SimpleAComponent {
//    SimpleA getSimpleA();

    void injectSimpleAActivity(ExSimpleAActivity simpleAActivity);

    void injectSimpleAActivity(ExSimpleBActivity simpleBActivity);
}

可以看到，两个活动中的SimpleA不一样（一个活动中多次Inject是一样的）。那么这就是局部单例，当Component中注入了不同的类，他们产生的实例也不相同

全局单例

那么如何做到全局单例？

先来看看SimpleBActivity中的代码，create是可以用Builder替代的，也就是说在这个类中其实会生成一个SimpleAComponent对象，然后再注入。

protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ex_simpleb_activity);

        DaggerSimpleAComponent.create().injectSimpleBActivity(this);
        //SimpleAComponent build = DaggerSimpleAComponent.builder().simpleAModule(new SimpleAModule()).build();
        //build.injectSimpleBActivity(this);
        
        Log.v("simpleA 1", String.valueOf(a1.hashCode()));
    }

所以由于Component在两个activity中被各自被实例化一次,，导致产生了两个不同的对象，所以我们需要做到让Component能够实现单例。Android中，我们知道在整个App生命周期中都只有一个Appclication实例，所以在Application中获得一个唯一的component实例，用它来提供我们需要的单例。

新建一个MyApplication

public class MyApplication extends Application {

    private SimpleAComponent singleSimpleAComponent;

    @Override
    public void onCreate() {
        super.onCreate();
        context = getApplicationContext();

        singleSimpleAComponent = DaggerSimpleAComponent.builder()
                .simpleAModule(new SimpleAModule())
                .build();
    }

    public SimpleAComponent getSingleSimpleAComponent(){
        return singleSimpleAComponent;
    }
}

修改A、B两个活动的代码，Component从Application中获取。

protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ex_simplea_activity);
//        DaggerSimpleAComponent.create().injectSimpleAActivity(this);
        SimpleAComponent singleSimpleAComponent = ((MyApplication) getApplication()).getSingleSimpleAComponent();
        singleSimpleAComponent.injectSimpleAActivity(this);

        Log.v("simpleA", String.valueOf(simpleA.hashCode()));

        Intent intent = new Intent(this, ExSimpleBActivity.class);
        startActivity(intent);
    }

protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.ex_simpleb_activity);

//        DaggerSimpleAComponent.create().injectSimpleBActivity(this);
        //SimpleAComponent build = DaggerSimpleAComponent.builder().simpleAModule(new SimpleAModule()).build();
        //build.injectSimpleBActivity(this);
        SimpleAComponent singleSimpleAComponent = ((MyApplication) getApplication()).getSingleSimpleAComponent();
        singleSimpleAComponent.injectSimpleBActivity(this);

        Log.v("simpleA 1", String.valueOf(a1.hashCode()));
    }

这时候句可以看到全局单例了

区分@Provides 方法

当有Context需要注入时，Dagger2就会在Module中查找返回类型为Context的方法。但是，当Container需要依赖两种不同的Context时，你就需要写两个@Provides方法，而且这两个@Provides方法都是返回Context类型，靠判别返回值的做法就行不通了。这就可以使用@Named注解来区分

//定义Module
@Module
public class ActivityModule{
	private Context mContext    ;
	private Context mAppContext = App.getAppContext();	// 另一种Context
    
    public ActivityModule(Context context) {
        mContext = context;		// 通过传参来构造
    }
    
    @Named("Activity")		//@ContextLife("Activity")
    @Provides
    public Context provideContext(){  
        return mContext;
    }
    
    @Named("Application")	//@ContextLife ("Application")
    @Provides
    public Context provideApplicationContext (){
        return mAppContext;
    }
}

//定义Component
@Component(modules={ActivityModule.class}) 
interface ActivityComponent{   
    void inject(Container container);   
}

//定义Container
class Container extends Fragment{
    @Named("Activity") 		//@ContextLife("Activity")
    @Inject
    Context mContext; 

    @Named("Application") 	//@ContextLife ("Application")
    @Inject
    Context mAppContext; 
    ...
    public void init(){
         DaggerActivityComponent.
     .activityModule(new ActivityModule(getActivity()))
     .inject(this);
     }
}