[Android]使用Dagger 2依赖注入 - DI介绍(翻译)


以下内容为原创,欢迎转载,转载请注明
来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/5092083.html

使用Dagger 2依赖注入 - DI介绍

原文:http://frogermcs.github.io/dependency-injection-with-dagger-2-introdution-to-di/

不久之前,在克拉科夫的 Tech Space 的 Google I/O 扩展中,我 展示 了一些关于使用Dagger 2来进行依赖注入。在准备期间我认识到有太多相关的东西需要去讲,无法用一打幻灯片就能覆盖到全部。但是它可以作为一个很好的进入点来开展更多这一系列主题-Android端的依赖注入。

在这一章中我会去通过之前所展示的来进行一个总结。可能并不是按部就班的 - 我认为现在是时候打破过去,使用一些原本我们不会使用或者不应该使用的方法来解决问题了。Jake Wharton 讲述 了相关历史(Guice, Dagger 1),Gregory Kick 也是(几乎有一半是关于Spring, Guice, Dagger 1)。我也会花几分钟的时间讲述以前的解决方式。但是此刻是时候开始了。

依赖注入

依赖注入的全部就是构建对象并在我们需要时把它们传入。我不会深入到它的学说(查看维基百科对DI的定义)。想象一个简单的类:UserManager,它依赖UserStoreApiService。如果没有使用依赖注入,这个类会看起来像这样:

UserStoreApiService 两者都是在UserManager类中构造和提供的:

class UserManager {

    private ApiService apiService;
    private UserStore userStore;

    //No-args constructor. Dependencies are created inside.
    public UserManager() {
        this.apiService = new ApiSerivce();
        this.userStore = new UserStore();
    }

    void registerUser() {/*  */}

}

class RegisterActivity extends Activity {

    private UserManager userManager;

    @Override
    protected void onCreate(Bundle b) {
        super.onCreate(b);
        this.userManager = new UserManager();
    }

    public void onRegisterClick(View v) {
        userManager.registerUser();
    }
}

为什么这些代码会给我们制造一些问题呢?让我们想象一下,你希望去改变UserStore的实现,用SharedPreferences来作为它的存储机制。它需要至少一个Context对象来创建一个实例,所以我们需要把它通过构造器传入到UserStore。它意味着UserManager类中也需要被修改来使用新的UserStore构造器。现在想象下有很多类使用了UserStore - 它们全部都需要被修改。

现在再来看下我们使用了依赖注入的UserManager类:

它的依赖是在类的外面创建和提供的:

class UserManager {

    private ApiService apiService;
    private UserStore userStore;

    //Dependencies are passed as arguments
    public UserManager(ApiService apiService, UserStore userStore) {
        this.apiService = apiService;
        this.userStore = userStore;
    }

    void registerUser() {/*  */}

}

class RegisterActivity extends Activity {

    private UserManager userManager;

    @Override
    protected void onCreate(Bundle b) {
        super.onCreate(b);
        ApiService api = ApiService.getInstance();
        UserStore store = UserStore.getInstance();

        this.userManager = new UserManager(api, store);
    }

    public void onRegisterClick(View v) {
        userManager.registerUser();
    }

}

现在在相似的情况下 - 我们改变它其中一个依赖的实现方式 - 我们不需要修改UserManager源代码。所有它的依赖都是从外面提供的,所以我们唯一一个需要修改的地方就是我们构造的UserStore对象。

所以使用依赖注入的优势是什么呢?

构造/使用 的分离

当我们构造类的实例 - 通常这些对象会在其它的地方被使用到,多亏这个方法让我们的代码更加模块化 - 所有的依赖都可以被很简单地替换掉(只要他们实现了相同的接口),并且不会与我们应用的逻辑产生冲突。想要改变DatabaseUserStoreSharedPrefsUserStore ?好的,只需要关心公开的API(与DatabaseUserStore相同的)或者实现相同的接口。

单元测试(Unit testing)

真正的单元测试假设一个类是可以完全被隔离进行测试的 - 不需要了解它的相关依赖。在实践中,基于我们的UserManager类,这里有一个我们应该编写的单元测试的例子:

public class UserManagerTests {

    UserManager userManager;

    @Mock
    ApiService apiServiceMock;
    @Mock
    UserStore userStoreMock;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        userManager = new UserManager(apiServiceMock, userStoreMock);
    }

    @After
    public void tearDown() {
    }

    @Test
    public void testSomething() {
        //Test our userManager here - all its dependencies are satisfied
    }
}

它可能只能使用DI - 多亏UserManager是完全独立于UserStoreApiService实现的。我们可以提供这些类的mock(简单地说 - mocks是一些拥有相同公开API的类,它在方法中不做任何事情并且/或者返回我们期望的值),然后在一个与所依赖的真实实现分离出来的环境下进行对UserManager的测试。

独立/并行开发

多亏模块化的代码(UserStore可以从UserManager中独立出来进行实现),它也可以非常方便在程序员间进行代码的分离。只需要UserStore相关的接口被每个人知道(尤其是在UserManager中使用到的UserStore中的公开方法)即可。剩下的(实现,逻辑)可以通过单元测试来测试。

依赖注入框架

依赖注入除了这些优点之外还有一些缺点。其中一个缺点是会产生很大的模版代码。想象一个简单的LoginActivity类,它在MVP(model-view-presenter)模式中被实现。这个类看起来就像这样:

唯一有问题的部分代码就是LoginActivityPresenter的初始化,如下:

public class LoginActivity extends AppCompatActivity {

    LoginActivityPresenter presenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        OkHttpClient okHttpClient = new OkHttpClient();
        RestAdapter.Builder builder = new RestAdapter.Builder();
        builder.setClient(new OkClient(okHttpClient));
        RestAdapter restAdapter = builder.build();
        ApiService apiService = restAdapter.create(ApiService.class);
        UserManager userManager = UserManager.getInstance(apiService);

        UserDataStore userDataStore = UserDataStore.getInstance(
                getSharedPreferences("prefs", MODE_PRIVATE)
        );

        //Presenter is initialized here
        presenter = new LoginActivityPresenter(this, userManager, userDataStore);
    }
}

它看起来不太友好,不是吗?

这就是DI框架需要解决的问题。相同功能的代码看起来就像这样:

public class LoginActivity extends AppCompatActivity {

    @Inject
    LoginActivityPresenter presenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //Satisfy all dependencies requested by @Inject annotation
        getDependenciesGraph().inject(this);
    }
}

简单多了,对吧?当然DI框架没有地方可以获取到对象 - 他们仍然需要在我们代码的某个地方进行初始化和配置。但是对象构建从使用中分离出来了(实质上这是DI模式的准则)。DI框架关心怎么样去把它们联系在一起(怎么在对象被需要时分配给它们)。

未完待续

我上面所有描述的东西都是使用Dagger 2的简单的背景 - 用于Android和Java开发的依赖注入框架。在下一章我将尝试讲解所有Dagger 2的API。如果你等不急可以尝试我的Github client example,它建立在Dagger 2之上并且会用在我的展示中。一个小提示 - @Module@Component就是构建/提供对象的地方。@Inject是我们对象使用到的地方。

More detailed description - soon.

参考

作者

Miroslaw Stanek

Head of Mobile Development @ Azimo

[Android]使用Dagger 2依赖注入 - DI介绍(翻译):

http://www.cnblogs.com/tiantianbyconan/p/5092083.html

[Android]使用Dagger 2依赖注入 - API(翻译):

http://www.cnblogs.com/tiantianbyconan/p/5092525.html

[Android]使用Dagger 2依赖注入 - 自定义Scope(翻译):

http://www.cnblogs.com/tiantianbyconan/p/5095426.html

[Android]使用Dagger 2依赖注入 - 图表创建的性能(翻译):

http://www.cnblogs.com/tiantianbyconan/p/5098943.html

[Android]Dagger2Metrics - 测量DI图表初始化的性能(翻译):

http://www.cnblogs.com/tiantianbyconan/p/5193437.html

[Android]使用Dagger 2进行依赖注入 - Producers(翻译):

http://www.cnblogs.com/tiantianbyconan/p/6234811.html

[Android]在Dagger 2中使用RxJava来进行异步注入(翻译):

http://www.cnblogs.com/tiantianbyconan/p/6236646.html

[Android]使用Dagger 2来构建UserScope(翻译):

http://www.cnblogs.com/tiantianbyconan/p/6237731.html

[Android]在Dagger 2中Activities和Subcomponents的多绑定(翻译):

http://www.cnblogs.com/tiantianbyconan/p/6266442.html

时间: 2024-10-05 17:06:36

[Android]使用Dagger 2依赖注入 - DI介绍(翻译)的相关文章

[Android]使用Dagger 2依赖注入 - API(翻译)

以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/5092525.html 使用Dagger 2依赖注入 - API 原文:http://frogermcs.github.io/dependency-injection-with-dagger-2-the-api/ 这章是展示使用Dagger 2在Android端实现依赖注入的系列中的一部分.今天我会探索Dagger 2的基础并且学习这个依赖注入框架的所有的API

[Android]使用Dagger 2依赖注入 - 图表创建的性能(翻译)

以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/5098943.html 使用Dagger 2依赖注入 - 图表创建的性能 原文:http://frogermcs.github.io/dagger-graph-creation-performance/ #PerfMatters - 最近非常流行标签,尤其在Android世界中.不管怎样,apps只需要正常工作就可以的时代已经过去了.现在所有的一切都应该是令人愉

[Android]使用Dagger 2依赖注入 - 自定义Scope(翻译)

以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/5095426.html 使用Dagger 2依赖注入 - 自定义Scope 原文:http://frogermcs.github.io/dependency-injection-with-dagger-2-custom-scopes/ 这章是展示使用Dagger 2在Android端实现依赖注入的系列中的一部分.今天我会花点时间在自定义Scope(作用域)上面

[Android]使用Dagger 2进行依赖注入 - Producers(翻译)

以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/6234811.html 使用Dagger 2进行依赖注入 - Producers 原文:http://frogermcs.github.io/dependency-injection-with-dagger-2-producers/ 本文是在Android中使用Dagger 2框架进行依赖注入的系列文章中的一部分.今天我们将探索下Dagger Producers

[Android]使用Dagger 2来构建UserScope(翻译)

以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/6237731.html 使用Dagger 2来构建UserScope 原文:http://frogermcs.github.io/building-userscope-with-dagger2/ 在Dagger 2中自定义scopes可以在不寻常存活时间(与Application和界面生命周期不同的)的依赖上给我带来更好的控制.但是在Android app中正确

Android 使用dagger2进行依赖注入(基础篇)

0. 前言 Dagger2是首个使用生成代码实现完整依赖注入的框架,极大减少了使用者的编码负担,本文主要介绍如何使用dagger2进行依赖注入.如果你不还不了解依赖注入,请看这一篇. 1. 简单的依赖注入 首先我们构建一个简单Android应用.我们创建一个UserModel,然后将它显示到TextView中.这里的问题是,在创建UserModel的时候,我们使用了前文所说的hard init.一旦我们的UserModel的创建方式发生了改变(比如需要传入Context对象到构造函数),我们就需

控制反转(IoC)与依赖注入(DI)

1.控制反转(Inversion of Control)与依赖注入(Dependency Injection) 控制反转即IoC (Inversion of Control),它把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配和管理.所谓的"控制反转"概念就是对组件对象控制权的转移,从程序代码本身转移到了外部容器. IoC是一个很大的概念,可以用不同的方式来实现.其主要实现方式有两种:<1>依赖查找(Dependency Lookup):容器提

[Android]在Dagger 2中使用RxJava来进行异步注入(翻译)

以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/6236646.html 在Dagger 2中使用RxJava来进行异步注入 原文:http://frogermcs.github.io/async-injection-in-dagger-2-with-rxjava 几星期前我写了一篇关于在Dagger 2中使用Producers进行异步注入的文章.在后台线程中执行对象的初始化又一个很好的优势 - 它负责实时(每

[Android]在Dagger 2中Activities和Subcomponents的多绑定(翻译)

以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/6266442.html 在Dagger 2中Activities和Subcomponents的多绑定 原文:http://frogermcs.github.io/activities-multibinding-in-dagger-2 几个月前,在MCE^3会议中,Gregory Kick在他的演讲中展示了一个提供Subcomponents(比如,为Activit