Android で Dagger を使う（その1）

• Android で Dagger を使う（その1）
• Android で Dagger を使う（その2 : subcomponent）
• Android で Dagger を使う（その3 : Android Support）

Dependency Injection

API にアクセスするための interface が用意されているとします。

view plainprint?

1. interface ApiService {  
2.    ...  
3. }  

interface ApiService { ... } この interface の実装クラスが何であるかや、どうインスタンス化するかを利用側（例えば Activity）では意識したくありません。
ApiService をどうインスタンス化するかは Activity 側の責務ではないからです。

view plainprint?

1. public class MainActivity extends AppCompatActivity {  
2.   
3.     // どうやってインスタンス化するかは知りたくない  
4.     ApiService service;  
5. }  

public class MainActivity extends AppCompatActivity { // どうやってインスタンス化するかは知りたくない ApiService service; } 必要としているもの（dependency）を内部で生成するのではなく、外部から注入（injection）する手法が dependency injection（DI）です。

外部から注入すると

• テストなど、状況に応じて注入するインスタンスを切り替えられる
• インスタンス化の方法が変わっても利用側は影響をうけない

などの利点があります。

外部から注入する一番簡単な方法は、コンストラクタで渡すことです。 しかし Activity はフレームワークが生成するため、この方法はとれません。

↓これはできない

view plainprint?

1. public class MainActivity extends AppCompatActivity {  
2.   
3.     ApiService service;  
4.   
5.     public MainActivity(ApiService service) {  
6.         this.service = service;  
7.     }  
8. }  

public class MainActivity extends AppCompatActivity { ApiService service; public MainActivity(ApiService service) { this.service = service; } } そこで、インスタンス化を責務とするクラス（例えば Factory など）を用意して、Activity からはそれを使ってインスタンスを取得するようにします。

view plainprint?

1. public class MainActivity extends AppCompatActivity {  
2.   
3.     ApiService service;  
4.   
5.     @Override  
6.     protected void onCreate(Bundle savedInstanceState) {  
7.         super.onCreate(savedInstanceState);  
8.         service = ApiServiceFactory.create();  
9.   
10.         setContentView(R.layout.activity_main);  
11.     }  
12. }  

public class MainActivity extends AppCompatActivity { ApiService service; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); service = ApiServiceFactory.create(); setContentView(R.layout.activity_main); } }

view plainprint?

1. public class ApiServiceFactory {  
2.   
3.     private static ApiService service;  
4.   
5.     @NonNull  
6.     public synchronized static ApiService create() {  
7.         if (service == null) {  
8.             final Retrofit retrofit = ...;  
9.             return retrofit.create(ApiService.class);  
10.         }  
11.         return service;  
12.     }  
13. }  

public class ApiServiceFactory { private static ApiService service; @NonNull public synchronized static ApiService create() { if (service == null) { final Retrofit retrofit = ...; return retrofit.create(ApiService.class); } return service; } } Retrofit では毎回インスタンスを生成するとコストが高いので Singleton にします。

この方法には以下のような欠点があります。

• 外部から注入したいクラスごとに同じようなFactoryクラスが必要
• どの Factory を使うかを結局知っていなくてはいけない

Dagger を使うと、これらの欠点を解消して DI を行うことができます。

Dagger

Dagger (https://google.github.io/dagger) は Java で DI を行うことをサポートするライブラリです。

「DI = Dagger を使うこと」ではありません。上記で書いたように Dagger を使わなくても DI はできます。

view plainprint?

1. dependencies {  
2.     compile 'com.google.dagger:dagger:2.11'  
3.     annotationProcessor 'com.google.dagger:dagger-compiler:2.11'  
4. }  

dependencies { compile 'com.google.dagger:dagger:2.11' annotationProcessor 'com.google.dagger:dagger-compiler:2.11' } Dagger では Component と Module が主な構成要素です。

Component は injector です。inject される側（例だと Activity）は、Component を経由して必要なインスタンス（例だと ApiService のインスンタンス）をもらいます。

Module の責務はインスタンスの生成です。そのため、Module には inject するもの（例だと ApiService）をどうインスタンス化するかを定義します。

Module 用のクラスには @Module アノテーションをつけます。
inject するもの（ApiService のインスタンス）を返すメソッドを用意し、@Provides アノテーションをつけます。

view plainprint?

1. @Module  
2. public class ApiModule {  
3.       
4.     @Provides  
5.     public ApiService provideApiService() {  
6.         final Retrofit retrofit = ...;  
7.         return retrofit.create(ApiService.class);  
8.     }  
9. }  

@Module public class ApiModule { @Provides public ApiService provideApiService() { final Retrofit retrofit = ...; return retrofit.create(ApiService.class); } } 慣例で Module 用のクラスには Module suffix、@Provides をつけるメソッドには provide prefix をつけることが多いです。

Component は abstract class か interface で用意します。
@Component アノテーションをつけ、modules 属性に必要な Module クラスを指定します。

view plainprint?

1. @Component(modules = ApiModule.class)  
2. public interface AppComponent {  
3.     ApiService apiService();  
4. }  

@Component(modules = ApiModule.class) public interface AppComponent { ApiService apiService(); } ビルドすると Component の実装クラスが生成されます。名前は Dagger + Component クラス名になるので、この場合だと DaggerAppComponent クラスが自動生成されます。

view plainprint?

1. public final class DaggerAppComponent implements AppComponent {  
2.   private Provider<ApiService> provideApiServiceProvider;  
3.   
4.   private DaggerAppComponent(Builder builder) {  
5.     assert builder != null;  
6.     initialize(builder);  
7.   }  
8.   
9.   public static Builder builder() {  
10.     return new Builder();  
11.   }  
12.   
13.   public static AppComponent create() {  
14.     return new Builder().build();  
15.   }  
16.   
17.   @SuppressWarnings("unchecked")  
18.   private void initialize(final Builder builder) {  
19.   
20.     this.provideApiServiceProvider = ApiModule_ProvideApiServiceFactory.create(builder.apiModule);  
21.   }  
22.   
23.   @Override  
24.   public ApiService apiService() {  
25.     return provideApiServiceProvider.get();  
26.   }  
27.   
28.   public static final class Builder {  
29.     private ApiModule apiModule;  
30.   
31.     private Builder() {}  
32.   
33.     public AppComponent build() {  
34.       if (apiModule == null) {  
35.         this.apiModule = new ApiModule();  
36.       }  
37.       return new DaggerAppComponent(this);  
38.     }  
39.   
40.     public Builder apiModule(ApiModule apiModule) {  
41.       this.apiModule = Preconditions.checkNotNull(apiModule);  
42.       return this;  
43.     }  
44.   }  
45. }  

public final class DaggerAppComponent implements AppComponent { private Provider<ApiService> provideApiServiceProvider; private DaggerAppComponent(Builder builder) { assert builder != null; initialize(builder); } public static Builder builder() { return new Builder(); } public static AppComponent create() { return new Builder().build(); } @SuppressWarnings("unchecked") private void initialize(final Builder builder) { this.provideApiServiceProvider = ApiModule_ProvideApiServiceFactory.create(builder.apiModule); } @Override public ApiService apiService() { return provideApiServiceProvider.get(); } public static final class Builder { private ApiModule apiModule; private Builder() {} public AppComponent build() { if (apiModule == null) { this.apiModule = new ApiModule(); } return new DaggerAppComponent(this); } public Builder apiModule(ApiModule apiModule) { this.apiModule = Preconditions.checkNotNull(apiModule); return this; } } } （AppComponent や ApiModule の実装を変えると DaggerAppComponent の実装も変わります）


Module の @Provides がついたメソッドからは、対応する Factory が自動生成されます。例えば ApiModule の provideApiService() メソッドに対しては ApiModule_ProvideApiServiceFactory が自動生成されます。

view plainprint?

1. public final class ApiModule_ProvideApiServiceFactory implements Factory<ApiService> {  
2.   private final ApiModule module;  
3.   
4.   public ApiModule_ProvideApiServiceFactory(ApiModule module) {  
5.     assert module != null;  
6.     this.module = module;  
7.   }  
8.   
9.   @Override  
10.   public ApiService get() {  
11.     return Preconditions.checkNotNull(  
12.         module.provideApiService(), "Cannot return null from a non-@Nullable @Provides method");  
13.   }  
14.   
15.   public static Factory<ApiService> create(ApiModule module) {  
16.     return new ApiModule_ProvideApiServiceFactory(module);  
17.   }  
18. }  

public final class ApiModule_ProvideApiServiceFactory implements Factory<ApiService> { private final ApiModule module; public ApiModule_ProvideApiServiceFactory(ApiModule module) { assert module != null; this.module = module; } @Override public ApiService get() { return Preconditions.checkNotNull( module.provideApiService(), "Cannot return null from a non-@Nullable @Provides method"); } public static Factory<ApiService> create(ApiModule module) { return new ApiModule_ProvideApiServiceFactory(module); } } DaggerAppComponent はこの Factory を介して ApiModule の provideApiService() を呼び出し、ApiService のインスタンスを取得します。



AppComponent のインスタンスは自動生成される DaggerAppComponent.Builder を使って取得します。

view plainprint?

1. final AppComponent appComponent = DaggerAppComponent.builder()  
2.         .apiModule(new ApiModule())  
3.         .build();  

final AppComponent appComponent = DaggerAppComponent.builder() .apiModule(new ApiModule()) .build(); 必要な Module が全てデフォルトコンストラクタで生成できる、もしくは @Provides がつけられたメソッドが全て static の場合は create() メソッドも用意されます。

view plainprint?

1. final AppComponent appComponent = DaggerAppComponent.create();  

final AppComponent appComponent = DaggerAppComponent.create();

Android では Application クラスで Component を生成して保持しておくことが多いです。

view plainprint?

1. public class MyApplication extends Application {  
2.   
3.     private AppComponent appComponent;  
4.   
5.     @Override  
6.     public void onCreate() {  
7.         super.onCreate();  
8.   
9.         appComponent = DaggerAppComponent.builder()  
10.                 .apiModule(new ApiModule())  
11.                 .build();  
12.     }  
13.   
14.     public AppComponent getAppComponent() {  
15.         return appComponent;  
16.     }  
17. }  

public class MyApplication extends Application { private AppComponent appComponent; @Override public void onCreate() { super.onCreate(); appComponent = DaggerAppComponent.builder() .apiModule(new ApiModule()) .build(); } public AppComponent getAppComponent() { return appComponent; } } これで MainActivity では AppComponent の apiService() から ApiService インスタンスをもらえるようになりました。

view plainprint?

1. public class MainActivity extends AppCompatActivity {  
2.   
3.     ApiService service;  
4.   
5.     @Override  
6.     protected void onCreate(Bundle savedInstanceState) {  
7.         super.onCreate(savedInstanceState);  
8.         service = ((MyApplication) getApplication())  
9.                 .getAppComponent()  
10.                 .apiService();  
11.   
12.         setContentView(R.layout.activity_main);  
13.     }  
14. }  

public class MainActivity extends AppCompatActivity { ApiService service; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); service = ((MyApplication) getApplication()) .getAppComponent() .apiService(); setContentView(R.layout.activity_main); } } Activity が自分で field に代入する書き方は field が増えると冗長になってきます。

view plainprint?

1. public class MainActivity extends AppCompatActivity {  
2.   
3.     ApiService apiService;  
4.     HogeService hogeService;  
5.     FugaService fugaService;  
6.   
7.     @Override  
8.     protected void onCreate(Bundle savedInstanceState) {  
9.         super.onCreate(savedInstanceState);  
10.         final AppComponent appComponent = ((MyApplication) getApplication())  
11.                 .getAppComponent();  
12.         apiService = appComponent.apiService();  
13.         hogeService = appComponent.hogeService();  
14.         fugaService = appComponent.fugaService();  
15.   
16.         setContentView(R.layout.activity_main);  
17.     }  
18. }  

public class MainActivity extends AppCompatActivity { ApiService apiService; HogeService hogeService; FugaService fugaService; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); final AppComponent appComponent = ((MyApplication) getApplication()) .getAppComponent(); apiService = appComponent.apiService(); hogeService = appComponent.hogeService(); fugaService = appComponent.fugaService(); setContentView(R.layout.activity_main); } } そこで、field に代入する部分も Dagger に任せるようにしてみましょう。

まず AppComponent に inject される側を引数にとる void メソッドを定義します。

view plainprint?

1. @Component(modules = ApiModule.class)  
2. public interface AppComponent {  
3.   
4.     void inject(MainActivity target);  
5. }  

@Component(modules = ApiModule.class) public interface AppComponent { void inject(MainActivity target); } そして、Dagger で注入したい field に @Inject アノテーション をつけます。
field の代入していた部分を上記で定義した inject メソッドを呼ぶように変更します。

view plainprint?

1. public class MainActivity extends AppCompatActivity {  
2.   
3.     @Inject  
4.     ApiService apiService;  
5.   
6.     @Inject  
7.     HogeService hogeService;  
8.   
9.     @Inject  
10.     FugaService fugaService;  
11.   
12.     @Override  
13.     protected void onCreate(Bundle savedInstanceState) {  
14.         super.onCreate(savedInstanceState);  
15.         ((MyApplication) getApplication())  
16.                 .getAppComponent()  
17.                 .inject(this);  
18.   
19.         setContentView(R.layout.activity_main);  
20.     }  
21. }  

public class MainActivity extends AppCompatActivity { @Inject ApiService apiService; @Inject HogeService hogeService; @Inject FugaService fugaService; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ((MyApplication) getApplication()) .getAppComponent() .inject(this); setContentView(R.layout.activity_main); } } AppComponent に void inject(MainActivity target) を定義したので、 MainActivity_MembersInjector が自動生成されます。

DaggerAppComponent の inject() を呼ぶと、MainActivity_MembersInjector を使って MainActivity の @Inject がついた field にインスタンスが代入されます。

view plainprint?

1. public final class DaggerAppComponent implements AppComponent {  
2.   ...  
3.   
4.   @SuppressWarnings("unchecked")  
5.   private void initialize(final Builder builder) {  
6.   
7.     this.provideApiServiceProvider = ApiModule_ProvideApiServiceFactory.create(builder.apiModule);  
8.   
9.     this.mainActivityMembersInjector =  
10.         MainActivity_MembersInjector.create(provideApiServiceProvider);  
11.   }  
12.   
13.   @Override  
14.   public void inject(MainActivity target) {  
15.     mainActivityMembersInjector.injectMembers(target);  
16.   }  
17.   
18.   ...  
19. }  

public final class DaggerAppComponent implements AppComponent { ... @SuppressWarnings("unchecked") private void initialize(final Builder builder) { this.provideApiServiceProvider = ApiModule_ProvideApiServiceFactory.create(builder.apiModule); this.mainActivityMembersInjector = MainActivity_MembersInjector.create(provideApiServiceProvider); } @Override public void inject(MainActivity target) { mainActivityMembersInjector.injectMembers(target); } ... }

view plainprint?

1. public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {  
2.   private final Provider<ApiService> apiServiceProvider;  
3.   
4.   public MainActivity_MembersInjector(Provider<ApiService> apiServiceProvider) {  
5.     assert apiServiceProvider != null;  
6.     this.apiServiceProvider = apiServiceProvider;  
7.   }  
8.   
9.   public static MembersInjector<MainActivity> create(Provider<ApiService> apiServiceProvider) {  
10.     return new MainActivity_MembersInjector(apiServiceProvider);  
11.   }  
12.   
13.   @Override  
14.   public void injectMembers(MainActivity instance) {  
15.     if (instance == null) {  
16.       throw new NullPointerException("Cannot inject members into a null reference");  
17.     }  
18.     instance.apiService = apiServiceProvider.get();  
19.   }  
20.   
21.   public static void injectApiService(  
22.       MainActivity instance, Provider<ApiService> apiServiceProvider) {  
23.     instance.apiService = apiServiceProvider.get();  
24.   }  
25. }  

public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> { private final Provider<ApiService> apiServiceProvider; public MainActivity_MembersInjector(Provider<ApiService> apiServiceProvider) { assert apiServiceProvider != null; this.apiServiceProvider = apiServiceProvider; } public static MembersInjector<MainActivity> create(Provider<ApiService> apiServiceProvider) { return new MainActivity_MembersInjector(apiServiceProvider); } @Override public void injectMembers(MainActivity instance) { if (instance == null) { throw new NullPointerException("Cannot inject members into a null reference"); } instance.apiService = apiServiceProvider.get(); } public static void injectApiService( MainActivity instance, Provider<ApiService> apiServiceProvider) { instance.apiService = apiServiceProvider.get(); } }

Singleton

Retrofit では毎回インスタンスを生成するとコストが高いので ApiService は Singleton にしたいのでした。

ApiModule の provideApiService() に @Singleton アノテーションをつけると、provideApiService() で生成されたインスタンスは Singleton として保持されます。

view plainprint?

1. @Module  
2. public class ApiModule {  
3.   
4.     @Singleton  
5.     @Provides  
6.     public ApiService provideApiService() {  
7.         final Retrofit retrofit = ...;  
8.         return retrofit.create(ApiService.class);  
9.     }  
10. }  

@Module public class ApiModule { @Singleton @Provides public ApiService provideApiService() { final Retrofit retrofit = ...; return retrofit.create(ApiService.class); } } 実際に Singleton として管理するのは Component の実装クラスです。
どの Component が管理するかを指定するために、管理する Component にも @Singleton をつけます。

view plainprint?

1. @Component(modules = ApiModule.class)  
2. @Singleton  
3. public interface AppComponent {  
4.     ...  
5. }  

@Component(modules = ApiModule.class) @Singleton public interface AppComponent { ... } DaggerAppComponent では、@Singleton アノテーションがついた @Provides メソッドは、DoubleCheck クラスを使って Singleton として管理するようになります。

view plainprint?

1. public final class DaggerAppComponent implements AppComponent {  
2.   ...  
3.   
4.   @SuppressWarnings("unchecked")  
5.   private void initialize(final Builder builder) {  
6.   
7.     this.provideApiServiceProvider =  
8.         DoubleCheck.provider(ApiModule_ProvideApiServiceFactory.create(builder.apiModule));  
9.   
10.     ...  
11.   }  
12. }  

public final class DaggerAppComponent implements AppComponent { ... @SuppressWarnings("unchecked") private void initialize(final Builder builder) { this.provideApiServiceProvider = DoubleCheck.provider(ApiModule_ProvideApiServiceFactory.create(builder.apiModule)); ... } } ちなみに @Singleton はスコープです。定義に @Scope がついています。

view plainprint?

1. @Scope  
2. @Documented  
3. @Retention(RUNTIME)  
4. public @interface Singleton {}  

@Scope @Documented @Retention(RUNTIME) public @interface Singleton {} 独自のスコープを作ることもできます。スコープの詳しい説明はここではしません。

テスト

テスト時に mock 化した ApiService インスタンスを注入することを考えましょう。

まず MyApplication が持つ AppComponent を差し替えられるように、テスト用のメソッドを用意します。

view plainprint?

1. public class MyApplication extends Application {  
2.   
3.     private AppComponent appComponent;  
4.   
5.     ...  
6.   
7.     @VisibleForTesting  
8.     public void setAppComponent(AppComponent appComponent) {  
9.         this.appComponent = appComponent;  
10.     }  
11. }  

public class MyApplication extends Application { private AppComponent appComponent; ... @VisibleForTesting public void setAppComponent(AppComponent appComponent) { this.appComponent = appComponent; } } 次に ApiModule を継承した MockApiModule を用意します。

view plainprint?

1. public class MockApiModule extends ApiModule {  
2.   
3.     private final ApiService service;  
4.   
5.     public MockApiModule(ApiService service) {  
6.         this.service = service;  
7.     }  
8.   
9.     @Override  
10.     public ApiService provideApiService() {  
11.         return service;  
12.     }  
13. }  

public class MockApiModule extends ApiModule { private final ApiService service; public MockApiModule(ApiService service) { this.service = service; } @Override public ApiService provideApiService() { return service; } } DaggerAppComponent.Builder で ApiModule を差し替えることができるので、mock 化した ApiService インスタンス持った MockApiModule に差し替えます。

view plainprint?

1. final AppComponent appComponent = DaggerAppComponent.builder()  
2.         .apiModule(new MockApiModule(mockApiService))  
3.         .build();  

final AppComponent appComponent = DaggerAppComponent.builder() .apiModule(new MockApiModule(mockApiService)) .build(); テストでは MyApplication が持つ AppComponent を差し替えてから MainActivity を起動します。
こうすることで MainActivity には MockApiModule を介して mock 化された ApiService インスタンスが注入されます。

view plainprint?

1. @RunWith(AndroidJUnit4.class)  
2. public class MainActivityUiTest {  
3.       
4.     @Rule  
5.     ActivityTestRule<MainActivity> activityTestRule  
6.             = new ActivityTestRule<>(MainActivity.class, false, false);  
7.   
8.     @Test  
9.     public void test() throws Exception {  
10.         final Context context = InstrumentationRegistry.getTargetContext();  
11.   
12.         final ApiService mockApiService = mock(ApiService.class);  
13.           
14.         ...  
15.   
16.         final AppComponent appComponent = DaggerAppComponent.builder()  
17.                 .apiModule(new MockApiModule(mockApiService))  
18.                 .build();  
19.   
20.         ((MyApplication) context.getApplicationContext())  
21.                 .setAppComponent(appComponent);  
22.   
23.         activityTestRule.launchActivity(new Intent(context, MainActivity.class));  
24.   
25.         ...  
26.     }  
27. }  

@RunWith(AndroidJUnit4.class) public class MainActivityUiTest { @Rule ActivityTestRule<MainActivity> activityTestRule = new ActivityTestRule<>(MainActivity.class, false, false); @Test public void test() throws Exception { final Context context = InstrumentationRegistry.getTargetContext(); final ApiService mockApiService = mock(ApiService.class); ... final AppComponent appComponent = DaggerAppComponent.builder() .apiModule(new MockApiModule(mockApiService)) .build(); ((MyApplication) context.getApplicationContext()) .setAppComponent(appComponent); activityTestRule.launchActivity(new Intent(context, MainActivity.class)); ... } }

余談

Subcomponent 使ってません。
Activity ごとに Subcomponent にわけるべきなのか私にはまだわかりません。
Subcomponent に分けるということは Component が1つの場合にくらべて明らかに複雑性は増します。
そのデメリットを上回るメリットがわかりませんでした。
（MVPとかMVVMではメリットあるのかな？Androidの思想に沿った設計が好きでそういうの取り入れてないのでわからないです）